diff --git a/.env.template b/.env.template index 58507a8ba..c0fbbcf5e 100644 --- a/.env.template +++ b/.env.template @@ -15,6 +15,7 @@ ALCHEMY_ROPSTEN_KEY=add-your-alchemy-key-here ALCHEMY_KOVAN_KEY=add-your-alchemy-key-here # Matic key used to deploy smart contracts +# Key should be the full URL MATIC_MAINNET_KEY=add-your-matic-vigil-key-here MATIC_MUMBAI_KEY=add-your-matic-vigil-key-here @@ -25,7 +26,7 @@ INFURA_KEY=add-your-infura-key-here ETHERSCAN_API_KEY=add-your-etherscan-api-key-here # CoinMarketCap API key used for gas reporting -CMC_KEY=add-your-alchemy-key-here +CMC_KEY=add-your-coinmarketcap-key-here # Gas price (in Gwei) used to deploy smart contract. # Note: Check current gas price in the Ethereum network before deploying. diff --git a/.eslintrc.json b/.eslintrc.json index a99be7d10..e6bceaf34 100644 --- a/.eslintrc.json +++ b/.eslintrc.json @@ -7,6 +7,7 @@ "parserOptions": { "project": "tsconfig.json" }, + "ignorePatterns": ["artifacts/**", "cache/**", "docs/**", "types/**"], "plugins": ["prettier", "simple-import-sort", "@typescript-eslint"], "rules": { "@typescript-eslint/no-empty-interface": "off", @@ -18,17 +19,21 @@ "argsIgnorePattern": "^_" } ], + "@typescript-eslint/no-extraneous-class": "off", "@typescript-eslint/promise-function-async": "off", "@typescript-eslint/restrict-template-expressions": "off", "@typescript-eslint/strict-boolean-expressions": "off", "@typescript-eslint/no-non-null-assertion": "warn", "@typescript-eslint/no-unused-expressions": "off", + "@typescript-eslint/require-array-sort-compare": "off", "arrow-parens": "error", + "no-extra-semi": "error", "no-unused-vars": "off", "no-useless-return": "off", "no-void": "off", + "prefer-arrow-callback": "error", + "prettier/prettier": "error", "semi": ["error", "never"], - "no-extra-semi": "error", "simple-import-sort/imports": "error" } } diff --git a/.github/workflows/run-ci.yml b/.github/workflows/run-ci-mainnet.yml similarity index 89% rename from .github/workflows/run-ci.yml rename to .github/workflows/run-ci-mainnet.yml index e67fddad2..3352c7a53 100644 --- a/.github/workflows/run-ci.yml +++ b/.github/workflows/run-ci-mainnet.yml @@ -4,7 +4,7 @@ on: [pull_request] jobs: test: - name: Build Project + name: Build Project - Mainnet runs-on: ubuntu-latest environment: testing-keys env: @@ -28,9 +28,9 @@ jobs: with: node-version: '14' registry-url: 'https://registry.npmjs.org/' - - name: Install dependencies + - name: Install dependencies - Mainnet run: | yarn --network-concurrency 1 - - name: Compiling and Executing Tests + - name: Compiling and Executing Tests - Mainnet run: | yarn test mainnet diff --git a/.github/workflows/run-ci-polygon.yml b/.github/workflows/run-ci-polygon.yml new file mode 100644 index 000000000..83d9f1f41 --- /dev/null +++ b/.github/workflows/run-ci-polygon.yml @@ -0,0 +1,36 @@ +name: Compile & Run Smart Contract Unit Tests + +on: [pull_request] + +jobs: + test: + name: Build Project - Polygon + runs-on: ubuntu-latest + environment: testing-keys + env: + MNEMONIC_KEY: ${{ secrets.MNEMONIC_KEY }} + ALCHEMY_MAINNET_KEY: ${{ secrets.ALCHEMY_MAINNET_KEY }} + ALCHEMY_RINKEBY_KEY: ${{ secrets.ALCHEMY_RINKEBY_KEY }} + ALCHEMY_ROPSTEN_KEY: ${{ secrets.ALCHEMY_ROPSTEN_KEY }} + ALCHEMY_KOVAN_KEY: ${{ secrets.ALCHEMY_KOVAN_KEY }} + MATIC_MAINNET_KEY: ${{ secrets.MATIC_MAINNET_KEY }} + MATIC_MUMBAI_KEY: ${{ secrets.MATIC_MUMBAI_KEY }} + INFURA_KEY: ${{ secrets.INFURA_KEY }} + ETHERSCAN_API_KEY: ${{ secrets.ETHERSCAN_API_KEY }} + CMC_KEY: ${{ secrets.CMC_KEY }} + GAS_PRICE_GWEI_KEY: 20 + GAS_WEI_KEY: 2500000 + ADDRESS_COUNT_KEY: 20 + DEFAULT_ADDRESS_INDEX_KEY: 0 + steps: + - uses: actions/checkout@v2 + - uses: actions/setup-node@v2 + with: + node-version: '14' + registry-url: 'https://registry.npmjs.org/' + - name: Install dependencies - Polygon + run: | + yarn --network-concurrency 1 + - name: Compiling and Executing Tests - Polygon + run: | + yarn test polygon diff --git a/.prettierrc b/.prettierrc index 8b29d4e49..80b66ee18 100644 --- a/.prettierrc +++ b/.prettierrc @@ -10,6 +10,7 @@ { "files": "*.sol", "options": { + "compiler": "0.8.0", "tabWidth": 4, "singleQuote": false, "explicitTypes": "always", @@ -19,7 +20,6 @@ { "files": "*.ts", "options": { - "printWidth": 80 } } ] diff --git a/.solhint.json b/.solhint.json index d52deb49e..4a982c0d6 100644 --- a/.solhint.json +++ b/.solhint.json @@ -1,16 +1,17 @@ { "extends": "solhint:recommended", + "plugins": ["prettier"], "rules": { - "func-visibility": ["warn", { "ignoreConstructors": true }], "check-send-result": "warn", - "reentrancy": "warn", - "quotes": "error", - "compiler-version": "off", "contract-name-camelcase": "off", - "no-empty-blocks": "off", "func-name-mixedcase": "off", + "func-visibility": ["warn", { "ignoreConstructors": true }], + "max-line-length": ["warn", 120], + "no-empty-blocks": "off", "no-inline-assembly": "off", + "prettier/prettier": "warn", + "quotes": "error", + "reentrancy": "warn", "var-name-mixedcase": "off" - }, - "plugins": ["prettier"] + } } diff --git a/config/asset-settings.ts b/config/asset-settings.ts index 1353f4d18..88bf107e8 100644 --- a/config/asset-settings.ts +++ b/config/asset-settings.ts @@ -1,53 +1,120 @@ import { AssetSettings } from '../types/custom/config-types' import { AssetType } from '../utils/consts' -const mainnetAssetSettings: AssetSettings = { - DAI: [ - { key: 'cToken', value: 'CDAI', type: AssetType.Address }, - { key: 'aToken', value: 'ADAI', type: AssetType.Address }, - { key: 'yVault', value: 'YDAI', type: AssetType.Address }, - { key: 'pPool', value: 'PCDAI', type: AssetType.Address }, - { key: 'MaxLoanAmount', value: 25000, type: AssetType.Amount }, - { key: 'MaxTVL', value: 10000000, type: AssetType.Amount }, - { key: 'MaxDebtRatio', value: 5000, type: AssetType.Uint }, - ], - USDC: [{ key: 'cToken', value: 'CUSDC', type: AssetType.Address }], - WETH: [{ key: 'cToken', value: 'CETH', type: AssetType.Address }], -} - export const assetSettings: Record = { kovan: { DAI: [ - { key: 'cToken', value: 'CDAI', type: AssetType.Address }, + { key: 'cToken', value: 'CDAI', type: AssetType.Token }, { key: 'MaxLoanAmount', value: 25000, type: AssetType.Amount }, { key: 'MaxTVL', value: 100000, type: AssetType.Amount }, { key: 'MaxDebtRatio', value: 5000, type: AssetType.Uint }, ], - USDC: [{ key: 'cToken', value: 'CUSDC', type: AssetType.Address }], - WETH: [{ key: 'cToken', value: 'CETH', type: AssetType.Address }], + USDC: [{ key: 'cToken', value: 'CUSDC', type: AssetType.Token }], + WETH: [{ key: 'cToken', value: 'CETH', type: AssetType.Token }], }, rinkeby: { DAI: [ - { key: 'cToken', value: 'CDAI', type: AssetType.Address }, - { key: 'pPool', value: 'PCDAI', type: AssetType.Address }, + { key: 'cToken', value: 'CDAI', type: AssetType.Token }, + { + key: 'pPool', + value: '0x4706856FA8Bb747D50b4EF8547FE51Ab5Edc4Ac2', + type: AssetType.Address, + }, { key: 'MaxLoanAmount', value: 25000, type: AssetType.Amount }, { key: 'MaxTVL', value: 100000, type: AssetType.Amount }, { key: 'MaxDebtRatio', value: 5000, type: AssetType.Uint }, ], - USDC: [{ key: 'cToken', value: 'CUSDC', type: AssetType.Address }], - WETH: [{ key: 'cToken', value: 'CETH', type: AssetType.Address }], + USDC: [ + { key: 'cToken', value: 'CUSDC', type: AssetType.Token }, + { + key: 'pPool', + value: '0xde5275536231eCa2Dd506B9ccD73C028e16a9a32', + type: AssetType.Address, + }, + ], + WETH: [{ key: 'cToken', value: 'CETH', type: AssetType.Token }], }, ropsten: { DAI: [ - { key: 'cToken', value: 'CDAI', type: AssetType.Address }, + { key: 'cToken', value: 'CDAI', type: AssetType.Token }, { key: 'MaxLoanAmount', value: 25000, type: AssetType.Amount }, { key: 'MaxTVL', value: 100000, type: AssetType.Amount }, { key: 'MaxDebtRatio', value: 5000, type: AssetType.Uint }, ], - USDC: [{ key: 'cToken', value: 'CUSDC', type: AssetType.Address }], - WETH: [{ key: 'cToken', value: 'CETH', type: AssetType.Address }], + USDC: [{ key: 'cToken', value: 'CUSDC', type: AssetType.Token }], + WETH: [{ key: 'cToken', value: 'CETH', type: AssetType.Token }], + }, + mainnet: { + DAI: [ + { key: 'cToken', value: 'CDAI', type: AssetType.Token }, + { key: 'aToken', value: 'ADAI', type: AssetType.Token }, + { key: 'yVault', value: 'YDAI', type: AssetType.Token }, + { + key: 'pPool', + value: '0xEBfb47A7ad0FD6e57323C8A42B2E5A6a4F68fc1a', + type: AssetType.Address, + }, + { key: 'MaxLoanAmount', value: 25000, type: AssetType.Amount }, + { key: 'MaxTVL', value: 10000000, type: AssetType.Amount }, + { key: 'MaxDebtRatio', value: 5000, type: AssetType.Uint }, + ], + USDT: [ + { key: 'cToken', value: 'CUSDT', type: AssetType.Token }, + { key: 'aToken', value: 'AUSDT', type: AssetType.Token }, + { key: 'yVault', value: 'YUSDT', type: AssetType.Token }, + { + key: 'pPool', + value: '0x481f1BA81f7C01400831DfF18215961C3530D118', + type: AssetType.Address, + }, + { key: 'MaxLoanAmount', value: 25000, type: AssetType.Amount }, + { key: 'MaxTVL', value: 10000000, type: AssetType.Amount }, + { key: 'MaxDebtRatio', value: 5000, type: AssetType.Uint }, + ], + USDC: [ + { key: 'cToken', value: 'CUSDC', type: AssetType.Token }, + { + key: 'pPool', + value: '0xde9ec95d7708b8319ccca4b8bc92c0a3b70bf416', + type: AssetType.Address, + }, + ], + WETH: [{ key: 'cToken', value: 'CETH', type: AssetType.Token }], + }, + polygon: { + DAI: [ + { key: 'aToken', value: 'ADAI', type: AssetType.Token }, + { + key: 'pPool', + value: '0xFECFa775643eb8C0F755491Ba4569e501764DA51', + type: AssetType.Address, + }, + { key: 'MaxLoanAmount', value: 25000, type: AssetType.Amount }, + { key: 'MaxTVL', value: 10000000, type: AssetType.Amount }, + { key: 'MaxDebtRatio', value: 5000, type: AssetType.Uint }, + ], + USDT: [ + { key: 'aToken', value: 'AUSDT', type: AssetType.Token }, + { + key: 'pPool', + value: '0x887E17D791Dcb44BfdDa3023D26F7a04Ca9C7EF4', + type: AssetType.Address, + }, + { key: 'MaxLoanAmount', value: 25000, type: AssetType.Amount }, + { key: 'MaxTVL', value: 10000000, type: AssetType.Amount }, + { key: 'MaxDebtRatio', value: 5000, type: AssetType.Uint }, + ], + USDC: [{ key: 'aToken', value: 'AUSDC', type: AssetType.Token }], + WETH: [{ key: 'aToken', value: 'AETH', type: AssetType.Token }], + }, + polygon_mumbai: { + DAI: [ + { key: 'aToken', value: 'ADAI', type: AssetType.Token }, + { key: 'MaxLoanAmount', value: 25000, type: AssetType.Amount }, + { key: 'MaxTVL', value: 10000000, type: AssetType.Amount }, + { key: 'MaxDebtRatio', value: 5000, type: AssetType.Uint }, + ], + USDC: [{ key: 'aToken', value: 'AUSDC', type: AssetType.Token }], + WETH: [{ key: 'aToken', value: 'AETH', type: AssetType.Token }], }, - hardhat: mainnetAssetSettings, - localhost: mainnetAssetSettings, - mainnet: mainnetAssetSettings, } diff --git a/config/atms.ts b/config/atms.ts index 97db443e9..3ae2f5c28 100644 --- a/config/atms.ts +++ b/config/atms.ts @@ -30,4 +30,6 @@ export const atms: Record = { hardhat: mainnetATMs, localhost: mainnetATMs, mainnet: mainnetATMs, + polygon: mainnetATMs, + polygon_mumbai: mainnetATMs, } diff --git a/config/chainlink.ts b/config/chainlink.ts index f2fe9d1ad..396c1b1ac 100644 --- a/config/chainlink.ts +++ b/config/chainlink.ts @@ -54,6 +54,44 @@ const mainnetChainlink: Chainlink = { }, } +const polygonChainlink: Chainlink = { + MATIC_ETH: { + baseTokenName: 'MATIC', + quoteTokenName: 'ETH', + address: '0x327e23A4855b6F663a28c5161541d69Af8973302', + }, + USDC_ETH: { + baseTokenName: 'USDC', + quoteTokenName: 'ETH', + address: '0xefb7e6be8356cCc6827799B6A7348eE674A80EaE', + }, + USDT_ETH: { + baseTokenName: 'USDT', + quoteTokenName: 'ETH', + address: '0xf9d5AAC6E5572AEFa6bd64108ff86a222F69B64d', + }, + DAI_ETH: { + baseTokenName: 'DAI', + quoteTokenName: 'ETH', + address: '0xFC539A559e170f848323e19dfD66007520510085', + }, + LINK_ETH: { + baseTokenName: 'LINK', + quoteTokenName: 'ETH', + address: '0xb77fa460604b9C6435A235D057F7D319AC83cb53', + }, + AAVE_ETH: { + baseTokenName: 'AAVE', + quoteTokenName: 'ETH', + address: '0xbE23a3AA13038CfC28aFd0ECe4FdE379fE7fBfc4', + }, + SUSHI_USDC: { + baseTokenName: 'SUSHI', + quoteTokenName: 'USDC', + address: '0x49B0c695039243BBfEb8EcD054EB70061fd54aa0', + }, +} + export const chainlink: Record = { kovan: { ETH_USDC: { @@ -121,7 +159,30 @@ export const chainlink: Record = { address: '0xD4d78d8e18d4717F5eE8801335eE5b5B97a4b824', }, }, - hardhat: mainnetChainlink, - localhost: mainnetChainlink, + polygon: polygonChainlink, + polygon_mumbai: { + USDC_MATIC: { + baseTokenName: 'MATIC', + quoteTokenName: 'USDC', + address: '0xd0D5e3DB44DE05E9F294BB0a3bEEaF030DE24Ada', // MATIC-USD + }, + DAI_MATIC: { + baseTokenName: 'MATIC', + quoteTokenName: 'DAI', + address: '0xd0D5e3DB44DE05E9F294BB0a3bEEaF030DE24Ada', // MATIC-USD + }, + USDC_ETH: { + baseTokenName: 'ETH', + quoteTokenName: 'USDC', + address: '0x0715A7794a1dc8e42615F059dD6e406A6594651A', // ETH-USD + }, + DAI_ETH: { + baseTokenName: 'ETH', + quoteTokenName: 'DAI', + address: '0x0715A7794a1dc8e42615F059dD6e406A6594651A', // ETH-USD + }, + }, + hardhat: polygonChainlink, + localhost: polygonChainlink, mainnet: mainnetChainlink, } diff --git a/config/dapps.ts b/config/dapps.ts new file mode 100644 index 000000000..5fa04da3c --- /dev/null +++ b/config/dapps.ts @@ -0,0 +1,25 @@ +import { Tokens } from '../types/custom/config-types' + +const mainnetDappAddresses: Tokens = { + aaveLendingPoolAddressProvider: '0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5', + sushiswapV2RouterAddress: '0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F', + uniswapV2RouterAddress: '0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D', + compoundComptrollerAddress: '0x3d9819210a31b4961b30ef54be2aed79b9c9cd3b', +} + +const polygonDappAddresses: Tokens = { + aaveLendingPoolAddressProvider: '0xd05e3E715d945B59290df0ae8eF85c1BdB684744', + sushiswapV2RouterAddress: '0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506', + uniswapV2RouterAddress: '0x0000000000000000000000000000000000000000', + compoundComptrollerAddress: '', +} + +export const dapps: Record = { + mainnet: mainnetDappAddresses, + kovan: mainnetDappAddresses, + rinkeby: mainnetDappAddresses, + ropsten: mainnetDappAddresses, + polygon: polygonDappAddresses, + polygon_mumbai: polygonDappAddresses, + hardhat: polygonDappAddresses, +} diff --git a/config/index.ts b/config/index.ts index 8afbd17f7..4d0d6782b 100644 --- a/config/index.ts +++ b/config/index.ts @@ -1,10 +1,23 @@ import { Network } from 'hardhat/types' import path from 'path' -import { Tokens } from '../types/custom/config-types' +import { + AssetSettings, + ATMs, + Chainlink, + Market, + NetworkTokens, + NFTMerkleTree, + Nodes, + PlatformSettings, + Signers, + TierInfo, + Tokens, +} from '../types/custom/config-types' import { assetSettings } from './asset-settings' import { atms } from './atms' import { chainlink } from './chainlink' +import { dapps } from './dapps' import { markets } from './markets' import { nftMerkleTree, tiers as nftTiers } from './nft' import { nodes } from './nodes' @@ -15,24 +28,28 @@ import { tokens } from './tokens' export const getNetworkName = (network: Network): string => process.env.FORKING_NETWORK ?? network.name -export const getAssetSettings = (network: Network) => +export const getAssetSettings = (network: Network): AssetSettings => assetSettings[getNetworkName(network)] -export const getATMs = (network: Network) => atms[getNetworkName(network)] +export const getATMs = (network: Network): ATMs => atms[getNetworkName(network)] -export const getChainlink = (network: Network) => +export const getChainlink = (network: Network): Chainlink => chainlink[getNetworkName(network)] -export const getMarkets = (network: Network) => markets[getNetworkName(network)] +export const getMarkets = (network: Network): Market[] => + markets[getNetworkName(network)] -export const getNodes = (network: Network) => nodes[getNetworkName(network)] +export const getNodes = (network: Network): Nodes => + nodes[getNetworkName(network)] -export const getPlatformSettings = (network: Network) => +export const getPlatformSettings = (network: Network): PlatformSettings => platformSettings[getNetworkName(network)] -export const getSigners = (network: Network) => signers[network.name] +export const getSigners = (network: Network): Signers => signers[network.name] -export const getTokens = (network: Network) => { +export const getTokens = ( + network: Network +): NetworkTokens & { all: Tokens } => { const networkTokens = tokens[getNetworkName(network)] const all: Tokens = Object.keys(networkTokens).reduce((map, type) => { // @ts-expect-error keys @@ -45,7 +62,33 @@ export const getTokens = (network: Network) => { } } -export const getNFT = (network: Network) => { +export const getNativeToken = (network: Network): string => { + const tokens = getTokens(network) + let wrappedNativeToken: string + const networkName = getNetworkName(network) + if ( + networkName === 'mainnet' || + networkName === 'kovan' || + networkName === 'rinkeby' || + networkName === 'ropsten' + ) { + wrappedNativeToken = tokens.erc20.WETH + } else { + wrappedNativeToken = tokens.erc20.WMATIC + } + return wrappedNativeToken +} + +export const getDappAddresses = (network: Network): Tokens => + dapps[getNetworkName(network)] + +export const getNFT = ( + network: Network +): { + tiers: TierInfo[] + merkleTrees: NFTMerkleTree + distributionsOutputFile: string +} => { const distributionsOutputFile = path.resolve( path.join( __dirname, diff --git a/config/markets.ts b/config/markets.ts index d094f419b..a94991dd4 100644 --- a/config/markets.ts +++ b/config/markets.ts @@ -26,6 +26,36 @@ const mainnetMarkets: Market[] = [ }, ] +const polygonMarkets: Market[] = [ + { + lendingToken: 'USDT', + collateralTokens: ['WMATIC', 'WETH'], + strategy: { + name: 'TTokenAaveStrategy_1', + initArgs: [ + { + type: 'TokenSymbol', + value: 'AUSDT', + }, + { + type: 'ProtocolAddressConstant', + value: 'aaveLendingPoolAddressProvider', + }, + { + // Balance Ratio Min + type: 'Number', + value: '2000', + }, + { + // Balance Ratio Max + type: 'Number', + value: '4000', + }, + ], + }, + }, +] + export const markets: Record = { kovan: [ { @@ -102,7 +132,9 @@ export const markets: Record = { }, }, ], - hardhat: mainnetMarkets, - localhost: mainnetMarkets, + hardhat: polygonMarkets, + localhost: polygonMarkets, mainnet: mainnetMarkets, + polygon: polygonMarkets, + polygon_mumbai: polygonMarkets, } diff --git a/config/nft.ts b/config/nft.ts index f3639a7aa..a78deb80e 100644 --- a/config/nft.ts +++ b/config/nft.ts @@ -497,4 +497,6 @@ export const nftMerkleTree: Record = { hardhat: testnetNFTMerkle, localhost: testnetNFTMerkle, mainnet: mainnetNFTMerkle, + polygon: testnetNFTMerkle, + polygon_mumbai: testnetNFTMerkle, } diff --git a/config/nodes.ts b/config/nodes.ts index 0fbd7dc7c..4a6fec8a1 100644 --- a/config/nodes.ts +++ b/config/nodes.ts @@ -12,4 +12,6 @@ export const nodes: Record = { hardhat: {}, localhost: {}, mainnet: {}, + polygon: {}, + polygon_mumbai: {}, } diff --git a/config/platform-settings.ts b/config/platform-settings.ts index 5494d05ae..435ca85cf 100644 --- a/config/platform-settings.ts +++ b/config/platform-settings.ts @@ -9,7 +9,7 @@ const mainnetPlatformSettings: PlatformSettings = { }, RequiredSubmissionsPercentage: { processOnDeployment: true, - value: 8000, + value: 100, min: 0, max: 10000, }, @@ -253,4 +253,6 @@ export const platformSettings: Record = { hardhat: mainnetPlatformSettings, localhost: mainnetPlatformSettings, mainnet: mainnetPlatformSettings, + polygon: mainnetPlatformSettings, + polygon_mumbai: mainnetPlatformSettings, } diff --git a/config/signers.ts b/config/signers.ts index 7cb14c8ab..94b73cff0 100644 --- a/config/signers.ts +++ b/config/signers.ts @@ -16,7 +16,9 @@ export const signers: Record = { '0x312a5217c12aD9b206A0380B4B134ef2b02d09A5', ], ropsten: [], - hardhat: [], - localhost: [], + hardhat: ['0xd380829600546D4B3b6aC5F0d9D5ED97cF799b92'], + localhost: ['0xd380829600546D4B3b6aC5F0d9D5ED97cF799b92'], mainnet: [], + polygon: ['0xd380829600546D4B3b6aC5F0d9D5ED97cF799b92'], + polygon_mumbai: ['0xd380829600546D4B3b6aC5F0d9D5ED97cF799b92'], } diff --git a/config/tokens.ts b/config/tokens.ts index 4ccfbf922..ac0487f0d 100644 --- a/config/tokens.ts +++ b/config/tokens.ts @@ -6,17 +6,27 @@ const mainnetTokens: NetworkTokens = { CDAI: '0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643', CUSDC: '0x39aa39c021dfbae8fac545936693ac917d5e7563', CETH: '0x4ddc2d193948926d02f9b1fe9e1daa0718270ed5', + CUSDT: '0xf650c3d88d12db855b8bf7d11be6c55a4e07dcc9', + }, + aave: { + ADAI: '0x028171bCA77440897B824Ca71D1c56caC55b68A3', + AUSDT: '0x3Ed3B47Dd13EC9a98b44e6204A523E766B225811', + }, + poolTogether: { + PTDAI: '0x334cbb5858417aee161b53ee0d5349ccf54514cf', + PTDAIS: '0x0A2E7f69fe9588fa7fBa5F5864236883Cd4AaC6d', + }, + yearn: { + YDAI: '0x19D3364A399d251E894aC732651be8B0E4e85001', // v2 - DAI yVault + YUSDT: '0x7Da96a3891Add058AdA2E826306D812C638D87a7', }, erc20: { // Compound COMP: '0xc00e94cb662c3520282e6f5717214004a7f26888', // Aave AAVE: '0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9', - ADAI: '0x028171bCA77440897B824Ca71D1c56caC55b68A3', // Pool Together - PCDAI: '0xEBfb47A7ad0FD6e57323C8A42B2E5A6a4F68fc1a', // Yearn - YDAI: '0x19D3364A399d251E894aC732651be8B0E4e85001', // v2 - DAI yVault // ERC20 WETH: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', DAI: '0x6B175474E89094C44Da98b954EedeAC495271d0F', @@ -30,26 +40,52 @@ const mainnetTokens: NetworkTokens = { }, } +const polygonTokens: NetworkTokens = { + aave: { + ADAI: '0x27F8D03b3a2196956ED754baDc28D73be8830A6e', // amDAI + AUSDC: '0x1a13F4Ca1d028320A707D99520AbFefca3998b7F', + AETH: '0x28424507fefb6f7f8E9D3860F56504E4e5f5f390', //amWETH + AUSDT: '0x60D55F02A771d515e077c9C2403a1ef324885CeC', // amUSDT + }, + poolTogether: { + PTDAI: '0x3e35681E6439961EC7F2b1ABaB6b967D6a645270', + PTDAIS: '0xB102A0Ba3707A94a64CE63c7BeA8039680e1ad5C', + PTUSDT: '0x9ecB26631098973834925eb453De1908Ea4bdD4e', + }, + erc20: { + // Aave + AAVE: '0xD6DF932A45C0f255f85145f286eA0b292B21C90B', + // Pool Together + // ERC20 + WETH: '0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619', + WMATIC: '0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270', + DAI: '0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063', + USDC: '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174', + USDT: '0xc2132D05D31c914a87C6611C10748AEb04B58e8F', + LINK: '0x53E0bca35eC356BD5ddDFebbD1Fc0fD03FaBad39', + WBTC: '0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6', + }, +} + export const tokens: Record = { kovan: { compound: { CDAI: '0xf0d0eb522cfa50b716b3b1604c4f0fa6f04376ad', CUSDC: '0x4a92e71227d294f041bd82dd8f78591b75140d63', CETH: '0x41b5844f4680a8c38fbb695b7f9cfd1f64474a72', + CUSDT: '0x3f0a0ea2f86bae6362cf9799b523ba06647da018', }, erc20: { // Compound COMP: '0x61460874a7196d6a22d1ee4922473664b3e95270', // Aave - ADAI: '0x0000000000000000000000000000000000000000', // Pool Together - PCDAI: '0x0000000000000000000000000000000000000000', // Yearn - YDAI: '0x0000000000000000000000000000000000000000', // ERC20 WETH: '0xd0a1e359811322d97991e03f863a0c30c2cf029c', DAI: '0x4f96fe3b7a6cf9725f59d353f723c1bdb64ca6aa', USDC: '0xb7a4f3e9097c08da09517b5ab877f7a917224ede', + USDT: '0xA68895Df8F959F5827A6B6427C0176044A4beba6', LINK: '0xa36085F69e2889c224210F603D836748e7dC0088', }, }, @@ -58,20 +94,18 @@ export const tokens: Record = { CDAI: '0x6D7F0754FFeb405d23C51CE938289d4835bE3b14', CUSDC: '0x5B281A6DdA0B271e91ae35DE655Ad301C976edb1', CETH: '0xd6801a1dffcd0a410336ef88def4320d6df1883e', + CUSDT: '0x2fb298bdbef468638ad6653ff8376575ea41e768', }, erc20: { // Compound - COMP: '0x0000000000000000000000000000000000000000', // Aave - ADAI: '0x0000000000000000000000000000000000000000', // Pool Together - PCDAI: '0x4706856FA8Bb747D50b4EF8547FE51Ab5Edc4Ac2', // Yearn - YDAI: '0x0000000000000000000000000000000000000000', // ERC20 WETH: '0xc778417E063141139Fce010982780140Aa0cD5Ab', DAI: '0x5592EC0cfb4dbc12D3aB100b257153436a1f0FEa', USDC: '0x4DBCdF9B62e891a7cec5A2568C3F4FAF9E8Abe2b', + USDT: '0x3B00Ef435fA4FcFF5C209a37d1f3dcff37c705aD', LINK: '0x01BE23585060835E02B77ef475b0Cc51aA1e0709', }, }, @@ -80,24 +114,45 @@ export const tokens: Record = { CDAI: '0xdb5Ed4605C11822811a39F94314fDb8F0fb59A2C', CUSDC: '0x8aF93cae804cC220D1A608d4FA54D1b6ca5EB361', CETH: '0xbe839b6d93e3ea47effcca1f27841c917a8794f3', + CUSDT: '0xf6958cf3127e62d3eb26c79f4f45d3f3b2ccded4', }, erc20: { // Compound COMP: '0xf76d4a441e4ba86a923ce32b89aff89dbccaa075', // Aave - ADAI: '0x0000000000000000000000000000000000000000', // Pool Together - PCDAI: '0x0000000000000000000000000000000000000000', // Yearn - YDAI: '0x0000000000000000000000000000000000000000', // ERC20 WETH: '0xc778417e063141139fce010982780140aa0cd5ab', DAI: '0xc2118d4d90b274016cB7a54c03EF52E6c537D957', USDC: '0x0D9C8723B343A8368BebE0B5E89273fF8D712e3C', + USDT: '0x516de3a7A567d81737e3a46ec4FF9cFD1fcb0136', LINK: '0x20fE562d797A42Dcb3399062AE9546cd06f63280', }, }, - hardhat: mainnetTokens, - localhost: mainnetTokens, + polygon: polygonTokens, + polygon_mumbai: { + aave: { + ADAI: '0x639cB7b21ee2161DF9c882483C9D55c90c20Ca3e', // amDAI + AUSDC: '0x2271e3Fef9e15046d09E1d78a8FF038c691E9Cf9', + AETH: '0x7aE20397Ca327721F013BB9e140C707F82871b56', //amWETH + AUSDT: '0xF8744C0bD8C7adeA522d6DDE2298b17284A79D1b', //amUSDT + }, + erc20: { + // Aave + AAVE: '0xc2132D05D31c914a87C6611C10748AEb04B58e8F', + // Pool Together + // ERC20 + WETH: '0x3C68CE8504087f89c640D02d133646d98e64ddd9', + WMATIC: '0x9c3C9283D3e44854697Cd22D3Faa240Cfb032889', + DAI: '0x001B3B4d0F3714Ca98ba10F6042DaEbF0B1B7b6F', + USDC: '0x2058A9D7613eEE744279e3856Ef0eAda5FCbaA7e', + USDT: '0xBD21A10F619BE90d6066c941b04e340841F1F989', + LINK: '0x326C977E6efc84E512bB9C30f76E30c160eD06FB', + WBTC: '0x0d787a4a1548f673ed375445535a6c7A1EE56180', + }, + }, + hardhat: polygonTokens, + localhost: polygonTokens, mainnet: mainnetTokens, } diff --git a/contracts/contexts/access-control/internal/is-admin-for-role.sol b/contracts/contexts/access-control/internal/is-admin-for-role.sol index 03186ecdc..c75d02751 100644 --- a/contracts/contexts/access-control/internal/is-admin-for-role.sol +++ b/contracts/contexts/access-control/internal/is-admin-for-role.sol @@ -11,9 +11,8 @@ abstract contract int_isAdminForRole_AccessControl_v1 is view returns (bool isAdminForRole_) { - isAdminForRole_ = accessControlRolesStore().roles[ - accessControlRolesStore().roles[role].adminRole - ] + isAdminForRole_ = accessControlRolesStore() + .roles[accessControlRolesStore().roles[role].adminRole] .members[account]; } } diff --git a/contracts/contexts/access-control/modifiers/entry.sol b/contracts/contexts/access-control/modifiers/entry.sol index da2602084..40920cfa8 100644 --- a/contracts/contexts/access-control/modifiers/entry.sol +++ b/contracts/contexts/access-control/modifiers/entry.sol @@ -4,7 +4,7 @@ pragma solidity ^0.8.0; import { sto_AccessControl } from "../storage.sol"; abstract contract mod_entry_AccessControl_v1 is sto_AccessControl { - modifier entry { + modifier entry() { AccessControlLayout storage layout = accessControl(); require(layout.notEntered, "RE_ENTRANCY"); layout.notEntered = false; diff --git a/contracts/contexts/initializable/modifiers/initializer.sol b/contracts/contexts/initializable/modifiers/initializer.sol index c73eff562..1b4335b44 100644 --- a/contracts/contexts/initializable/modifiers/initializer.sol +++ b/contracts/contexts/initializable/modifiers/initializer.sol @@ -4,7 +4,7 @@ pragma solidity ^0.8.0; import "../storage.sol"; abstract contract mod_initializer_Initializable_v1 is sto_Initializable { - modifier initializer { + modifier initializer() { require( !initializableStorage().initialized, "Teller: already initialized" diff --git a/contracts/escrow/EscrowClaimTokens.sol b/contracts/escrow/EscrowClaimTokens.sol index f8d23a9ea..6b9c82f3c 100644 --- a/contracts/escrow/EscrowClaimTokens.sol +++ b/contracts/escrow/EscrowClaimTokens.sol @@ -46,8 +46,8 @@ contract EscrowClaimTokens is PausableMods { function __claimEscrowTokens(uint256 loanID) internal { __claimToken(loanID, LibLoans.loan(loanID).lendingToken); - EnumerableSet.AddressSet storage tokens = - MarketStorageLib.store().escrowTokens[loanID]; + EnumerableSet.AddressSet storage tokens = MarketStorageLib.store() + .escrowTokens[loanID]; for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) { __claimToken(loanID, EnumerableSet.at(tokens, i)); } diff --git a/contracts/escrow/dapps/AaveFacet.sol b/contracts/escrow/dapps/AaveFacet.sol index bd3d3ee07..09c5c49b6 100644 --- a/contracts/escrow/dapps/AaveFacet.sol +++ b/contracts/escrow/dapps/AaveFacet.sol @@ -5,14 +5,29 @@ pragma solidity ^0.8.0; import { DappMods } from "./DappMods.sol"; import { PausableMods } from "../../settings/pausable/PausableMods.sol"; import { LibDapps } from "./libraries/LibDapps.sol"; -import { LibEscrow } from "../libraries/LibEscrow.sol"; -import { IAToken } from "./interfaces/IAToken.sol"; -import { IAaveLendingPool } from "./interfaces/IAaveLendingPool.sol"; +import { LibEscrow, ILoansEscrow } from "../libraries/LibEscrow.sol"; +import { IAToken } from "../../shared/interfaces/IAToken.sol"; +import { IAaveLendingPool } from "../../shared/interfaces/IAaveLendingPool.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; contract AaveFacet is PausableMods, DappMods { using SafeERC20 for IERC20; + + /** + * @dev The address of Aave's Lending Pool Address Provider on the deployed network + * @dev example - Aave's Lending Pool Address Provider contract address on L1 mainnet or L2 polygon mainnet + */ + address public immutable LP_ADDRESS_PROVIDER_ADDRESS; + + /** + * @notice Sets the network relevant address for Aave's Lending Pool Address Provider on protocol deployment. + * @param aaveLPAddressProvider The immutable address of Aave's Lending Pool Address Provider on the deployed network. + */ + constructor(address aaveLPAddressProvider) public { + LP_ADDRESS_PROVIDER_ADDRESS = aaveLPAddressProvider; + } + /** @notice This event is emitted every time Aave deposit is invoked successfully. @param tokenAddress address of the underlying token. @@ -56,25 +71,28 @@ contract AaveFacet is PausableMods, DappMods { address tokenAddress, uint256 amount ) public paused("", false) onlyBorrower(loanID) { - IAaveLendingPool aaveLendingPool = LibDapps.getAaveLendingPool(); - IAToken aToken = LibDapps.getAToken(tokenAddress); - uint256 aTokenBalanceBeforeDeposit = aToken.balanceOf(address(this)); - IERC20(tokenAddress).safeApprove(address(aaveLendingPool), amount); - - bytes memory callData = - abi.encode( - IAaveLendingPool.deposit.selector, - tokenAddress, - amount, - address(this), - 0 - ); - LibDapps.s().loanEscrows[loanID].callDapp( - address(aaveLendingPool), - callData + ILoansEscrow escrow = LibEscrow.e(loanID); + + IAaveLendingPool aaveLendingPool = LibDapps.getAaveLendingPool( + LP_ADDRESS_PROVIDER_ADDRESS + ); + escrow.setTokenAllowance(tokenAddress, address(aaveLendingPool)); + IAToken aToken = LibDapps.getAToken( + LP_ADDRESS_PROVIDER_ADDRESS, + tokenAddress + ); + uint256 aTokenBalanceBeforeDeposit = aToken.balanceOf(address(escrow)); + + bytes memory callData = abi.encodeWithSelector( + aaveLendingPool.deposit.selector, + tokenAddress, + amount, + address(escrow), + 0 ); + escrow.callDapp(address(aaveLendingPool), callData); - uint256 aTokenBalanceAfterDeposit = aToken.balanceOf(address(this)); + uint256 aTokenBalanceAfterDeposit = aToken.balanceOf(address(escrow)); require( aTokenBalanceAfterDeposit > aTokenBalanceBeforeDeposit, "AAVE_BALANCE_NOT_INCREASED" @@ -103,27 +121,33 @@ contract AaveFacet is PausableMods, DappMods { address tokenAddress, uint256 amount ) public paused("", false) onlyBorrower(loanID) { - IAToken aToken = LibDapps.getAToken(tokenAddress); - IAaveLendingPool aaveLendingPool = LibDapps.getAaveLendingPool(); - uint256 aTokenBalanceBeforeWithdraw = aToken.balanceOf(address(this)); + ILoansEscrow escrow = LibEscrow.e(loanID); + + IAToken aToken = LibDapps.getAToken( + LP_ADDRESS_PROVIDER_ADDRESS, + tokenAddress + ); + IAaveLendingPool aaveLendingPool = LibDapps.getAaveLendingPool( + LP_ADDRESS_PROVIDER_ADDRESS + ); + uint256 aTokenBalanceBeforeWithdraw = aToken.balanceOf(address(escrow)); require( aTokenBalanceBeforeWithdraw >= amount, "NO_BALANCE_TO_WITHDRAW" ); - bytes memory callData = - abi.encode( - IAaveLendingPool.withdraw.selector, - tokenAddress, - amount, - address(this) - ); + bytes memory callData = abi.encodeWithSelector( + aaveLendingPool.withdraw.selector, + tokenAddress, + amount, + address(escrow) + ); LibDapps.s().loanEscrows[loanID].callDapp( address(aaveLendingPool), callData ); - uint256 aTokenBalanceAfterWithdraw = aToken.balanceOf(address(this)); + uint256 aTokenBalanceAfterWithdraw = aToken.balanceOf(address(escrow)); require( aTokenBalanceAfterWithdraw < aTokenBalanceBeforeWithdraw, "AAVE_WITHDRAWAL_ERROR" @@ -151,27 +175,28 @@ contract AaveFacet is PausableMods, DappMods { paused("", false) onlyBorrower(loanID) { - IAToken aToken = LibDapps.getAToken(tokenAddress); + ILoansEscrow escrow = LibEscrow.e(loanID); + IAToken aToken = LibDapps.getAToken( + LP_ADDRESS_PROVIDER_ADDRESS, + tokenAddress + ); - uint256 aTokenBalanceBeforeWithdraw = aToken.balanceOf(address(this)); + uint256 aTokenBalanceBeforeWithdraw = aToken.balanceOf(address(escrow)); require(aTokenBalanceBeforeWithdraw >= 0, "NO_BALANCE_TO_WITHDRAW"); - IAaveLendingPool aaveLendingPool = LibDapps.getAaveLendingPool(); + IAaveLendingPool aaveLendingPool = LibDapps.getAaveLendingPool( + LP_ADDRESS_PROVIDER_ADDRESS + ); - bytes memory callData = - abi.encode( - IAaveLendingPool.withdraw.selector, - tokenAddress, - aTokenBalanceBeforeWithdraw, - address(this) - ); - LibDapps.s().loanEscrows[loanID].callDapp( - address(aaveLendingPool), - callData + bytes memory callData = abi.encodeWithSelector( + aaveLendingPool.withdraw.selector, + tokenAddress, + aTokenBalanceBeforeWithdraw, + address(escrow) ); + escrow.callDapp(address(aaveLendingPool), callData); - uint256 aTokenBalanceAfterWithdraw = aToken.balanceOf(address(this)); - require(aTokenBalanceAfterWithdraw == 0, "AAVE_WITHDRAWAL_ERROR"); + uint256 aTokenBalanceAfterWithdraw = aToken.balanceOf(address(escrow)); LibEscrow.tokenUpdated(loanID, address(aToken)); LibEscrow.tokenUpdated(loanID, tokenAddress); diff --git a/contracts/escrow/dapps/CompoundClaimComp.sol b/contracts/escrow/dapps/CompoundClaimComp.sol new file mode 100644 index 000000000..5e6cf7dea --- /dev/null +++ b/contracts/escrow/dapps/CompoundClaimComp.sol @@ -0,0 +1,69 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +// Contracts +import { DappMods } from "./DappMods.sol"; +import { PausableMods } from "../../settings/pausable/PausableMods.sol"; +import "hardhat/console.sol"; +// Libraries +import { LibCompound } from "./libraries/LibCompound.sol"; +import { LibEscrow } from "../libraries/LibEscrow.sol"; + +// Interfaces +import { IComptroller } from "../../shared/interfaces/IComptroller.sol"; + +contract CompoundClaimCompFacet is PausableMods, DappMods { + /** + * @notice This event is emitted every time Compound redeem is invoked successfully. + * @param holder address of escrow. + * @param loanID loan ID. + */ + event CompoundClaimed(address indexed holder, uint256 loanID); + + /** + * @dev The address of Compound's Comptroler Address Provider on the deployed network + * @dev example - Compound's Comptroler Address Provider contract address on L1 mainnet or L2 polygon mainnet + */ + address public immutable COMPTROLLER_ADDRESS_PROVIDER_ADDRESS; + + /** + * @notice Sets the network relevant address for Compound's Comptroller Address Provider on protocol deployment. + * @param compComptrollerAddressProvider The immutable address of Compound's Comptroller Address Provider on the deployed network. + */ + constructor(address compComptrollerAddressProvider) public { + COMPTROLLER_ADDRESS_PROVIDER_ADDRESS = compComptrollerAddressProvider; + } + + /** + * @notice To claim comp call the claim comp function on COMPTROLLER_ADDRESS_PROVIDER_ADDRESS. + * @param loanID id of the loan being used in the dapp + */ + function compoundClaimComp(uint256 loanID) + public + paused("", false) + onlyBorrower(loanID) + { + address escrow = address(LibEscrow.e(loanID)); + LibEscrow.e(loanID).callDapp( + address(COMPTROLLER_ADDRESS_PROVIDER_ADDRESS), + abi.encodeWithSignature("claimComp(address)", escrow) + ); + emit CompoundClaimed(escrow, loanID); + } + + /** + * @notice This function calcullates the holder's accrued comp. + * @param loanID id of the loan being used in the dapp + */ + function compoundCalculateComp(uint256 loanID) + public + view + returns (uint256) + { + IComptroller comptroller = IComptroller( + COMPTROLLER_ADDRESS_PROVIDER_ADDRESS + ); + uint256 comp = comptroller.compAccrued(address(LibEscrow.e(loanID))); + return comp; + } +} diff --git a/contracts/escrow/dapps/CompoundFacet.sol b/contracts/escrow/dapps/CompoundFacet.sol index e1ed02048..78e713b28 100644 --- a/contracts/escrow/dapps/CompoundFacet.sol +++ b/contracts/escrow/dapps/CompoundFacet.sol @@ -57,11 +57,10 @@ contract CompoundFacet is PausableMods, DappMods { LibEscrow.e(loanID).setTokenAllowance(tokenAddress, address(cToken)); - bytes memory result = - LibEscrow.e(loanID).callDapp( - address(cToken), - abi.encodeWithSelector(ICErc20.mint.selector, amount) - ); + bytes memory result = LibEscrow.e(loanID).callDapp( + address(cToken), + abi.encodeWithSelector(ICErc20.mint.selector, amount) + ); require( abi.decode(result, (uint256)) == LibCompound.NO_ERROR, @@ -137,8 +136,10 @@ contract CompoundFacet is PausableMods, DappMods { address tokenAddress, bytes memory callData ) private { - bytes memory result = - LibEscrow.e(loanID).callDapp(cTokenAddress, callData); + bytes memory result = LibEscrow.e(loanID).callDapp( + cTokenAddress, + callData + ); require( abi.decode(result, (uint256)) != diff --git a/contracts/escrow/dapps/PoolTogetherFacet.sol b/contracts/escrow/dapps/PoolTogetherFacet.sol index 6cd4af429..1b1b5f2d7 100644 --- a/contracts/escrow/dapps/PoolTogetherFacet.sol +++ b/contracts/escrow/dapps/PoolTogetherFacet.sol @@ -10,7 +10,9 @@ import { AssetPPoolLib } from "../../settings/asset/libraries/AssetPPoolLib.sol"; import { PoolTogetherLib } from "./libraries/PoolTogetherLib.sol"; -import { PrizePoolInterface } from "./interfaces/PrizePoolInterface.sol"; +import { + PrizePoolInterface +} from "../../shared/interfaces/pooltogether/PrizePoolInterface.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; @@ -68,18 +70,17 @@ contract PoolTogetherFacet is PausableMods, DappMods { address ticketAddress = PoolTogetherLib.getTicketAddress(tokenAddress); uint256 balanceBefore = LibEscrow.balanceOf(loanID, ticketAddress); - IERC20(tokenAddress).safeApprove(address(prizePool), amount); - - bytes memory callData = - abi.encode( - PrizePoolInterface.depositTo.selector, - address(this), - amount, - ticketAddress, - address(this) - ); - LibDapps.s().loanEscrows[loanID].callDapp(address(prizePool), callData); + // Set token allowance to Prize Pool + LibEscrow.e(loanID).setTokenAllowance(tokenAddress, address(prizePool)); + bytes memory callData = abi.encodeWithSelector( + PrizePoolInterface.depositTo.selector, + address(LibEscrow.e(loanID)), // Tickets sent to Escrow + amount, + ticketAddress, + address(this) // Referrer is the Teller Diamond + ); + LibDapps.s().loanEscrows[loanID].callDapp(address(prizePool), callData); uint256 balanceAfter = LibEscrow.balanceOf(loanID, ticketAddress); require(balanceAfter > balanceBefore, "DEPOSIT_ERROR"); @@ -111,24 +112,13 @@ contract PoolTogetherFacet is PausableMods, DappMods { address ticketAddress = PoolTogetherLib.getTicketAddress(tokenAddress); uint256 balanceBefore = LibEscrow.balanceOf(loanID, ticketAddress); - ( - uint256 maxExitFee, /* uint256 burnedCredit */ - - ) = - prizePool.calculateEarlyExitFee( - address(this), - ticketAddress, - amount - ); - - bytes memory callData = - abi.encode( - PrizePoolInterface.withdrawInstantlyFrom.selector, - address(this), - amount, - ticketAddress, - maxExitFee - ); + bytes memory callData = abi.encodeWithSelector( + PrizePoolInterface.withdrawInstantlyFrom.selector, + address(LibEscrow.e(loanID)), + amount, + ticketAddress, + 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF // max exit fee + ); LibDapps.s().loanEscrows[loanID].callDapp(address(prizePool), callData); uint256 balanceAfter = LibEscrow.balanceOf(loanID, ticketAddress); @@ -159,24 +149,15 @@ contract PoolTogetherFacet is PausableMods, DappMods { PrizePoolInterface prizePool = AssetPPoolLib.get(tokenAddress); address ticketAddress = PoolTogetherLib.getTicketAddress(tokenAddress); - uint256 balanceBefore = LibEscrow.balanceOf(loanID, ticketAddress); - (uint256 maxExitFee, ) = - prizePool.calculateEarlyExitFee( - address(this), - ticketAddress, - balanceBefore - ); - - bytes memory callData = - abi.encode( - PrizePoolInterface.withdrawInstantlyFrom.selector, - address(this), - balanceBefore, - ticketAddress, - maxExitFee - ); + bytes memory callData = abi.encodeWithSelector( + PrizePoolInterface.withdrawInstantlyFrom.selector, + address(LibEscrow.e(loanID)), + balanceBefore, + ticketAddress, + 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + ); LibDapps.s().loanEscrows[loanID].callDapp(address(prizePool), callData); uint256 balanceAfter = LibEscrow.balanceOf(loanID, ticketAddress); diff --git a/contracts/escrow/dapps/UniswapFacet.sol b/contracts/escrow/dapps/UniswapFacet.sol deleted file mode 100644 index 9ca11d4b2..000000000 --- a/contracts/escrow/dapps/UniswapFacet.sol +++ /dev/null @@ -1,86 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity ^0.8.0; - -// Contracts -import { DappMods } from "./DappMods.sol"; -import { PausableMods } from "../../settings/pausable/PausableMods.sol"; - -// Libraries -import { LibEscrow } from "../libraries/LibEscrow.sol"; -import { LibUniswap } from "./libraries/LibUniswap.sol"; -import { - ChainlinkLib -} from "../../price-aggregator/chainlink/ChainlinkLib.sol"; - -// Interfaces -import { IUniswapV2Router } from "../../shared/interfaces/IUniswapV2Router.sol"; - -contract UniswapFacet is PausableMods, DappMods { - /** - * @notice Event emitted every time a successful swap has taken place. - * @param sourceToken source token address. - * @param destinationToken destination address. - * @param sourceAmount source amount sent. - * @param destinationAmount destination amount received. - */ - event UniswapSwapped( - address indexed sourceToken, - address indexed destinationToken, - uint256 sourceAmount, - uint256 destinationAmount - ); - - /** - * @notice Swaps tokens for tokens on Uniswap. - * @dev {path} must have at least 2 token addresses - * @param path An array of token addresses. - * @param sourceAmount amount of source token to swap. - * @param minDestination The minimum amount of output tokens that must be received for the transaction not to revert. - */ - function uniswapSwap( - uint256 loanID, - address[] memory path, - uint256 sourceAmount, - uint256 minDestination - ) external paused("", false) onlySecured(loanID) onlyBorrower(loanID) { - address src = path[0]; - address dst = path[path.length - 1]; - require( - ChainlinkLib.isTokenSupported(src), - "Teller: uniswap src not supported" - ); - require( - ChainlinkLib.isTokenSupported(dst), - "Teller: uniswap dst not supported" - ); - - // Set allowance on source token to Uniswap Router - LibEscrow.e(loanID).setTokenAllowance(src, address(LibUniswap.ROUTER)); - - // Encode data for LoansEscrow to call - bytes memory callData = - abi.encodeWithSelector( - IUniswapV2Router.swapExactTokensForTokens.selector, - sourceAmount, - minDestination, - path, - address(LibEscrow.e(loanID)), - block.timestamp - ); - // Call Escrow to do swap get the response amounts - uint256[] memory amounts = - abi.decode( - LibEscrow.e(loanID).callDapp( - address(LibUniswap.ROUTER), - callData - ), - (uint256[]) - ); - uint256 destinationAmount = amounts[amounts.length - 1]; - - LibEscrow.tokenUpdated(loanID, src); - LibEscrow.tokenUpdated(loanID, dst); - - emit UniswapSwapped(src, dst, sourceAmount, destinationAmount); - } -} diff --git a/contracts/escrow/dapps/YearnFacet.sol b/contracts/escrow/dapps/YearnFacet.sol index f86ba29ce..75142aa4c 100644 --- a/contracts/escrow/dapps/YearnFacet.sol +++ b/contracts/escrow/dapps/YearnFacet.sol @@ -1,13 +1,22 @@ // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; -// Storage +// Contracts import { DappMods } from "./DappMods.sol"; import { PausableMods } from "../../settings/pausable/PausableMods.sol"; + +// Libraries +import { + AssetYVaultLib +} from "../../settings/asset/libraries/AssetYVaultLib.sol"; import { LibDapps } from "./libraries/LibDapps.sol"; import { LibEscrow } from "../libraries/LibEscrow.sol"; -import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; -import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; +import { + SafeERC20 +} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; + +// Interfaces +import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import { IVault } from "./interfaces/IVault.sol"; contract YearnFacet is PausableMods, DappMods { @@ -55,7 +64,7 @@ contract YearnFacet is PausableMods, DappMods { address tokenAddress, uint256 amount ) public paused("", false) onlyBorrower(loanID) { - IVault iVault = LibDapps.getYVault(tokenAddress); + IVault iVault = AssetYVaultLib.get(tokenAddress); uint256 tokenBalanceBeforeDeposit = iVault.balanceOf(address(this)); IERC20(tokenAddress).safeApprove(address(iVault), amount); @@ -91,11 +100,12 @@ contract YearnFacet is PausableMods, DappMods { address tokenAddress, uint256 amount ) public paused("", false) onlyBorrower(loanID) { - IVault iVault = LibDapps.getYVault(tokenAddress); + IVault iVault = AssetYVaultLib.get(tokenAddress); uint256 price = iVault.getPricePerShare(); uint256 shares = amount / price; - uint256 tokenBalanceBeforeWithdrawal = - IERC20(tokenAddress).balanceOf(address(this)); + uint256 tokenBalanceBeforeWithdrawal = IERC20(tokenAddress).balanceOf( + address(this) + ); require( shares >= iVault.balanceOf(address(this)), "INSUFFICIENT_DEPOSIT" @@ -104,8 +114,9 @@ contract YearnFacet is PausableMods, DappMods { bytes memory callData = abi.encode(IVault.withdraw.selector, shares); LibDapps.s().loanEscrows[loanID].callDapp(address(iVault), callData); - uint256 tokenBalanceAfterWithdrawal = - IERC20(tokenAddress).balanceOf(address(this)); + uint256 tokenBalanceAfterWithdrawal = IERC20(tokenAddress).balanceOf( + address(this) + ); require( tokenBalanceAfterWithdrawal > tokenBalanceBeforeWithdrawal, "WITHDRAWAL_UNSUCCESSFUL" @@ -133,15 +144,17 @@ contract YearnFacet is PausableMods, DappMods { paused("", false) onlyBorrower(loanID) { - IVault iVault = LibDapps.getYVault(tokenAddress); - uint256 tokenBalanceBeforeWithdrawal = - IERC20(tokenAddress).balanceOf(address(this)); + IVault iVault = AssetYVaultLib.get(tokenAddress); + uint256 tokenBalanceBeforeWithdrawal = IERC20(tokenAddress).balanceOf( + address(this) + ); bytes memory callData = abi.encode(IVault.withdrawAll.selector); LibDapps.s().loanEscrows[loanID].callDapp(address(iVault), callData); - uint256 tokenBalanceAfterWithdrawal = - IERC20(tokenAddress).balanceOf(address(this)); + uint256 tokenBalanceAfterWithdrawal = IERC20(tokenAddress).balanceOf( + address(this) + ); require( tokenBalanceAfterWithdrawal > tokenBalanceBeforeWithdrawal, "WITHDRAWAL_UNSUCCESSFUL" diff --git a/contracts/escrow/dapps/interfaces/IComptroller.sol b/contracts/escrow/dapps/interfaces/IComptroller.sol deleted file mode 100644 index 50d173298..000000000 --- a/contracts/escrow/dapps/interfaces/IComptroller.sol +++ /dev/null @@ -1,135 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity ^0.8.0; - -interface IComptroller { - /*** Assets You Are In ***/ - - function enterMarkets(address[] calldata cTokens) - external - returns (uint256[] memory); - - function exitMarket(address cToken) external returns (uint256); - - /*** Policy Hooks ***/ - - function mintAllowed( - address cToken, - address minter, - uint256 mintAmount - ) external returns (uint256); - - function mintVerify( - address cToken, - address minter, - uint256 mintAmount, - uint256 mintTokens - ) external; - - function redeemAllowed( - address cToken, - address redeemer, - uint256 redeemTokens - ) external returns (uint256); - - function redeemVerify( - address cToken, - address redeemer, - uint256 redeemAmount, - uint256 redeemTokens - ) external; - - function borrowAllowed( - address cToken, - address borrower, - uint256 borrowAmount - ) external returns (uint256); - - function borrowVerify( - address cToken, - address borrower, - uint256 borrowAmount - ) external; - - function repayBorrowAllowed( - address cToken, - address payer, - address borrower, - uint256 repayAmount - ) external returns (uint256); - - function repayBorrowVerify( - address cToken, - address payer, - address borrower, - uint256 repayAmount, - uint256 borrowerIndex - ) external; - - function liquidateBorrowAllowed( - address cTokenBorrowed, - address cTokenCollateral, - address liquidator, - address borrower, - uint256 repayAmount - ) external returns (uint256); - - function liquidateBorrowVerify( - address cTokenBorrowed, - address cTokenCollateral, - address liquidator, - address borrower, - uint256 repayAmount, - uint256 seizeTokens - ) external; - - function seizeAllowed( - address cTokenCollateral, - address cTokenBorrowed, - address liquidator, - address borrower, - uint256 seizeTokens - ) external returns (uint256); - - function seizeVerify( - address cTokenCollateral, - address cTokenBorrowed, - address liquidator, - address borrower, - uint256 seizeTokens - ) external; - - function transferAllowed( - address cToken, - address src, - address dst, - uint256 transferTokens - ) external returns (uint256); - - function transferVerify( - address cToken, - address src, - address dst, - uint256 transferTokens - ) external; - - function claimComp(address holder) external; - - function claimComp(address holder, address[] calldata cTokens) external; - - function claimComp( - address[] calldata holders, - address[] calldata cTokens, - bool borrowers, - bool suppliers - ) external; - - /*** Liquidity/Liquidation Calculations ***/ - - function liquidateCalculateSeizeTokens( - address cTokenBorrowed, - address cTokenCollateral, - uint256 repayAmount - ) external view returns (uint256, uint256); - - function getCompAddress() external view returns (address); -} diff --git a/contracts/escrow/dapps/interfaces/ISushiswapDapp.sol b/contracts/escrow/dapps/interfaces/ISushiswapDapp.sol new file mode 100644 index 000000000..2b23fe18a --- /dev/null +++ b/contracts/escrow/dapps/interfaces/ISushiswapDapp.sol @@ -0,0 +1,35 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +/** + @notice This defines the functions available to use in the Sushiswap Dapp. + @author develop@teller.finance + */ +interface ISushiswapDapp { + /** + @notice Swaps tokens using the Sushiswap protocol. + @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity. + @param sourceAmount amount of source token to swap. + @param minDestination The minimum amount of output tokens that must be received for the transaction not to revert. + + */ + function swap( + address[] calldata path, + uint256 sourceAmount, + uint256 minDestination + ) external; + + /** + @notice Event emmitted every time a successful swap has taken place. + @param sourceToken source token address. + @param destinationToken destination address. + @param sourceAmount source amount sent. + @param destinationAmount destination amount received. + */ + event SushiswapSwapped( + address indexed sourceToken, + address indexed destinationToken, + uint256 sourceAmount, + uint256 destinationAmount + ); +} diff --git a/contracts/escrow/dapps/libraries/LibDapps.sol b/contracts/escrow/dapps/libraries/LibDapps.sol index 5d36d3a05..a5d3b5a5e 100644 --- a/contracts/escrow/dapps/libraries/LibDapps.sol +++ b/contracts/escrow/dapps/libraries/LibDapps.sol @@ -3,11 +3,13 @@ pragma solidity ^0.8.0; // Interfaces import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; -import { IAToken } from "../interfaces/IAToken.sol"; -import { IAaveLendingPool } from "../interfaces/IAaveLendingPool.sol"; +import { IAToken } from "../../../shared/interfaces/IAToken.sol"; +import { + IAaveLendingPool +} from "../../../shared/interfaces/IAaveLendingPool.sol"; import { IAaveLendingPoolAddressesProvider -} from "../interfaces/IAaveLendingPoolAddressesProvider.sol"; +} from "../../../shared/interfaces/IAaveLendingPoolAddressesProvider.sol"; import { IUniswapV2Router } from "../../../shared/interfaces/IUniswapV2Router.sol"; @@ -28,42 +30,38 @@ library LibDapps { } /** - @notice Grabs the Aave lending pool instance from the Aave lending pool address provider - @return IAaveLendingPool instance address + @notice Grabs the Aave lending pool instance from the Aave lending pool address provider. + @param aaveLPAddressProvider The immutable address of Aave's Lending Pool Address Provider on the deployed network. + @return IAaveLendingPool instance address. */ - function getAaveLendingPool() internal view returns (IAaveLendingPool) { + function getAaveLendingPool(address aaveLPAddressProvider) + internal + view + returns (IAaveLendingPool) + { return IAaveLendingPool( - IAaveLendingPoolAddressesProvider( - 0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5 - ) + IAaveLendingPoolAddressesProvider(aaveLPAddressProvider) .getLendingPool() - ); // LP address provider contract is immutable and the address will never change + ); // LP address provider contract is immutable on each deployed network and the address will never change } /** - @notice Grabs the aToken instance from the lending pool - @param tokenAddress The underlying asset address to get the aToken for - @return IAToken instance + @notice Grabs the aToken instance from the lending pool. + @param aaveLPAddressProvider The immutable address of Aave's Lending Pool Address Provider on the deployed network. + @param tokenAddress The underlying asset address to get the aToken for. + @return IAToken instance. */ - function getAToken(address tokenAddress) internal view returns (IAToken) { + function getAToken(address aaveLPAddressProvider, address tokenAddress) + internal + view + returns (IAToken) + { return IAToken( - getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress - ); - } - - /** - @notice Grabs the yVault address for a token from the asset settings - @param tokenAddress The underlying token address for the associated yVault - @return yVault instance - */ - function getYVault(address tokenAddress) internal view returns (IVault) { - return - IVault( - AppStorageLib.store().assetSettings[tokenAddress].addresses[ - keccak256("yVaultAddress") - ] + getAaveLendingPool(aaveLPAddressProvider).getReserveData( + tokenAddress + ).aTokenAddress ); } } diff --git a/contracts/escrow/dapps/libraries/LibUniswap.sol b/contracts/escrow/dapps/libraries/LibSwapper.sol similarity index 75% rename from contracts/escrow/dapps/libraries/LibUniswap.sol rename to contracts/escrow/dapps/libraries/LibSwapper.sol index 0f80f92fd..401b8aa12 100644 --- a/contracts/escrow/dapps/libraries/LibUniswap.sol +++ b/contracts/escrow/dapps/libraries/LibSwapper.sol @@ -12,30 +12,28 @@ import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; -library LibUniswap { - IUniswapV2Router constant ROUTER = - IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); - +library LibSwapper { /** - * @notice Swaps tokens for tokens on Uniswap. + * @notice Swaps tokens for tokens on Sushiswap. * @dev {path} must have at least 2 token addresses + * @param routerAddress The address of the swapping router (UniswapV2Router, SushiswapV2Router, etc) * @param path An array of token addresses. * @param sourceAmount amount of source token to swap. * @param minDestination The minimum amount of output tokens that must be received for the transaction not to revert. - * @return amounts is the resulting number of tokens swapped for */ function swap( + address routerAddress, address[] memory path, uint256 sourceAmount, uint256 minDestination ) internal returns (uint256) { SafeERC20.safeIncreaseAllowance( IERC20(path[0]), - address(ROUTER), + routerAddress, sourceAmount ); - uint256[] memory amounts = - ROUTER.swapExactTokensForTokens( + uint256[] memory amounts = IUniswapV2Router(routerAddress) + .swapExactTokensForTokens( sourceAmount, minDestination, path, diff --git a/contracts/escrow/dapps/swappers/AbstractSwapper.sol b/contracts/escrow/dapps/swappers/AbstractSwapper.sol new file mode 100644 index 000000000..717275074 --- /dev/null +++ b/contracts/escrow/dapps/swappers/AbstractSwapper.sol @@ -0,0 +1,23 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +// Contracts +import { DappMods } from "../DappMods.sol"; +import { PausableMods } from "../../../settings/pausable/PausableMods.sol"; +import { + ChainlinkPricer +} from "../../../price-aggregator/pricers/ChainlinkPricer.sol"; + +// Storage +import { AppStorageLib } from "../../../storage/app.sol"; + +abstract contract AbstractSwapper is PausableMods, DappMods { + function __isValidPath(address src, address dst) internal returns (bool) { + ChainlinkPricer chainlinkPricer = AppStorageLib.store() + .priceAggregator + .chainlinkPricer(); + return + address(chainlinkPricer.getEthAggregator(src)) != address(0) && + address(chainlinkPricer.getEthAggregator(dst)) != address(0); + } +} diff --git a/contracts/escrow/dapps/swappers/AbstractUniSwapper.sol b/contracts/escrow/dapps/swappers/AbstractUniSwapper.sol new file mode 100644 index 000000000..7974db529 --- /dev/null +++ b/contracts/escrow/dapps/swappers/AbstractUniSwapper.sol @@ -0,0 +1,21 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +// Contracts +import { AbstractSwapper } from "./AbstractSwapper.sol"; + +abstract contract AbstractUniSwapper is AbstractSwapper { + /** + * @dev The address of the swapping router on the deployed network + * @dev example - contract address on L1 mainnet or L2 polygon mainnet + */ + address internal immutable ROUTER_ADDRESS; + + /** + * @notice Sets the swapping router address on protocol deployment. + * @param routerAddress The address of the swapping router contract on the network. + */ + constructor(address routerAddress) { + ROUTER_ADDRESS = routerAddress; + } +} diff --git a/contracts/escrow/dapps/swappers/SushiswapFacet.sol b/contracts/escrow/dapps/swappers/SushiswapFacet.sol new file mode 100644 index 000000000..080ade735 --- /dev/null +++ b/contracts/escrow/dapps/swappers/SushiswapFacet.sol @@ -0,0 +1,83 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +// Contracts +import { AbstractUniSwapper } from "./AbstractUniSwapper.sol"; + +// Libraries +import { LibEscrow } from "../../libraries/LibEscrow.sol"; + +// Interfaces +import { + IUniswapV2Router +} from "../../../shared/interfaces/IUniswapV2Router.sol"; + +contract SushiswapFacet is AbstractUniSwapper { + /** + * @notice Sets the swapping router address on protocol deployment. + * @param routerAddress The address of the swapping router contract on the network. + */ + constructor(address routerAddress) AbstractUniSwapper(routerAddress) {} + + /** + * @notice Event emitted every time a successful swap has taken place. + * @param sourceToken source token address. + * @param destinationToken destination address. + * @param sourceAmount source amount sent. + * @param destinationAmount destination amount received. + */ + event SushiswapSwapped( + address indexed sourceToken, + address indexed destinationToken, + uint256 sourceAmount, + uint256 destinationAmount + ); + + /** + * @notice Swaps tokens for tokens on Sushiswap. + * @dev {path} must have at least 2 token addresses + * @param path An array of token addresses. + * @param sourceAmount amount of source token to swap. + * @param minDestination The minimum amount of output tokens that must be received for the transaction not to revert. + */ + function sushiswapSwap( + uint256 loanID, + address[] memory path, + uint256 sourceAmount, + uint256 minDestination + ) external paused("", false) onlySecured(loanID) onlyBorrower(loanID) { + require( + __isValidPath(path[0], path[path.length - 1]), + "Teller: swapper dst not supported" + ); + + // Set allowance on source token to Uniswap Router + LibEscrow.e(loanID).setTokenAllowance(path[0], address(ROUTER_ADDRESS)); + + // Encode data for LoansEscrow to call + bytes memory callData = abi.encodeWithSelector( + IUniswapV2Router.swapExactTokensForTokens.selector, + sourceAmount, + minDestination, + path, + address(LibEscrow.e(loanID)), + block.timestamp + ); + + // Call Escrow to do swap get the response amounts + uint256[] memory amounts = abi.decode( + LibEscrow.e(loanID).callDapp(address(ROUTER_ADDRESS), callData), + (uint256[]) + ); + + LibEscrow.tokenUpdated(loanID, path[0]); + LibEscrow.tokenUpdated(loanID, path[path.length - 1]); + + emit SushiswapSwapped( + path[0], + path[path.length - 1], + sourceAmount, + amounts[amounts.length - 1] + ); + } +} diff --git a/contracts/escrow/dapps/swappers/UniswapFacet.sol b/contracts/escrow/dapps/swappers/UniswapFacet.sol new file mode 100644 index 000000000..d3c55476d --- /dev/null +++ b/contracts/escrow/dapps/swappers/UniswapFacet.sol @@ -0,0 +1,82 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +// Contracts +import { AbstractUniSwapper } from "./AbstractUniSwapper.sol"; + +// Libraries +import { LibEscrow } from "../../libraries/LibEscrow.sol"; + +// Interfaces +import { + IUniswapV2Router +} from "../../../shared/interfaces/IUniswapV2Router.sol"; + +contract UniswapFacet is AbstractUniSwapper { + /** + * @notice Sets the swapping router address on protocol deployment. + * @param routerAddress The address of the swapping router contract on the network. + */ + constructor(address routerAddress) AbstractUniSwapper(routerAddress) {} + + /** + * @notice Event emitted every time a successful swap has taken place. + * @param sourceToken source token address. + * @param destinationToken destination address. + * @param sourceAmount source amount sent. + * @param destinationAmount destination amount received. + */ + event UniswapSwapped( + address indexed sourceToken, + address indexed destinationToken, + uint256 sourceAmount, + uint256 destinationAmount + ); + + /** + * @notice Swaps tokens for tokens on Uniswap. + * @dev {path} must have at least 2 token addresses + * @param path An array of token addresses. + * @param sourceAmount amount of source token to swap. + * @param minDestination The minimum amount of output tokens that must be received for the transaction not to revert. + */ + function uniswapSwap( + uint256 loanID, + address[] memory path, + uint256 sourceAmount, + uint256 minDestination + ) external paused("", false) onlySecured(loanID) onlyBorrower(loanID) { + require( + __isValidPath(path[0], path[path.length - 1]), + "Teller: swapper dst not supported" + ); + + // Set allowance on source token to Uniswap Router + LibEscrow.e(loanID).setTokenAllowance(path[0], address(ROUTER_ADDRESS)); + + // Encode data for LoansEscrow to call + bytes memory callData = abi.encodeWithSelector( + IUniswapV2Router.swapExactTokensForTokens.selector, + sourceAmount, + minDestination, + path, + address(LibEscrow.e(loanID)), + block.timestamp + ); + // Call Escrow to do swap get the response amounts + uint256[] memory amounts = abi.decode( + LibEscrow.e(loanID).callDapp(ROUTER_ADDRESS, callData), + (uint256[]) + ); + + LibEscrow.tokenUpdated(loanID, path[0]); + LibEscrow.tokenUpdated(loanID, path[path.length - 1]); + + emit UniswapSwapped( + path[0], + path[path.length - 1], + sourceAmount, + amounts[amounts.length - 1] + ); + } +} diff --git a/contracts/escrow/escrow/LoansEscrow_V1.sol b/contracts/escrow/escrow/LoansEscrow_V1.sol index 37171d8cb..50c8c46a7 100644 --- a/contracts/escrow/escrow/LoansEscrow_V1.sol +++ b/contracts/escrow/escrow/LoansEscrow_V1.sol @@ -23,7 +23,7 @@ import { IBeacon } from "@openzeppelin/contracts/proxy/beacon/IBeacon.sol"; contract LoansEscrow_V1 is ILoansEscrow { address public owner; - modifier onlyOwner { + modifier onlyOwner() { require(owner == msg.sender, "Teller: loan escrow not owner"); _; } diff --git a/contracts/escrow/libraries/LibEscrow.sol b/contracts/escrow/libraries/LibEscrow.sol index 2f53eeb12..aa01d042d 100644 --- a/contracts/escrow/libraries/LibEscrow.sol +++ b/contracts/escrow/libraries/LibEscrow.sol @@ -4,7 +4,6 @@ pragma solidity ^0.8.0; // Libraries import { LibDapps } from "../dapps/libraries/LibDapps.sol"; import { LibLoans } from "../../market/libraries/LibLoans.sol"; -import { PriceAggLib } from "../../price-aggregator/PriceAggLib.sol"; import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol"; @@ -14,6 +13,7 @@ import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import { ILoansEscrow } from "../escrow/ILoansEscrow.sol"; // Storage +import { AppStorageLib } from "../../storage/app.sol"; import { MarketStorageLib, MarketStorage } from "../../storage/market.sol"; library LibEscrow { @@ -25,10 +25,14 @@ library LibEscrow { e_ = s().loanEscrows[loanID]; } + function exists(uint256 loanID) internal view returns (bool) { + return address(e(loanID)) != address(0); + } + /** * @notice It returns a list of tokens owned by a loan escrow * @param loanID uint256 index used to return our token list - * @return t_ which is a list of tokens + * @return t_ which is a list of tokens */ function getEscrowTokens(uint256 loanID) internal @@ -49,7 +53,7 @@ library LibEscrow { view returns (uint256) { - return IERC20(token).balanceOf(address(e(loanID))); + return exists(loanID) ? IERC20(token).balanceOf(address(e(loanID))) : 0; } /** @@ -79,22 +83,25 @@ library LibEscrow { */ function calculateTotalValue(uint256 loanID) internal - view returns (uint256 value_) { + if (!exists(loanID)) { + return 0; + } + address lendingToken = LibLoans.loan(loanID).lendingToken; value_ += balanceOf(loanID, lendingToken); EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID); if (EnumerableSet.length(tokens) > 0) { for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) { - uint256 tokenBal = - balanceOf(loanID, EnumerableSet.at(tokens, i)); - value_ += PriceAggLib.valueFor( - EnumerableSet.at(tokens, i), - lendingToken, - tokenBal - ); + value_ += AppStorageLib.store() + .priceAggregator + .getBalanceOfFor( + address(e(loanID)), + EnumerableSet.at(tokens, i), + lendingToken + ); } } } diff --git a/contracts/lending/ttoken/ITToken.sol b/contracts/lending/ttoken/ITToken.sol index 5455bb87e..c9c9bdfe6 100644 --- a/contracts/lending/ttoken/ITToken.sol +++ b/contracts/lending/ttoken/ITToken.sol @@ -35,7 +35,43 @@ abstract contract ITToken is ERC20Upgradeable, RolesFacet { ); /** - * @notice The token that is the underlying assets for this Teller token. + * @notice This event is emitted when a loan has been taken out through the Teller Diamond. + * @param recipient The address receiving the borrowed funds. + * @param totalBorrowed The total amount being loaned out by the tToken. + */ + event LoanFunded(address indexed recipient, uint256 totalBorrowed); + + /** + * @notice This event is emitted when a loan has been repaid through the Teller Diamond. + * @param sender The address making the payment to the tToken. + * @param principlePayment The amount paid back towards the principle loaned out by the tToken. + * @param interestPayment The amount paid back towards the interest owed to the tToken. + */ + event LoanPaymentMade( + address indexed sender, + uint256 principlePayment, + uint256 interestPayment + ); + + /** + * @notice This event is emitted when a new investment management strategy has been set for a Teller token. + * @param strategyAddress The address of the new strategy set for managing the underlying assets held by the tToken. + * @param sender The address of the sender setting the token strategy. + */ + event StrategySet(address strategyAddress, address indexed sender); + + /** + * @notice This event is emitted when the platform restriction is switched + * @param restriction Boolean representing the state of the restriction + * @param investmentManager address of the investment manager flipping the switch + */ + event PlatformRestricted( + bool restriction, + address indexed investmentManager + ); + + /** + * @notice The token that is the underlying asset for this Teller token. * @return ERC20 token */ function underlying() external view virtual returns (ERC20); @@ -51,7 +87,7 @@ abstract contract ITToken is ERC20Upgradeable, RolesFacet { returns (uint256 balance_); /** - * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance. + * @notice It calculates the current exchange rate for a whole Teller Token based off the underlying token balance. * @return rate_ The current exchange rate. */ function exchangeRate() external virtual returns (uint256 rate_); @@ -96,7 +132,7 @@ abstract contract ITToken is ERC20Upgradeable, RolesFacet { /** * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount. * @param newLoanAmount the new loan amount to consider the StD ratio. - * @return ratio_ Whether debt ratio for lending pool is valid. + * @return ratio_ The debt ratio for lending pool. */ function debtRatioFor(uint256 newLoanAmount) external @@ -128,7 +164,7 @@ abstract contract ITToken is ERC20Upgradeable, RolesFacet { returns (uint256 mintAmount_); /** - * @notice Redeem supplied Teller token underlying value. + * @notice Redeem supplied Teller tokens for underlying value. * @param amount The amount of Teller tokens to redeem. */ function redeem(uint256 amount) external virtual; diff --git a/contracts/lending/ttoken/TToken_V1.sol b/contracts/lending/ttoken/TToken_V1.sol index 826423230..402bd3a3e 100644 --- a/contracts/lending/ttoken/TToken_V1.sol +++ b/contracts/lending/ttoken/TToken_V1.sol @@ -2,12 +2,7 @@ pragma solidity ^0.8.0; // Contracts -import { - CONTROLLER, - ADMIN, - EXCHANGE_RATE_FACTOR, - ONE_HUNDRED_PERCENT -} from "./data.sol"; +import { CONTROLLER, ADMIN, EXCHANGE_RATE_FACTOR } from "./data.sol"; import { ITTokenStrategy } from "./strategies/ITTokenStrategy.sol"; import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol"; @@ -27,28 +22,31 @@ import { ERC165Checker } from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol"; import { RolesLib } from "../../contexts2/access-control/roles/RolesLib.sol"; +import { + ReentryMods +} from "../../contexts2/access-control/reentry/ReentryMods.sol"; import { NumbersLib } from "../../shared/libraries/NumbersLib.sol"; // Storage -import "./storage.sol" as Storage; +import "./token-storage.sol" as Storage; /** * @notice This contract represents a lending pool for an asset within Teller protocol. * @author develop@teller.finance */ -contract TToken_V1 is ITToken { - function() pure returns (Storage.Store storage) private constant s = +contract TToken_V1 is ITToken, ReentryMods { + function() pure returns (Storage.Store storage) internal constant s = Storage.store; /* Modifiers */ /** - * @notice Checks if the LP is restricted or has the CONTROLLER role. + * @notice Checks if the LP is restricted or the message sender has the CONTROLLER role. * * The LP being restricted means that only the Teller protocol may * lend/borrow funds. */ - modifier notRestricted { + modifier notRestricted() { require( !s().restricted || RolesLib.hasRole(CONTROLLER, _msgSender()), "Teller: platform restricted" @@ -67,8 +65,8 @@ contract TToken_V1 is ITToken { } /** - * @notice The token that is the underlying assets for this Teller token. - * @return ERC20 token that is the underl + * @notice The token that is the underlying asset for this Teller token. + * @return ERC20 token that is the underlying asset */ function underlying() public view override returns (ERC20) { return s().underlying; @@ -88,8 +86,8 @@ contract TToken_V1 is ITToken { } /** - * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance. - * @return rate_ The current exchange rate. + * @notice It calculates the current scaled exchange rate for a whole Teller Token based of the underlying token balance. + * @return rate_ The current exchange rate, scaled by the EXCHANGE_RATE_FACTOR. */ function exchangeRate() public override returns (uint256 rate_) { if (totalSupply() == 0) { @@ -104,17 +102,16 @@ contract TToken_V1 is ITToken { * @return totalSupply_ the total supply denoted in the underlying asset. */ function totalUnderlyingSupply() public override returns (uint256) { - bytes memory data = - _delegateStrategy( - abi.encodeWithSelector( - ITTokenStrategy.totalUnderlyingSupply.selector - ) - ); + bytes memory data = _delegateStrategy( + abi.encodeWithSelector( + ITTokenStrategy.totalUnderlyingSupply.selector + ) + ); return abi.decode(data, (uint256)); } /** - * @notice It calculates the market state values across a given markets. + * @notice It calculates the market state values across a given market. * @notice Returns values that represent the global state across the market. * @return totalSupplied Total amount of the underlying asset supplied. * @return totalBorrowed Total amount borrowed through loans. @@ -155,7 +152,7 @@ contract TToken_V1 is ITToken { /** * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount. * @param newLoanAmount the new loan amount to consider the StD ratio. - * @return ratio_ Whether debt ratio for lending pool is valid. + * @return ratio_ The debt ratio for lending pool. */ function debtRatioFor(uint256 newLoanAmount) external @@ -176,6 +173,7 @@ contract TToken_V1 is ITToken { */ function fundLoan(address recipient, uint256 amount) external + virtual override authorized(CONTROLLER, _msgSender()) { @@ -195,6 +193,7 @@ contract TToken_V1 is ITToken { // Transfer tokens to recipient SafeERC20.safeTransfer(s().underlying, recipient, amount); + emit LoanFunded(recipient, amount); } /** @@ -209,9 +208,11 @@ contract TToken_V1 is ITToken { { s().totalRepaid += amount; s().totalInterestRepaid += interestAmount; + emit LoanPaymentMade(_msgSender(), amount, interestAmount); } /** + * @dev The tToken contract needs to have been granted sufficient allowance to transfer the amount being used to mint. * @notice Deposit underlying token amount into LP and mint tokens. * @param amount The amount of underlying tokens to use to mint. * @return Amount of TTokens minted. @@ -220,6 +221,7 @@ contract TToken_V1 is ITToken { external override notRestricted + nonReentry(keccak256("MINT")) returns (uint256) { require(amount > 0, "Teller: cannot mint 0"); @@ -231,6 +233,8 @@ contract TToken_V1 is ITToken { // Calculate amount of tokens to mint uint256 mintAmount = _valueOfUnderlying(amount, exchangeRate()); + require(mintAmount > 0, "Teller: amount to be minted cannot be 0"); + // Transfer tokens from lender SafeERC20.safeTransferFrom( s().underlying, @@ -248,10 +252,14 @@ contract TToken_V1 is ITToken { } /** - * @notice Redeem supplied Teller token underlying value. + * @notice Redeem supplied Teller tokens for underlying value. * @param amount The amount of Teller tokens to redeem. */ - function redeem(uint256 amount) external override { + function redeem(uint256 amount) + external + override + nonReentry(keccak256("REDEEM")) + { require(amount > 0, "Teller: cannot withdraw 0"); require( amount <= balanceOf(_msgSender()), @@ -260,6 +268,11 @@ contract TToken_V1 is ITToken { // Accrue interest and calculate exchange rate uint256 underlyingAmount = _valueInUnderlying(amount, exchangeRate()); + require( + underlyingAmount > 0, + "Teller: underlying teller token value to be redeemed cannot be 0" + ); + require( underlyingAmount <= totalUnderlyingSupply(), "Teller: redeem ttoken lp not enough supply" @@ -273,7 +286,11 @@ contract TToken_V1 is ITToken { * @notice Redeem supplied underlying value. * @param amount The amount of underlying tokens to redeem. */ - function redeemUnderlying(uint256 amount) external override { + function redeemUnderlying(uint256 amount) + external + override + nonReentry(keccak256("REDEEM")) + { require(amount > 0, "Teller: cannot withdraw 0"); require( amount <= totalUnderlyingSupply(), @@ -282,7 +299,7 @@ contract TToken_V1 is ITToken { // Accrue interest and calculate exchange rate uint256 rate = exchangeRate(); - uint256 tokenValue = _valueOfUnderlying(amount, rate); + uint256 tokenValue = _valueOfUnderlying(amount, rate) + 1; // Make sure sender has adequate balance require( @@ -332,7 +349,7 @@ contract TToken_V1 is ITToken { } /** - * @notice Sets a new strategy to use for balancing funds. + * @notice Sets or updates a strategy to use for balancing funds. * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface. * @param initData Optional data to initialize the strategy. * @@ -355,6 +372,7 @@ contract TToken_V1 is ITToken { if (initData.length > 0) { _delegateStrategy(initData); } + emit StrategySet(strategy, _msgSender()); } /** @@ -366,7 +384,7 @@ contract TToken_V1 is ITToken { } /** - * @notice Sets the restricted state of the platform. + * @notice Sets the restricted state of the tToken. * @param state boolean value that resembles the platform's state */ function restrict(bool state) @@ -375,12 +393,16 @@ contract TToken_V1 is ITToken { authorized(ADMIN, _msgSender()) { s().restricted = state; + emit PlatformRestricted(state, _msgSender()); } /** * @notice it initializes the Teller Token * @param admin address of the admin to the respective Teller Token * @param underlying address of the ERC20 token + * + * Requirements: + * - Underlying token must implement `name`, `symbol` and `decimals` */ function initialize(address admin, address underlying) external @@ -441,8 +463,6 @@ contract TToken_V1 is ITToken { * @notice Delegates data to call on the strategy contract. * @param callData Data to call the strategy contract with. * - * Requirements: - * - Sender must have ADMIN role */ function _delegateStrategy(bytes memory callData) internal diff --git a/contracts/lending/ttoken/TToken_V2.sol b/contracts/lending/ttoken/TToken_V2.sol new file mode 100644 index 000000000..88d210923 --- /dev/null +++ b/contracts/lending/ttoken/TToken_V2.sol @@ -0,0 +1,40 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +// Contracts +import { TToken_V1 } from "./TToken_V1.sol"; +import { CONTROLLER } from "./data.sol"; +import { ITTokenStrategy } from "./strategies/ITTokenStrategy.sol"; + +// Libraries +import { + SafeERC20 +} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; + +/** + * @notice This contract represents a lending pool for an asset within Teller protocol. + * @author develop@teller.finance + */ +contract TToken_V2 is TToken_V1 { + /** + * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds. + * @param recipient The account to send the funds to. + * @param amount Funds requested to fulfil the loan. + */ + function fundLoan(address recipient, uint256 amount) + external + override + authorized(CONTROLLER, _msgSender()) + { + // Call the strategy to ensure there is enough available funds to fund the loan + _delegateStrategy( + abi.encodeWithSelector(ITTokenStrategy.withdraw.selector, amount) + ); + + // Increase total borrowed amount + s().totalBorrowed += amount; + + // Transfer tokens to recipient + SafeERC20.safeTransfer(s().underlying, recipient, amount); + } +} diff --git a/contracts/lending/ttoken/data.sol b/contracts/lending/ttoken/data.sol index 05da71dd4..cb9f4c87e 100644 --- a/contracts/lending/ttoken/data.sol +++ b/contracts/lending/ttoken/data.sol @@ -7,4 +7,3 @@ bytes32 constant CONTROLLER = keccak256("CONTROLLER"); bytes32 constant ADMIN = keccak256("ADMIN"); uint256 constant EXCHANGE_RATE_FACTOR = 1e18; -uint256 constant ONE_HUNDRED_PERCENT = 10000; diff --git a/contracts/lending/ttoken/strategies/ITTokenStrategy.sol b/contracts/lending/ttoken/strategies/ITTokenStrategy.sol index ed9e78f2e..1f51ace9e 100644 --- a/contracts/lending/ttoken/strategies/ITTokenStrategy.sol +++ b/contracts/lending/ttoken/strategies/ITTokenStrategy.sol @@ -2,11 +2,28 @@ pragma solidity ^0.8.0; interface ITTokenStrategy { + /** + * @notice This event is emitted when the underlying assets are rebalanced as directed by the set investment strategy. + * @param strategyName The name of the strategy being rebalanced - example: "CompoundStrategy_1" + * @param sender The address of the sender rebalancing the token strategy. + */ event StrategyRebalanced( string indexed strategyName, address indexed sender ); + /** + * @notice This event is emitted when the underlying assets are rebalanced as directed by the set investment strategy. + * @param strategyName The name of the strategy being rebalanced - example: "CompoundStrategy_1" + * @param investmentAsset The address of the investible asset / protocol being used to leverage the underlying assets. + * @param sender The address of the sender rebalancing the token strategy. + */ + event StrategyInitialized( + string indexed strategyName, + address investmentAsset, + address indexed sender + ); + /** * @notice it returns the total supply of an underlying asset in a Teller token. * @return uint256 the underlying supply @@ -15,7 +32,6 @@ interface ITTokenStrategy { /** * @notice it rebalances the underlying asset held by the Teller Token. - * */ function rebalance() external; diff --git a/contracts/lending/ttoken/strategies/TTokenStrategy.sol b/contracts/lending/ttoken/strategies/TTokenStrategy.sol index 1ad9a00ab..1960ba73f 100644 --- a/contracts/lending/ttoken/strategies/TTokenStrategy.sol +++ b/contracts/lending/ttoken/strategies/TTokenStrategy.sol @@ -2,9 +2,16 @@ pragma solidity ^0.8.0; import { ERC165 } from "@openzeppelin/contracts/utils/introspection/ERC165.sol"; +import { + ContextUpgradeable +} from "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol"; import { ITTokenStrategy } from "./ITTokenStrategy.sol"; -abstract contract TTokenStrategy is ITTokenStrategy, ERC165 { +abstract contract TTokenStrategy is + ITTokenStrategy, + ContextUpgradeable, + ERC165 +{ /** * @notice it checks if interface is supported according to the ERC165 standard * @param interfaceId Id of the interface in question diff --git a/contracts/lending/ttoken/strategies/aave/TTokenAaveStrategy_1.sol b/contracts/lending/ttoken/strategies/aave/TTokenAaveStrategy_1.sol new file mode 100644 index 000000000..fa066d7eb --- /dev/null +++ b/contracts/lending/ttoken/strategies/aave/TTokenAaveStrategy_1.sol @@ -0,0 +1,172 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +// contracts +import { + RolesMods +} from "../../../../contexts2/access-control/roles/RolesMods.sol"; +import { ADMIN } from "../../data.sol"; + +// Interfaces +import { IAToken } from "../../../../shared/interfaces/IAToken.sol"; +import { + IAaveLendingPool +} from "../../../../shared/interfaces/IAaveLendingPool.sol"; +import { TTokenStrategy } from "../TTokenStrategy.sol"; + +// Libraries +import { + SafeERC20 +} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; +import { NumbersLib } from "../../../../shared/libraries/NumbersLib.sol"; +import { LibDapps } from "../../../../escrow/dapps/libraries/LibDapps.sol"; + +// Storage +import "../../token-storage.sol" as TokenStorage; +import "./aave-storage.sol" as AaveStorage; + +contract TTokenAaveStrategy_1 is RolesMods, TTokenStrategy { + function() pure returns (TokenStorage.Store storage) + private constant tokenStore = TokenStorage.store; + + function() pure returns (AaveStorage.Store storage) + private constant aaveStore = AaveStorage.store; + + string public constant NAME = "AaveStrategy_1"; + + /* External Functions */ + + function totalUnderlyingSupply() external override returns (uint256) { + return + tokenStore().underlying.balanceOf(address(this)) + + aaveStore().aToken.balanceOf(address(this)); + } + + /** + * @notice Rebalances the underlying asset held by the Teller Token. + * + * This strategy looks at the ratio of held underlying asset balance and balance deposited into + * Aave. Based on the store {balanceRatioMin} and {balanceRatioMax} values, will deposit or + * withdraw to keep the ratio within that range. + */ + function rebalance() public override { + ( + uint256 storedBal, + uint256 aaveBal, + uint16 storedRatio + ) = _getBalanceInfo(); + if (storedRatio > aaveStore().balanceRatioMax) { + // Calculate median ratio to rebalance to + uint16 medianRatio = (aaveStore().balanceRatioMax + + aaveStore().balanceRatioMin) / 2; + uint256 requiredBal = NumbersLib.percent( + storedBal + aaveBal, + medianRatio + ); + uint256 amountToDeposit = storedBal - requiredBal; + + IAaveLendingPool lendingPool = LibDapps.getAaveLendingPool( + aaveStore().LP_ADDRESS_PROVIDER_ADDRESS + ); + + // Approve Aave lending pool + SafeERC20.safeIncreaseAllowance( + tokenStore().underlying, + address(lendingPool), + amountToDeposit + ); + // Deposit into Aave + lendingPool.deposit( + address(tokenStore().underlying), + amountToDeposit, + address(this), + 0 // TODO get referral code from Aave when applicable + ); + + emit StrategyRebalanced(NAME, _msgSender()); + } else if (storedRatio > aaveStore().balanceRatioMin) { + // Withdraw tokens from Aave + _withdraw(0, storedBal, aaveBal); + + emit StrategyRebalanced(NAME, _msgSender()); + } + } + + /** + * @notice Rebalances the TToken funds by indicating a minimum {amount} of underlying tokens that must be present + * after the call. + * @notice If the minimum amount is present, no rebalance happens. + * @param amount Amount of underlying tokens that must be available. + */ + function withdraw(uint256 amount) external override { + (uint256 storedBal, uint256 aaveBal, ) = _getBalanceInfo(); + if (storedBal < amount) { + _withdraw(amount, storedBal, aaveBal); + } + } + + /** + * @dev Gets balances and the current ratio of the underlying asset stored on the TToken. + */ + function _getBalanceInfo() + internal + returns ( + uint256 storedBalance_, + uint256 aaveBalance_, + uint16 storedRatio_ + ) + { + storedBalance_ = tokenStore().underlying.balanceOf(address(this)); + aaveBalance_ = aaveStore().aToken.balanceOf(address(this)); + storedRatio_ = NumbersLib.ratioOf( + storedBalance_, + storedBalance_ + aaveBalance_ + ); + } + + /** + * @dev Rebalances funds stored on the TToken by indicating an extra {amount} to withdraw. + */ + function _withdraw( + uint256 amount, + uint256 storedBal, + uint256 aaveBal + ) internal { + // Calculate amount to rebalance + uint16 medianRatio = (aaveStore().balanceRatioMax + + aaveStore().balanceRatioMin) / 2; + uint256 requiredBal = NumbersLib.percent( + storedBal + aaveBal - amount, + medianRatio + ); + uint256 redeemAmount = requiredBal + amount - storedBal; + // Withdraw tokens from the Aave lending pool if needed + IAaveLendingPool lendingPool = LibDapps.getAaveLendingPool( + aaveStore().LP_ADDRESS_PROVIDER_ADDRESS + ); + lendingPool.withdraw( + address(tokenStore().underlying), + redeemAmount, + address(this) + ); + } + + /** + * @notice Sets the Aave token that should be used to manage the underlying Teller Token asset. + * @param aTokenAddress Address of the Aave token that has the same underlying asset as the TToken. + * @param aaveLPAddressProvider The immutable address of Aave's Lending Pool Address Provider on the deployed network. + * @param balanceRatioMin Percentage indicating the _ limit of underlying token balance should remain on the TToken + * @param balanceRatioMax Percentage indicating the _ limit of underlying token balance should remain on the TToken + */ + function init( + address aTokenAddress, + address aaveLPAddressProvider, + uint16 balanceRatioMin, + uint16 balanceRatioMax + ) external { + aaveStore().aToken = IAToken(aTokenAddress); + aaveStore().LP_ADDRESS_PROVIDER_ADDRESS = aaveLPAddressProvider; + aaveStore().balanceRatioMin = balanceRatioMin; + aaveStore().balanceRatioMax = balanceRatioMax; + } +} diff --git a/contracts/lending/ttoken/strategies/aave/aave-storage.sol b/contracts/lending/ttoken/strategies/aave/aave-storage.sol new file mode 100644 index 000000000..4ffc0c03d --- /dev/null +++ b/contracts/lending/ttoken/strategies/aave/aave-storage.sol @@ -0,0 +1,20 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +import { IAToken } from "../../../../shared/interfaces/IAToken.sol"; + +struct Store { + IAToken aToken; + uint16 balanceRatioMax; + uint16 balanceRatioMin; + address LP_ADDRESS_PROVIDER_ADDRESS; +} + +bytes32 constant POSITION = keccak256("ttoken.strategy.aave.storage.position"); + +function store() pure returns (Store storage s_) { + bytes32 position = POSITION; + assembly { + s_.slot := position + } +} diff --git a/contracts/lending/ttoken/strategies/compound/TTokenCompoundStrategy_1.sol b/contracts/lending/ttoken/strategies/compound/TTokenCompoundStrategy_1.sol index 292050e06..c5ee13975 100644 --- a/contracts/lending/ttoken/strategies/compound/TTokenCompoundStrategy_1.sol +++ b/contracts/lending/ttoken/strategies/compound/TTokenCompoundStrategy_1.sol @@ -16,10 +16,14 @@ import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import { NumbersLib } from "../../../../shared/libraries/NumbersLib.sol"; +import { LibMeta } from "../../../../shared/libraries/LibMeta.sol"; +import { + LibCompound +} from "../../../../escrow/dapps/libraries/LibCompound.sol"; // Storage -import "../../storage.sol" as TokenStorage; -import "./storage.sol" as CompoundStorage; +import "../../token-storage.sol" as TokenStorage; +import "./compound-storage.sol" as CompoundStorage; contract TTokenCompoundStrategy_1 is RolesMods, TTokenStrategy { /** @@ -56,15 +60,19 @@ contract TTokenCompoundStrategy_1 is RolesMods, TTokenStrategy { * (storedRatio > balanceRatioMax) or withdraw to keep the ratio within that range. */ function rebalance() public override { - (uint256 storedBal, uint256 compoundBal, uint16 storedRatio) = - _getBalanceInfo(); + ( + uint256 storedBal, + uint256 compoundBal, + uint16 storedRatio + ) = _getBalanceInfo(); if (storedRatio > compoundStore().balanceRatioMax) { // Calculate median ratio to rebalance to - uint16 medianRatio = - (compoundStore().balanceRatioMax + - compoundStore().balanceRatioMin) / 2; - uint256 requiredBal = - NumbersLib.percent(storedBal + compoundBal, medianRatio); + uint16 medianRatio = (compoundStore().balanceRatioMax + + compoundStore().balanceRatioMin) / 2; + uint256 requiredBal = NumbersLib.percent( + storedBal + compoundBal, + medianRatio + ); uint256 amountToDeposit = storedBal - requiredBal; // Allow Compound to take underlying tokens @@ -75,14 +83,18 @@ contract TTokenCompoundStrategy_1 is RolesMods, TTokenStrategy { ); // Deposit tokens into Compound - compoundStore().cToken.mint(amountToDeposit); + require( + compoundStore().cToken.mint(amountToDeposit) == + LibCompound.NO_ERROR, + "Teller: Strategy deposit error - Compound" + ); - emit StrategyRebalanced(NAME, msg.sender); + emit StrategyRebalanced(NAME, _msgSender()); } else if (storedRatio < compoundStore().balanceRatioMin) { // Withdraw tokens from Compound - _withdraw(0, storedBal, compoundBal, storedRatio); + _withdraw(0, storedBal, compoundBal); - emit StrategyRebalanced(NAME, msg.sender); + emit StrategyRebalanced(NAME, _msgSender()); } } @@ -93,17 +105,16 @@ contract TTokenCompoundStrategy_1 is RolesMods, TTokenStrategy { * @param amount Amount of underlying tokens that must be available. */ function withdraw(uint256 amount) external override { - (uint256 storedBal, uint256 compoundBal, uint16 storedRatio) = - _getBalanceInfo(); + (uint256 storedBal, uint256 compoundBal, ) = _getBalanceInfo(); if (storedBal < amount) { - _withdraw(amount, storedBal, compoundBal, storedRatio); + _withdraw(amount, storedBal, compoundBal); } } /** * @notice it gets balances and the current ratio of the underlying asset stored on the TToken. * @return storedBalance_ returns the total stored balance of the current underlying token - * @return compoundBalance_ returns the total stored balance + * @return compoundBalance_ returns the amount of underlying value stored in Compound * @return storedRatio_ ratio of current storedBalance_ over storedBalance_ and compoundBalance_ */ function _getBalanceInfo() @@ -130,21 +141,22 @@ contract TTokenCompoundStrategy_1 is RolesMods, TTokenStrategy { function _withdraw( uint256 amount, uint256 storedBal, - uint256 compoundBal, - uint16 storedRatio + uint256 compoundBal ) internal { // Calculate amount to rebalance - uint16 medianRatio = - (compoundStore().balanceRatioMax + - compoundStore().balanceRatioMin) / 2; - uint256 requiredBal = - NumbersLib.percent( - storedBal + compoundBal - amount, - medianRatio - storedRatio - ); - uint256 redeemAmount = requiredBal - storedBal + amount; + uint16 medianRatio = (compoundStore().balanceRatioMax + + compoundStore().balanceRatioMin) / 2; + uint256 requiredBal = NumbersLib.percent( + storedBal + compoundBal - amount, + medianRatio + ); + uint256 redeemAmount = requiredBal + amount - storedBal; // Withdraw tokens from Compound if needed - compoundStore().cToken.redeemUnderlying(redeemAmount); + require( + compoundStore().cToken.redeemUnderlying(redeemAmount) == + LibCompound.NO_ERROR, + "Teller: Strategy withdraw error - Compound" + ); } /** @@ -152,14 +164,20 @@ contract TTokenCompoundStrategy_1 is RolesMods, TTokenStrategy { * @param cTokenAddress Address of the Compound token that has the same underlying asset as the TToken. * @param balanceRatioMin Percentage indicating the _ limit of underlying token balance should remain on the TToken * @param balanceRatioMax Percentage indicating the _ limit of underlying token balance should remain on the TToken + * @dev Note that the balanceRatio percentages have to be scaled by ONE_HUNDRED_PERCENT */ function init( address cTokenAddress, uint16 balanceRatioMin, uint16 balanceRatioMax ) external { + require( + balanceRatioMax > balanceRatioMin, + "Teller: Max ratio balance should be greater than Min ratio balance" + ); compoundStore().cToken = ICErc20(cTokenAddress); compoundStore().balanceRatioMin = balanceRatioMin; compoundStore().balanceRatioMax = balanceRatioMax; + emit StrategyInitialized(NAME, cTokenAddress, LibMeta.msgSender()); } } diff --git a/contracts/lending/ttoken/strategies/compound/compound-storage.sol b/contracts/lending/ttoken/strategies/compound/compound-storage.sol new file mode 100644 index 000000000..2cb50d6d5 --- /dev/null +++ b/contracts/lending/ttoken/strategies/compound/compound-storage.sol @@ -0,0 +1,21 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +import { ICErc20 } from "../../../../shared/interfaces/ICErc20.sol"; + +struct Store { + ICErc20 cToken; + uint16 balanceRatioMax; + uint16 balanceRatioMin; +} + +bytes32 constant POSITION = keccak256( + "ttoken.strategy.compound.storage.position" +); + +function store() pure returns (Store storage s_) { + bytes32 position = POSITION; + assembly { + s_.slot := position + } +} diff --git a/contracts/lending/ttoken/token-storage.sol b/contracts/lending/ttoken/token-storage.sol new file mode 100644 index 000000000..ee0963725 --- /dev/null +++ b/contracts/lending/ttoken/token-storage.sol @@ -0,0 +1,33 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +import { ERC20, IERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol"; + +struct Store { + // The underlying asset of the tToken + ERC20 underlying; + // The address of the investment strategy contract managing the underlying assets + address strategy; + // The total amount of the underlying asset currently out in disbursed loans + uint256 totalBorrowed; + // The total amount of the underlying asset currently repaid from disbursed loans + uint256 totalRepaid; + // The total amount of the underlying asset currently repaid in the form of interest owed from disbursed loans + uint256 totalInterestRepaid; + // The decimals of the underlying ERC20 asset + uint8 decimals; + // The status of token investment restriction + bool restricted; +} + +bytes32 constant POSITION = keccak256("ttoken.storage.position"); + +/** + * @notice it saves the Store struct in a hashed slot + */ +function store() pure returns (Store storage s_) { + bytes32 position = POSITION; + assembly { + s_.slot := position + } +} diff --git a/contracts/market/CollateralFacet.sol b/contracts/market/CollateralFacet.sol index 01cd60356..986c88257 100644 --- a/contracts/market/CollateralFacet.sol +++ b/contracts/market/CollateralFacet.sol @@ -46,7 +46,11 @@ contract CollateralFacet is RolesMods, ReentryMods, PausableMods { ); // Transfer tokens to the collateral escrow - LibCollateral.deposit(loanID, amount); + LibCollateral.deposit( + loanID, + LibLoans.loan(loanID).collateralToken, + amount + ); } /** @@ -118,8 +122,8 @@ contract CollateralFacet is RolesMods, ReentryMods, PausableMods { view returns (address[] memory tokens_) { - EnumerableSet.AddressSet storage collateralTokens = - MarketStorageLib.store().collateralTokens[asset]; + EnumerableSet.AddressSet storage collateralTokens = MarketStorageLib + .store().collateralTokens[asset]; tokens_ = new address[](EnumerableSet.length(collateralTokens)); for (uint256 i; i < EnumerableSet.length(collateralTokens); i++) { tokens_[i] = EnumerableSet.at(collateralTokens, i); diff --git a/contracts/market/CreateLoanFacet.sol b/contracts/market/CreateLoanFacet.sol index 04c38e7d7..61790f92f 100644 --- a/contracts/market/CreateLoanFacet.sol +++ b/contracts/market/CreateLoanFacet.sol @@ -14,7 +14,6 @@ import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import { LibLoans } from "./libraries/LibLoans.sol"; import { LibEscrow } from "../escrow/libraries/LibEscrow.sol"; import { LibCollateral } from "./libraries/LibCollateral.sol"; -import { MarketLib } from "./libraries/MarketLib.sol"; import { LendingLib } from "../lending/libraries/LendingLib.sol"; import { PlatformSettingsLib @@ -33,7 +32,6 @@ import { NumbersLib } from "../shared/libraries/NumbersLib.sol"; import { NFTLib } from "../nft/libraries/NFTLib.sol"; import { Verifier } from "./cra/verifier.sol"; import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol"; -import { MarketLib } from "./libraries/MarketLib.sol"; import { ProcessRequestLib } from "./cra/ProcessRequestLib.sol"; // Interfaces @@ -48,7 +46,7 @@ import { Clones } from "@openzeppelin/contracts/proxy/Clones.sol"; // Storage import { - LoanRequest, + LoanRequestWithResponse, LoanStatus, LoanTerms, Loan, @@ -77,7 +75,10 @@ contract CreateLoanFacet is RolesMods, ReentryMods, PausableMods { * @notice Creates the loan from requests and validator responses then calling the main function. * @param request Struct of the protocol loan request */ - modifier __createLoan(LoanRequest calldata request, bool withNFT) { + modifier __createLoan( + LoanRequestWithResponse calldata request, + bool withNFT + ) { Loan storage loan = CreateLoanLib.createLoan(request, withNFT); _; @@ -87,33 +88,13 @@ contract CreateLoanFacet is RolesMods, ReentryMods, PausableMods { loan.duration = request.request.duration; } - // used for testing our zkcra function - function initializeMarketAdmins() external authorized(ADMIN, msg.sender) { - // setting market admin - // MarketLib.m(bytes32(0)).admin[msg.sender] = true; - // // setting providers admin - // MarketLib.p(bytes32(0)).admin[msg.sender] = true; - // MarketLib.p(bytes32(uint256(1))).admin[msg.sender] = true; - // MarketLib.p(bytes32(uint256(2))).admin[msg.sender] = true; - } - - function setProviderInformation( - bytes32 providerId, - uint32 maxAge, - address signer, - bool signerValue - ) external { - // MarketLib.setProviderSigner(providerId, signer, signerValue); - // MarketLib.setProviderMaxAge(providerId, maxAge); - } - /** * @notice Creates a loan with the loan request and NFTs without any collateral * @param request Struct of the protocol loan request * @param nftIDs IDs of TellerNFTs to use for the loan */ function takeOutLoanWithNFTs( - LoanRequest calldata request, + LoanRequestWithResponse calldata request, uint16[] calldata nftIDs ) external paused(LibLoans.ID, false) __createLoan(request, true) { // Get the ID of the newly created loan @@ -160,7 +141,7 @@ contract CreateLoanFacet is RolesMods, ReentryMods, PausableMods { * @param collateralAmount Amount of collateral required for the loan */ function takeOutLoan( - LoanRequest calldata request, + LoanRequestWithResponse calldata request, address collateralToken, uint256 collateralAmount ) @@ -196,7 +177,7 @@ contract CreateLoanFacet is RolesMods, ReentryMods, PausableMods { // Pay in collateral if (collateralAmount > 0) { - LibCollateral.deposit(loan.id, collateralAmount); + LibCollateral.deposit(loan.id, collateralToken, collateralAmount); } // Check that enough collateral has been provided for this loan @@ -220,23 +201,25 @@ contract CreateLoanFacet is RolesMods, ReentryMods, PausableMods { } library CreateLoanLib { - function createLoan(LoanRequest calldata request, bool withNFT) + function createLoan(LoanRequestWithResponse calldata request, bool withNFT) internal returns (Loan storage loan) { // Perform loan request checks - require( - msg.sender == request.request.borrower, - "Teller: not loan requester" - ); require( PlatformSettingsLib.getMaximumLoanDurationValue() >= request.request.duration, "Teller: max loan duration exceeded" ); // Get consensus values from request - (uint16 interestRate, uint16 collateralRatio, uint256 maxLoanAmount) = - ProcessRequestLib.processMarketRequest(request); + uint16 interestRate = 15000; + uint16 collateralRatio = 5000; + uint256 maxLoanAmount = 25000; + // ( + // uint16 interestRate, + // uint16 collateralRatio, + // uint256 maxLoanAmount + // ) = ProcessRequestLib.processMarketRequest(request); // Perform loan value checks require( @@ -252,6 +235,7 @@ library CreateLoanLib { // Get and increment new loan ID uint256 loanID = CreateLoanLib.newID(); + // Set loan data based on terms loan = LibLoans.loan(loanID); loan.id = uint128(loanID); @@ -284,23 +268,20 @@ library CreateLoanLib { * @return id_ the new ID requested, which stores it in the loan data */ function newID() internal returns (uint256 id_) { - Counters.Counter storage counter = - MarketStorageLib.store().loanIDCounter; + Counters.Counter storage counter = MarketStorageLib + .store() + .loanIDCounter; id_ = Counters.current(counter); Counters.increment(counter); } function currentID() internal view returns (uint256 id_) { - Counters.Counter storage counter = - MarketStorageLib.store().loanIDCounter; + Counters.Counter storage counter = MarketStorageLib + .store() + .loanIDCounter; id_ = Counters.current(counter); } - /** - * @notice it creates a new loan escrow contract - * @param loanID the ID that identifies the loan - * @return escrow_ the loanEscrow that gets created - */ function createEscrow(uint256 loanID) internal returns (address escrow_) { // Create escrow escrow_ = AppStorageLib.store().loansEscrowBeacon.cloneProxy(""); diff --git a/contracts/market/CreateLoanNFTFacet.sol b/contracts/market/CreateLoanNFTFacet.sol new file mode 100644 index 000000000..7e5e99116 --- /dev/null +++ b/contracts/market/CreateLoanNFTFacet.sol @@ -0,0 +1,199 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +// Contracts +import { PausableMods } from "../settings/pausable/PausableMods.sol"; +import { + ReentryMods +} from "../contexts2/access-control/reentry/ReentryMods.sol"; +import { RolesMods } from "../contexts2/access-control/roles/RolesMods.sol"; +import { AUTHORIZED, ADMIN } from "../shared/roles.sol"; +import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol"; + +// Libraries +import { LibLoans } from "./libraries/LibLoans.sol"; +import { LibEscrow } from "../escrow/libraries/LibEscrow.sol"; +import { LibCollateral } from "./libraries/LibCollateral.sol"; +import { LendingLib } from "../lending/libraries/LendingLib.sol"; +import { + PlatformSettingsLib +} from "../settings/platform/libraries/PlatformSettingsLib.sol"; +import { + MaxDebtRatioLib +} from "../settings/asset/libraries/MaxDebtRatioLib.sol"; +import { + MaxLoanAmountLib +} from "../settings/asset/libraries/MaxLoanAmountLib.sol"; +import { Counters } from "@openzeppelin/contracts/utils/Counters.sol"; +import { + EnumerableSet +} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol"; +import { NumbersLib } from "../shared/libraries/NumbersLib.sol"; +import { NFTLib } from "../nft/libraries/NFTLib.sol"; +import { Verifier } from "./cra/verifier.sol"; +import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol"; +import { ProcessRequestLib } from "./cra/ProcessRequestLib.sol"; + +// Interfaces +import { ILoansEscrow } from "../escrow/escrow/ILoansEscrow.sol"; +import { ITToken } from "../lending/ttoken/ITToken.sol"; + +// Proxy +import { + BeaconProxy +} from "@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol"; +import { Clones } from "@openzeppelin/contracts/proxy/Clones.sol"; + +// Storage +import { + LoanRequestNFT, + LoanStatus, + LoanTerms, + Loan, + MarketStorageLib, + Signature, + DataProviderSignature +} from "../storage/market.sol"; +import { AppStorageLib } from "../storage/app.sol"; + +contract CreateLoanNFTFacet is RolesMods, ReentryMods, PausableMods { + /** + * @notice This event is emitted when a loan has been successfully taken out + * @param loanID ID of loan from which collateral was withdrawn + * @param borrower Account address of the borrower + * @param amountBorrowed Total amount taken out in the loan + * @param withNFT Boolean indicating if the loan was taken out using NFTs + */ + event LoanTakenOutNFT( + uint256 indexed loanID, + address indexed borrower, + uint256 amountBorrowed, + bool withNFT + ); + + function takeOutLoanNFTs( + LoanRequestNFT calldata request, + uint16[] calldata nftIDs + ) external paused(LibLoans.ID, false) { + // create loan from library + Loan storage loan = CreateLoanNFTLib.createLoanNFT(request); + + // Create loan + uint256 loanID = CreateLoanNFTLib.currentID() - 1; + uint256 amount = LibLoans.loan(loanID).borrowedAmount; + uint8 lendingDecimals = ERC20(request.assetAddress).decimals(); + uint256 allowedBaseLoanSize; + for (uint256 i; i < nftIDs.length; i++) { + NFTLib.applyToLoan(loanID, nftIDs[i]); + + allowedBaseLoanSize += NFTLib.s().nftDictionary.tokenBaseLoanSize( + nftIDs[i] + ); + } + require( + amount <= allowedBaseLoanSize * (10**lendingDecimals), + "Teller: insufficient NFT loan size" + ); + + // Pull funds from Teller Token LP and transfer to the new loan escrow + LendingLib.tToken(LibLoans.loan(loanID).lendingToken).fundLoan( + CreateLoanNFTLib.createEscrow(loanID), + amount + ); + + emit LoanTakenOutNFT( + loanID, + msg.sender, + LibLoans.loan(loanID).borrowedAmount, + true + ); + + // set to active + loan.status = LoanStatus.Active; + loan.loanStartTime = uint32(block.timestamp); + loan.duration = request.duration; + } +} + +library CreateLoanNFTLib { + function createLoanNFT(LoanRequestNFT calldata request) + internal + returns (Loan storage loan) + { + // Perform loan request checks + require( + PlatformSettingsLib.getMaximumLoanDurationValue() >= + request.duration, + "Teller: max loan duration exceeded" + ); + + // tier 3 example + uint256 maxLoanAmount = 25000; + + // Perform loan value checks + require( + MaxLoanAmountLib.get(request.assetAddress) > maxLoanAmount, + "Teller: asset max loan amount exceeded" + ); + require( + LendingLib.tToken(request.assetAddress).debtRatioFor( + maxLoanAmount + ) <= MaxDebtRatioLib.get(request.assetAddress), + "Teller: max supply-to-debt ratio exceeded" + ); + + // Get and increment new loan ID + uint256 loanID = CreateLoanNFTLib.newID(); + + // Set loan data based on terms + loan = LibLoans.loan(loanID); + loan.id = uint128(loanID); + loan.status = LoanStatus.TermsSet; + loan.lendingToken = request.assetAddress; + loan.borrower = request.borrower; + loan.borrowedAmount = maxLoanAmount; + + // since we are creating a loan with nft, we get the nft interest rate from + // our platform settings + loan.interestRate = PlatformSettingsLib.getNFTInterestRate(); + + // Set loan debt + LibLoans.debt(loanID).principalOwed = maxLoanAmount; + LibLoans.debt(loanID).interestOwed = LibLoans.getInterestOwedFor( + uint256(loanID), + maxLoanAmount + ); + + // Add loanID to borrower list + MarketStorageLib.store().borrowerLoans[loan.borrower].push( + uint128(loanID) + ); + } + + /** + * @notice increments the loanIDCounter + * @return id_ the new ID requested, which stores it in the loan data + */ + function newID() internal returns (uint256 id_) { + Counters.Counter storage counter = MarketStorageLib + .store() + .loanIDCounter; + id_ = Counters.current(counter); + Counters.increment(counter); + } + + function currentID() internal view returns (uint256 id_) { + Counters.Counter storage counter = MarketStorageLib + .store() + .loanIDCounter; + id_ = Counters.current(counter); + } + + function createEscrow(uint256 loanID) internal returns (address escrow_) { + // Create escrow + escrow_ = AppStorageLib.store().loansEscrowBeacon.cloneProxy(""); + ILoansEscrow(escrow_).init(); + // Save escrow address for loan + MarketStorageLib.store().loanEscrows[loanID] = ILoansEscrow(escrow_); + } +} diff --git a/contracts/market/CreateLoanSnarkFacet.sol b/contracts/market/CreateLoanSnarkFacet.sol new file mode 100644 index 000000000..58c192246 --- /dev/null +++ b/contracts/market/CreateLoanSnarkFacet.sol @@ -0,0 +1,219 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +// Contracts +import { PausableMods } from "../settings/pausable/PausableMods.sol"; +import { + ReentryMods +} from "../contexts2/access-control/reentry/ReentryMods.sol"; +import { RolesMods } from "../contexts2/access-control/roles/RolesMods.sol"; +import { AUTHORIZED, ADMIN } from "../shared/roles.sol"; +import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol"; + +// Libraries +import { LibLoans } from "./libraries/LibLoans.sol"; +import { LibEscrow } from "../escrow/libraries/LibEscrow.sol"; +import { LibCollateral } from "./libraries/LibCollateral.sol"; +import { LendingLib } from "../lending/libraries/LendingLib.sol"; +import { + PlatformSettingsLib +} from "../settings/platform/libraries/PlatformSettingsLib.sol"; +import { + MaxDebtRatioLib +} from "../settings/asset/libraries/MaxDebtRatioLib.sol"; +import { + MaxLoanAmountLib +} from "../settings/asset/libraries/MaxLoanAmountLib.sol"; +import { Counters } from "@openzeppelin/contracts/utils/Counters.sol"; +import { + EnumerableSet +} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol"; +import { NumbersLib } from "../shared/libraries/NumbersLib.sol"; +import { NFTLib } from "../nft/libraries/NFTLib.sol"; +import { Verifier } from "./cra/verifier.sol"; +import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol"; +import { ProcessRequestLib } from "./cra/ProcessRequestLib.sol"; + +// Interfaces +import { ILoansEscrow } from "../escrow/escrow/ILoansEscrow.sol"; +import { ITToken } from "../lending/ttoken/ITToken.sol"; + +// Proxy +import { + BeaconProxy +} from "@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol"; +import { Clones } from "@openzeppelin/contracts/proxy/Clones.sol"; + +// Storage +import { + LoanRequestSnark, + LoanStatus, + LoanTerms, + Loan, + MarketStorageLib, + Signature, + DataProviderSignature +} from "../storage/market.sol"; +import { AppStorageLib } from "../storage/app.sol"; + +contract CreateLoanSnarkFacet is RolesMods, ReentryMods, PausableMods { + /** + * @notice This event is emitted when a loan has been successfully taken out + * @param loanID ID of loan from which collateral was withdrawn + * @param borrower Account address of the borrower + * @param amountBorrowed Total amount taken out in the loan + * @param withNFT Boolean indicating if the loan was taken out using NFTs + */ + event LoanTakenOutSnark( + uint256 indexed loanID, + address indexed borrower, + uint256 amountBorrowed, + bool withNFT + ); + + function takeOutLoanSnark( + LoanRequestSnark calldata request, + address collateralToken, + uint256 collateralAmount + ) + external + payable + paused(LibLoans.ID, false) + nonReentry("") + authorized(AUTHORIZED, msg.sender) + { + // create loan from library + Loan storage loan = CreateLoanSnarkLib.createLoanSnark(request); + // Check if collateral token is zero + require( + collateralToken != address(0x0), + "Teller: token addr can't be 0" + ); + + // Verify collateral token is acceptable + require( + EnumerableSet.contains( + MarketStorageLib.store().collateralTokens[ + request.request.assetAddress + ], + collateralToken + ), + "Teller: collateral token not allowed" + ); + + // Save collateral token to loan + loan.collateralToken = collateralToken; + + // Pay in collateral + if (collateralAmount > 0) { + LibCollateral.deposit(loan.id, collateralToken, collateralAmount); + } + + // Check that enough collateral has been provided for this loan + require( + LibLoans.getCollateralNeeded(loan.id) <= + LibCollateral.e(loan.id).loanSupply(loan.id), + "Teller: more collateral required" + ); + // Pull funds from Teller token LP and and transfer to the recipient + ITToken tToken = LendingLib.tToken(request.request.assetAddress); + + tToken.fundLoan( + LibLoans.canGoToEOAWithCollateralRatio(loan.collateralRatio) + ? loan.borrower + : CreateLoanSnarkLib.createEscrow(loan.id), + loan.borrowedAmount + ); + + emit LoanTakenOutSnark(loan.id, msg.sender, loan.borrowedAmount, false); + // set to active + loan.status = LoanStatus.Active; + loan.loanStartTime = uint32(block.timestamp); + loan.duration = request.request.duration; + } +} + +library CreateLoanSnarkLib { + function createLoanSnark(LoanRequestSnark calldata request) + internal + returns (Loan storage loan) + { + // Perform loan request checks + require( + PlatformSettingsLib.getMaximumLoanDurationValue() >= + request.request.duration, + "Teller: max loan duration exceeded" + ); + + // Get market values + ( + uint16 interestRate, + uint16 collateralRatio, + uint256 maxLoanAmount + ) = ProcessRequestLib.processMarketRequest(request); + + // Perform loan value checks + require( + MaxLoanAmountLib.get(request.request.assetAddress) > maxLoanAmount, + "Teller: asset max loan amount exceeded" + ); + require( + LendingLib.tToken(request.request.assetAddress).debtRatioFor( + maxLoanAmount + ) <= MaxDebtRatioLib.get(request.request.assetAddress), + "Teller: max supply-to-debt ratio exceeded" + ); + + // Get and increment new loan ID + uint256 loanID = CreateLoanSnarkLib.newID(); + + // Set loan data based on terms + loan = LibLoans.loan(loanID); + loan.id = uint128(loanID); + loan.status = LoanStatus.TermsSet; + loan.lendingToken = request.request.assetAddress; + loan.borrower = request.request.borrower; + loan.borrowedAmount = maxLoanAmount; + loan.interestRate = interestRate; + loan.collateralRatio = collateralRatio; + + // Set loan debt + LibLoans.debt(loanID).principalOwed = maxLoanAmount; + LibLoans.debt(loanID).interestOwed = LibLoans.getInterestOwedFor( + uint256(loanID), + maxLoanAmount + ); + + // Add loanID to borrower list + MarketStorageLib.store().borrowerLoans[loan.borrower].push( + uint128(loanID) + ); + } + + /** + * @notice increments the loanIDCounter + * @return id_ the new ID requested, which stores it in the loan data + */ + function newID() internal returns (uint256 id_) { + Counters.Counter storage counter = MarketStorageLib + .store() + .loanIDCounter; + id_ = Counters.current(counter); + Counters.increment(counter); + } + + function currentID() internal view returns (uint256 id_) { + Counters.Counter storage counter = MarketStorageLib + .store() + .loanIDCounter; + id_ = Counters.current(counter); + } + + function createEscrow(uint256 loanID) internal returns (address escrow_) { + // Create escrow + escrow_ = AppStorageLib.store().loansEscrowBeacon.cloneProxy(""); + ILoansEscrow(escrow_).init(); + // Save escrow address for loan + MarketStorageLib.store().loanEscrows[loanID] = ILoansEscrow(escrow_); + } +} diff --git a/contracts/market/LoanDataFacet.sol b/contracts/market/LoanDataFacet.sol index 51b9df362..bf902e2ff 100644 --- a/contracts/market/LoanDataFacet.sol +++ b/contracts/market/LoanDataFacet.sol @@ -94,7 +94,6 @@ contract LoanDataFacet { */ function getCollateralNeededInfo(uint256 loanID) external - view returns ( uint256 neededInLendingTokens, uint256 neededInCollateralTokens, @@ -122,11 +121,7 @@ contract LoanDataFacet { * @param loanID the identifier of the respective escrow's loan * @return the total value of the loan escrow */ - function getLoanEscrowValue(uint256 loanID) - external - view - returns (uint256) - { + function getLoanEscrowValue(uint256 loanID) external returns (uint256) { return LibEscrow.calculateTotalValue(loanID); } @@ -140,8 +135,8 @@ contract LoanDataFacet { view returns (address[] memory tokens_) { - EnumerableSet.AddressSet storage escrowTokens = - LibEscrow.getEscrowTokens(loanID); + EnumerableSet.AddressSet storage escrowTokens = LibEscrow + .getEscrowTokens(loanID); tokens_ = new address[](EnumerableSet.length(escrowTokens)); for (uint256 i; i < tokens_.length; i++) { tokens_[i] = EnumerableSet.at(escrowTokens, i); diff --git a/contracts/market/RepayFacet.sol b/contracts/market/RepayFacet.sol index 80c8871cc..b5400011a 100644 --- a/contracts/market/RepayFacet.sol +++ b/contracts/market/RepayFacet.sol @@ -27,7 +27,6 @@ import { PlatformSettingsLib } from "../settings/platform/libraries/PlatformSettingsLib.sol"; import { NumbersLib } from "../shared/libraries/NumbersLib.sol"; -import { PriceAggLib } from "../price-aggregator/PriceAggLib.sol"; import { NFTLib } from "../nft/libraries/NFTLib.sol"; // Interfaces @@ -35,6 +34,7 @@ import { ITToken } from "../lending/ttoken/ITToken.sol"; import { ILoansEscrow } from "../escrow/escrow/ILoansEscrow.sol"; // Storage +import { AppStorageLib } from "../storage/app.sol"; import { MarketStorageLib, MarketStorage, @@ -88,13 +88,16 @@ contract RepayFacet is RolesMods, ReentryMods, PausableMods, EscrowClaimTokens { authorized(AUTHORIZED, msg.sender) nonReentry("") { - uint256 balance = - LibEscrow.balanceOf(loanID, LibLoans.loan(loanID).lendingToken); + uint256 balance = LibEscrow.balanceOf( + loanID, + LibLoans.loan(loanID).lendingToken + ); uint256 totalOwed = LibLoans.getTotalOwed(loanID); // if there isn't enough balance in the escrow, then transfer amount needed to the escrow if (balance < totalOwed && amount > balance) { - uint256 amountNeeded = - amount > totalOwed ? totalOwed - (balance) : amount - (balance); + uint256 amountNeeded = amount > totalOwed + ? totalOwed - (balance) + : amount - (balance); SafeERC20.safeTransferFrom( IERC20(LibLoans.loan(loanID).lendingToken), @@ -149,10 +152,9 @@ contract RepayFacet is RolesMods, ReentryMods, PausableMods, EscrowClaimTokens { } // Get the Teller token for the loan - ITToken tToken = - MarketStorageLib.store().tTokens[ - LibLoans.loan(loanID).lendingToken - ]; + ITToken tToken = MarketStorageLib.store().tTokens[ + LibLoans.loan(loanID).lendingToken + ]; // Transfer funds from an escrow if an escrow is calling it // Otherwise, transfer funds from an account if (address(LibEscrow.e(loanID)) == sender) { @@ -249,13 +251,12 @@ contract RepayFacet is RolesMods, ReentryMods, PausableMods, EscrowClaimTokens { ); // Calculate the reward before repaying the loan - (uint256 rewardInLending, uint256 collateralInLending) = - RepayLib.getLiquidationReward(loanID, collateralAmount); + (uint256 rewardInLending, uint256 collateralInLending) = RepayLib + .getLiquidationReward(loanID, collateralAmount); // The liquidator pays the amount still owed on the loan - uint256 amountToLiquidate = - LibLoans.debt(loanID).principalOwed + - LibLoans.debt(loanID).interestOwed; + uint256 amountToLiquidate = LibLoans.debt(loanID).principalOwed + + LibLoans.debt(loanID).interestOwed; __repayLoan(loanID, amountToLiquidate, msg.sender, true); @@ -287,14 +288,13 @@ contract RepayFacet is RolesMods, ReentryMods, PausableMods, EscrowClaimTokens { */ function getLiquidationReward(uint256 loanID) external - view returns (uint256 inLending_, uint256 inCollateral_) { (inLending_, ) = RepayLib.getLiquidationReward( loanID, LibCollateral.e(loanID).loanSupply(loanID) ); - inCollateral_ = PriceAggLib.valueFor( + inCollateral_ = AppStorageLib.store().priceAggregator.getValueFor( LibLoans.loan(loanID).lendingToken, LibLoans.loan(loanID).collateralToken, inLending_ @@ -310,7 +310,6 @@ library RepayLib { */ function isLiquidable(uint256 loanID, uint256 collateralAmount) internal - view returns (bool) { Loan storage loan = LibLoans.loan(loanID); @@ -321,8 +320,8 @@ library RepayLib { if (loan.collateralRatio > 0) { // If loan has a collateral ratio, check how much is needed - (, uint256 neededInCollateral, ) = - LoanDataFacet(address(this)).getCollateralNeededInfo(loanID); + (, uint256 neededInCollateral, ) = LoanDataFacet(address(this)) + .getCollateralNeededInfo(loanID); if (neededInCollateral > collateralAmount) { return true; } @@ -340,28 +339,27 @@ library RepayLib { */ function getLiquidationReward(uint256 loanID, uint256 collateralAmount) internal - view returns (uint256 reward_, uint256 collateralValue_) { - uint256 amountToLiquidate = - LibLoans.debt(loanID).principalOwed + - LibLoans.debt(loanID).interestOwed; + uint256 amountToLiquidate = LibLoans.debt(loanID).principalOwed + + LibLoans.debt(loanID).interestOwed; // Max reward is amount repaid on loan plus extra percentage - uint256 maxReward = - amountToLiquidate + - NumbersLib.percent( - amountToLiquidate, - uint16(PlatformSettingsLib.getLiquidateRewardPercent()) - ); + uint256 maxReward = amountToLiquidate + + NumbersLib.percent( + amountToLiquidate, + uint16(PlatformSettingsLib.getLiquidateRewardPercent()) + ); // Calculate available collateral for reward if (collateralAmount > 0) { - collateralValue_ = PriceAggLib.valueFor( - LibLoans.loan(loanID).collateralToken, - LibLoans.loan(loanID).lendingToken, - collateralAmount - ); + collateralValue_ = AppStorageLib.store() + .priceAggregator + .getValueFor( + LibLoans.loan(loanID).collateralToken, + LibLoans.loan(loanID).lendingToken, + collateralAmount + ); reward_ += collateralValue_; } @@ -401,8 +399,9 @@ library RepayLib { // if the lending reward is less than the collateral lending tokens, then aggregate // the value for the lending token with the collateral token and send it to the liquidator if (rewardInLending <= collateralInLending) { - uint256 rewardInCollateral = - PriceAggLib.valueFor( + uint256 rewardInCollateral = AppStorageLib.store() + .priceAggregator + .getValueFor( LibLoans.loan(loanID).lendingToken, LibLoans.loan(loanID).collateralToken, rewardInLending @@ -433,8 +432,8 @@ library RepayLib { address recipient, uint256 value ) private { - EnumerableSet.AddressSet storage tokens = - MarketStorageLib.store().escrowTokens[loanID]; + EnumerableSet.AddressSet storage tokens = MarketStorageLib.store() + .escrowTokens[loanID]; uint256 valueLeftToTransfer = value; // Start with the lending token @@ -483,11 +482,13 @@ library RepayLib { if (token == LibLoans.loan(loanID).lendingToken) { balanceInLending = balance; } else { - balanceInLending = PriceAggLib.valueFor( - token, - LibLoans.loan(loanID).lendingToken, - balance - ); + balanceInLending = AppStorageLib.store() + .priceAggregator + .getValueFor( + token, + LibLoans.loan(loanID).lendingToken, + balance + ); } if (balanceInLending <= valueLeftToTransfer) { diff --git a/contracts/market/collateral/CollateralEscrow_V1.sol b/contracts/market/collateral/CollateralEscrow_V1.sol index 2352fd72e..13379c666 100644 --- a/contracts/market/collateral/CollateralEscrow_V1.sol +++ b/contracts/market/collateral/CollateralEscrow_V1.sol @@ -18,14 +18,17 @@ import { Address } from "@openzeppelin/contracts/utils/Address.sol"; contract CollateralEscrow_V1 is OwnableUpgradeable, ICollateralEscrow { mapping(uint256 => uint256) internal _balances; // loanID -> collateral address public collateralToken; - bool internal _isWETH; + bool internal _isWrappedNativeToken; // Should this be renamed to _isNetworkToken? more agnostic in cases of WMATIC /** * @notice it initializes an escrow * @param tokenAddress the address of the collateral token to be stored - * @param isWETH check if it's wrapped Ethereum + * @param isWrappedNativeToken check if it's wrapped Ethereum/MATIC */ - function init(address tokenAddress, bool isWETH) external override { + function init(address tokenAddress, bool isWrappedNativeToken) + external + override + { require( tokenAddress != address(0), "Teller escrow: collateral token address 0" @@ -33,7 +36,7 @@ contract CollateralEscrow_V1 is OwnableUpgradeable, ICollateralEscrow { OwnableUpgradeable.__Ownable_init(); collateralToken = tokenAddress; - _isWETH = isWETH; + _isWrappedNativeToken = isWrappedNativeToken; } /** @@ -47,7 +50,7 @@ contract CollateralEscrow_V1 is OwnableUpgradeable, ICollateralEscrow { override onlyOwner { - if (_isWETH && msg.value > 0) { + if (_isWrappedNativeToken && msg.value > 0) { require(msg.value == amount, "Teller: incorrect eth deposit"); IWETH(collateralToken).deposit{ value: msg.value }(); } else { diff --git a/contracts/market/cra/ProcessRequestLib.sol b/contracts/market/cra/ProcessRequestLib.sol index d20b7d629..5b4cad3d0 100644 --- a/contracts/market/cra/ProcessRequestLib.sol +++ b/contracts/market/cra/ProcessRequestLib.sol @@ -2,7 +2,7 @@ pragma solidity ^0.8.0; import { - LoanRequest, + LoanRequestSnark, DataProviderSignature, Signature } from "../../storage/market.sol"; @@ -22,7 +22,7 @@ library ProcessRequestLib { * @return collateralRatio the collateral ratio required for the loan, if any * @return maxLoanAmount the max loan amount the user is entitled to */ - function processMarketRequest(LoanRequest memory request) + function processMarketRequest(LoanRequestSnark memory request) public returns ( uint16 interestRate, @@ -30,8 +30,9 @@ library ProcessRequestLib { uint256 maxLoanAmount ) { - MarketHandler marketHandler = - MarketHandler(request.marketHandlerAddress); + MarketHandler marketHandler = MarketHandler( + request.marketHandlerAddress + ); // Overwrite the first snark witness item with the on-chain identifier // for the loan (msg.sender ^ nonce). This forces the CRA to have been // run with the proper identifier. @@ -134,18 +135,17 @@ library ProcessRequestLib { bytes32 commitment, address providerAddress ) private view { - address recoveredSigner = - ECDSA.recover( - keccak256( - abi.encodePacked( - "\x19Ethereum Signed Message:\n32", - uint256(commitment) - ) - ), - signature.v, - signature.r, - signature.s - ); + address recoveredSigner = ECDSA.recover( + keccak256( + abi.encodePacked( + "\x19Ethereum Signed Message:\n32", + uint256(commitment) + ) + ), + signature.v, + signature.r, + signature.s + ); DataProvider provider = DataProvider(providerAddress); require( provider.signers(recoveredSigner), diff --git a/contracts/market/cra/market-handler/MarketHandler.sol b/contracts/market/cra/market-handler/MarketHandler.sol index 2b038d270..cdc99951a 100644 --- a/contracts/market/cra/market-handler/MarketHandler.sol +++ b/contracts/market/cra/market-handler/MarketHandler.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: MIT pragma solidity ^0.8.3; -import { LoanRequest } from "../../../storage/market.sol"; +import { LoanRequestSnark } from "../../../storage/market.sol"; import { DataProvider } from "../DataProvider.sol"; import { EnumerableSet @@ -48,7 +48,7 @@ abstract contract MarketHandler { * @return userCollateralRatio returns the collateral ratio of the user based on his score * @return userLoanAmount returns the amount for the user to take a loan out based on his score */ - function handler(uint256 marketScore, LoanRequest memory request) + function handler(uint256 marketScore, LoanRequestSnark memory request) external view virtual diff --git a/contracts/market/cra/market-handler/TellerMarketHandler.sol b/contracts/market/cra/market-handler/TellerMarketHandler.sol index aa36e0a8f..5371f40c1 100644 --- a/contracts/market/cra/market-handler/TellerMarketHandler.sol +++ b/contracts/market/cra/market-handler/TellerMarketHandler.sol @@ -1,13 +1,14 @@ // SPDX-License-Identifier: MIT pragma solidity ^0.8.3; -import { LoanRequest } from "../../../storage/market.sol"; +import { LoanRequestSnark } from "../../../storage/market.sol"; import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol"; import { MarketHandler } from "./MarketHandler.sol"; +import { Rates } from "../../data/states.sol"; -contract TellerMarketHandler is MarketHandler { +contract TellerMarketHandler is MarketHandler, Rates { constructor( uint16 maxInterestRate, uint16 collateralRatio, @@ -15,7 +16,7 @@ contract TellerMarketHandler is MarketHandler { ) MarketHandler(maxInterestRate, collateralRatio, maxLoanAmount) {} // teller market handler - function handler(uint256 marketScore, LoanRequest memory request) + function handler(uint256 marketScore, LoanRequestSnark memory request) external view override @@ -25,25 +26,63 @@ contract TellerMarketHandler is MarketHandler { uint256 userLoanAmount ) { + uint256 amount = 0; + + // get amount for user based on market score + if (marketScore >= 5 && marketScore < 7) { + amount = _loanAmount(18000, 10000, 7, 5, marketScore); + } else if (marketScore >= 7 && marketScore < 9) { + amount = _loanAmount(23000, 18000, 9, 7, marketScore); + } else if (marketScore >= 9 && marketScore <= 10) { + amount = _loanAmount(25000, 23000, 10, 9, marketScore); + } + // get interest rate uint16 baseInterestRate = 1000; - uint16 interestRate = - baseInterestRate * - ((maxCollateralRatio / request.request.collateralRatio + 1) / - 2); - userInterestRate = interestRate; - - // loan score multiplier - uint16 scoreMultiplier = 100; + + uint16 interestRate = baseInterestRate * + ((maxCollateralRatio / request.request.collateralRatio) / 2); + // Illinois interest rate for testing - uint16 sampleCappedInterestRate = 900; + uint16 sampleCappedInterestRate = rates[uint16(request.request.code)]; - // get loan - uint256 loanAmount = - (marketScore * scoreMultiplier) / + bool useLegalIR = interestRate > sampleCappedInterestRate; + + if (useLegalIR) { + userInterestRate = sampleCappedInterestRate; + userLoanAmount = + (amount) / (interestRate / (sampleCappedInterestRate + 1)); - userLoanAmount = loanAmount; + } else { + userInterestRate = interestRate; + // + userLoanAmount = amount; + } userCollateralRatio = request.request.collateralRatio; } + + /** + * @notice it calculates the loan amount from different bounds + * @param highestAmountBound the highest amount in a select bound (i.e 20000) + * @param lowestAmountBound the lowest amount in a select bound (i.e 10000) + * @param highestScoreBound the highest score in a select bound (i.e 7.5) + * @param lowestScoreBound the lowest score in a select bound + */ + function _loanAmount( + uint256 highestAmountBound, + uint256 lowestAmountBound, + uint16 highestScoreBound, + uint16 lowestScoreBound, + uint256 scoreToCalculate + ) internal pure returns (uint256 amount) { + // calculate for slope + uint256 m = (highestAmountBound - lowestAmountBound) / + (highestScoreBound - lowestScoreBound); + + // return amount + amount = + highestAmountBound - + ((m) * uint256((highestScoreBound - scoreToCalculate))); + } } diff --git a/contracts/market/data/states.sol b/contracts/market/data/states.sol new file mode 100644 index 000000000..1c619ba91 --- /dev/null +++ b/contracts/market/data/states.sol @@ -0,0 +1,114 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.3; + +library States { + enum StatesCode { + AK, + AL, + AR, + AZ, + CA, + CO, + CT, + DC, + DE, + FL, + GA, + HI, + IA, + ID, + IL, + IN, + KS, + KY, + LA, + MA, + MD, + ME, + MI, + MN, + MO, + MS, + MT, + NC, + ND, + NE, + NH, + NJ, + NM, + NV, + NY, + OH, + OK, + OR, + PA, + RI, + SC, + SD, + TN, + TX, + UT, + VA, + VT, + WA, + WI, + WV, + WY + } +} + +contract Rates { + uint16[] public rates = [ + 1050, + 600, + 500, + 1000, + 1000, + 800, + 1200, + 600, + 500, + 1200, + 700, + 1200, + 500, + 1200, + 900, + 2100, + 1000, + 800, + 1200, + 600, + 600, + 800, + 500, + 800, + 900, + 800, + 1000, + 800, + 550, + 600, + 1000, + 600, + 1500, + 0, + 1600, + 800, + 600, + 900, + 600, + 1200, + 875, + 1500, + 1000, + 600, + 1000, + 800, + 1200, + 1200, + 500, + 600, + 700 + ]; +} diff --git a/contracts/market/libraries/LibCollateral.sol b/contracts/market/libraries/LibCollateral.sol index 43a38eb18..71cade112 100644 --- a/contracts/market/libraries/LibCollateral.sol +++ b/contracts/market/libraries/LibCollateral.sol @@ -54,8 +54,20 @@ library LibCollateral { * @param loanID the respective loan ID * @param amount the amount of collateral to deposit */ - function deposit(uint256 loanID, uint256 amount) internal { - e(loanID).deposit{ value: amount }(loanID, amount); + function deposit( + uint256 loanID, + address collateralToken, + uint256 amount + ) internal { + if (msg.value == 0) { + IERC20(collateralToken).transferFrom( + msg.sender, + address(this), + amount + ); + IERC20(collateralToken).approve(address(e(loanID)), amount); + } + e(loanID).deposit{ value: msg.value }(loanID, amount); emit CollateralDeposited(loanID, msg.sender, amount); } @@ -93,12 +105,13 @@ library LibCollateral { // Check if collateral escrow exists if (address(e(token)) == address(0)) { // Create escrow - address escrow = - AppStorageLib.store().collateralEscrowBeacon.cloneProxy(""); + address escrow = AppStorageLib.store() + .collateralEscrowBeacon + .cloneProxy(""); ICollateralEscrow(escrow).init( token, - // Check if collateral token is WETH - token == AppStorageLib.store().assetAddresses["WETH"] + // Check if collateral token is the base network token + token == AppStorageLib.store().wrappedNativeToken ); // Set max allowance diff --git a/contracts/market/libraries/LibLoans.sol b/contracts/market/libraries/LibLoans.sol index de5cb60f7..3f93170f2 100644 --- a/contracts/market/libraries/LibLoans.sol +++ b/contracts/market/libraries/LibLoans.sol @@ -7,9 +7,9 @@ import { NumbersLib } from "../../shared/libraries/NumbersLib.sol"; import { PlatformSettingsLib } from "../../settings/platform/libraries/PlatformSettingsLib.sol"; -import { PriceAggLib } from "../../price-aggregator/PriceAggLib.sol"; // Storage +import { AppStorageLib } from "../../storage/app.sol"; import { MarketStorageLib, MarketStorage, @@ -98,7 +98,6 @@ library LibLoans { */ function getCollateralNeeded(uint256 loanID) internal - view returns (uint256 _needed) { (, _needed, ) = getCollateralNeededInfo(loanID); @@ -113,7 +112,6 @@ library LibLoans { */ function getCollateralNeededInfo(uint256 loanID) internal - view returns ( uint256 neededInLendingTokens, uint256 neededInCollateralTokens, @@ -128,11 +126,13 @@ library LibLoans { if (neededInLendingTokens == 0) { neededInCollateralTokens = 0; } else { - neededInCollateralTokens = PriceAggLib.valueFor( - loan(loanID).lendingToken, - loan(loanID).collateralToken, - neededInLendingTokens - ); + neededInCollateralTokens = AppStorageLib.store() + .priceAggregator + .getValueFor( + loan(loanID).lendingToken, + loan(loanID).collateralToken, + neededInLendingTokens + ); } } @@ -146,7 +146,6 @@ library LibLoans { */ function getCollateralNeededInTokens(uint256 loanID) internal - view returns (uint256 neededInLendingTokens, uint256 escrowLoanValue) { if (loan(loanID).collateralRatio == 0) { @@ -168,10 +167,9 @@ library LibLoans { loan(loanID).collateralRatio ); } else if (loan(loanID).status == LoanStatus.Active) { - uint16 requiredRatio = - loan(loanID).collateralRatio - - getInterestRatio(loanID) - - uint16(PlatformSettingsLib.getCollateralBufferValue()); + uint16 requiredRatio = loan(loanID).collateralRatio - + getInterestRatio(loanID) - + uint16(PlatformSettingsLib.getCollateralBufferValue()); neededInLendingTokens = debt(loanID).principalOwed + diff --git a/contracts/market/libraries/MarketLib.sol b/contracts/market/libraries/MarketLib.sol deleted file mode 100644 index 3a3806db9..000000000 --- a/contracts/market/libraries/MarketLib.sol +++ /dev/null @@ -1,156 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity ^0.8.0; - -// external contracts -import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol"; - -// Teller contracts -import { PausableMods } from "../../settings/pausable/PausableMods.sol"; -import { - ReentryMods -} from "../../contexts2/access-control/reentry/ReentryMods.sol"; -import { RolesMods } from "../../contexts2/access-control/roles/RolesMods.sol"; -import { ADMIN } from "../../shared/roles.sol"; -import { - Signature, - MarketStorageLib, - MarketStorage, - MarketConfig, - ProviderConfig, - LoanRequest -} from "../../storage/market.sol"; -import { Verifier } from "../cra/verifier.sol"; -import { LibLoans } from "../libraries/LibLoans.sol"; - -// import reentry guard - -library MarketLib { - // function s() internal pure returns (MarketStorage storage s_) { - // s_ = MarketStorageLib.store(); - // } - // function m(bytes32 marketId) - // internal - // view - // returns (MarketConfig storage m_) - // { - // m_ = s().markets[marketId]; - // } - // function p(bytes32 providerId) - // internal - // view - // returns (ProviderConfig storage p_) - // { - // p_ = s().providers[providerId]; - // } - // function c(bytes32 commitmentId) internal view returns (bool c_) { - // c_ = s().usedCommitments[commitmentId]; - // } - // function setProviderAdmin( - // bytes32 providerId, - // address account, - // bool admin - // ) internal onlyProviderAdmin(providerId) { - // p(providerId).signer[account] = admin; - // } - // function getProviderAdmin(bytes32 providerId) - // internal - // view - // returns (bool admin) - // { - // admin = p(providerId).signer[msg.sender]; - // } - // function setProviderSigner( - // bytes32 providerId, - // address account, - // bool signerValue - // ) internal onlyProviderAdmin(providerId) { - // p(providerId).signer[account] = signerValue; - // } - // function setProviderMaxAge(bytes32 providerId, uint32 maxAge) - // internal - // onlyProviderAdmin(providerId) - // { - // p(providerId).maxAge = maxAge; - // } - // function setMarketAdmin( - // bytes32 marketId, - // address account, - // bool admin - // ) internal onlyMarketAdmin(marketId) { - // m(marketId).admin[account] = admin; - // } - // /** - // * @notice it gets the user score and user request then returns the loan interest rate, - // * loan collateral ratio and loan amount. - // * @param marketScore the score of the user - // * @param request the user's request for the loan - // * @return userInterestRate returns the interest rate for the user based on his score - // * @return userCollateralRatio returns the collateral ratio of the user based on his score - // * @return userLoanAmount returns the amount for the user to take a loan out based on his score - // */ - // function handler(uint256 marketScore, LoanRequest memory request) - // internal - // pure - // returns ( - // uint16 userInterestRate, - // uint16 userCollateralRatio, - // uint256 userLoanAmount - // ) - // { - // require(marketScore > 5, "market score not high enough!"); - // ( - // uint16 marketInterestRate, - // uint16 marketCollateralRatio, - // uint256 marketLoanAmount - // ) = _getMarketInformation(request.marketId); - // // uint256 marketScoreForInterestRatio = (marketScore - 5) / 5; - // // userInterestRate = uint16( - // // marketInterestRate - - // // (marketScoreForInterestRatio * marketInterestRate) - // // ); - // // to compile for now - // userInterestRate = marketInterestRate; - // userCollateralRatio = marketCollateralRatio; - // userLoanAmount = marketLoanAmount; - // } - // /** - // * @notice it retrieves market information concerning max interest rate, collateral ratio and - // * loan amount. This information is for use by the market handler - // * @param marketId the market to get the information from - // * @return maxInterestRate the maximum interest rate set in a market - // * @return maxCollateralRatio the maximum collateral ratio set in a market - // * @return maxLoanAmount the maximum loan amount set in a market - // */ - // function _getMarketInformation(bytes32 marketId) - // internal - // pure - // returns ( - // uint16 maxInterestRate, - // uint16 maxCollateralRatio, - // uint256 maxLoanAmount - // ) - // { - // uint16 _maxInterestRate; - // uint16 _maxCollateralRatio; - // uint256 _maxLoanAmount; - // // if market id is teller market - // if (marketId == bytes32(0)) { - // _maxInterestRate = 10000; - // _maxCollateralRatio = 15000; - // _maxLoanAmount = 25000; - // } else { - // // get market information from other markets - // } - // maxInterestRate = _maxInterestRate; - // maxCollateralRatio = _maxCollateralRatio; - // maxLoanAmount = _maxLoanAmount; - // } - // modifier onlyMarketAdmin(bytes32 marketId) { - // require(m(marketId).admin[msg.sender], "Teller: not market admin"); - // _; - // } - // modifier onlyProviderAdmin(bytes32 providerId) { - // require(p(providerId).admin[msg.sender], "Teller: not provider admin"); - // _; - // } -} diff --git a/contracts/nft/NFTFacet.sol b/contracts/nft/NFTFacet.sol index d421dddcf..2e6a248b4 100644 --- a/contracts/nft/NFTFacet.sol +++ b/contracts/nft/NFTFacet.sol @@ -5,7 +5,6 @@ pragma solidity ^0.8.0; import { TellerNFT } from "../nft/TellerNFT.sol"; import { RolesMods } from "../contexts2/access-control/roles/RolesMods.sol"; import { ADMIN, AUTHORIZED } from "../shared/roles.sol"; -import "../nft/TellerNFTDictionary.sol"; // Libraries import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol"; @@ -57,18 +56,4 @@ contract NFTFacet is RolesMods { // Give the caller authorization to protocol RolesLib.grantRole(AUTHORIZED, msg.sender); } - - /** - * @notice Sets the NFTDictionary address used to get information about an NFT and its tier. - * @param dictAddress Dictionary address to use. - * - * Requirements: - * - Sender must have `ADMIN` role - */ - function setNFTDictionary(address dictAddress) - external - authorized(ADMIN, msg.sender) - { - NFTLib.s().nftDictionary = TellerNFTDictionary(dictAddress); - } } diff --git a/contracts/nft/TellerNFTDictionary.sol b/contracts/nft/TellerNFTDictionary.sol index 422e7ae49..f7517942a 100644 --- a/contracts/nft/TellerNFTDictionary.sol +++ b/contracts/nft/TellerNFTDictionary.sol @@ -197,21 +197,23 @@ contract TellerNFTDictionary is IStakeableNFT, AccessControlUpgradeable { uint256 offset = ((31 - (tokenId % 32)) * 8); - uint256 updateMaskShifted = - 0x00000000000000000000000000000000000000000000000000000000000000FF << - offset; + + uint256 updateMaskShifted + = 0x00000000000000000000000000000000000000000000000000000000000000FF << + offset; uint256 updateMaskShiftedNegated = ~updateMaskShifted; - uint256 tokenTierShifted = - ((0x0000000000000000000000000000000000000000000000000000000000000000 | - tokenTier) << offset); - uint256 existingRegisterClearedWithMask = - existingRegister & updateMaskShiftedNegated; + uint256 tokenTierShifted + = ((0x0000000000000000000000000000000000000000000000000000000000000000 | + tokenTier) << offset); + + uint256 existingRegisterClearedWithMask = existingRegister & + updateMaskShiftedNegated; - uint256 updatedRegister = - existingRegisterClearedWithMask | tokenTierShifted; + uint256 updatedRegister = existingRegisterClearedWithMask | + tokenTierShifted; _tokenTierMappingCompressed[mappingIndex] = updatedRegister; diff --git a/contracts/nft/distributor/entry/claim.sol b/contracts/nft/distributor/entry/claim.sol index 594caaf47..3870554a5 100644 --- a/contracts/nft/distributor/entry/claim.sol +++ b/contracts/nft/distributor/entry/claim.sol @@ -39,19 +39,21 @@ contract ent_claim_NFTDistributor_v1 is // Mark it claimed and send the token. _setClaimed(requests[i].merkleIndex, requests[i].nodeIndex); - uint256 tierIndex = - distributorStore().merkleRoots[requests[i].merkleIndex] - .tierIndex; + uint256 tierIndex = distributorStore() + .merkleRoots[requests[i].merkleIndex] + .tierIndex; for (uint256 j; j < requests[i].amount; j++) { distributorStore().nft.mint(tierIndex, account); } //Find the newly minted tokens and add to memory - uint256[] memory postOwnedTokens = - distributorStore().nft.getOwnedTokens(account); + uint256[] memory postOwnedTokens = distributorStore() + .nft + .getOwnedTokens(account); - uint256[] memory newlyMintedTokenIds = - new uint256[](requests[i].amount); + uint256[] memory newlyMintedTokenIds = new uint256[]( + requests[i].amount + ); uint256 offset = postOwnedTokens.length - requests[i].amount; diff --git a/contracts/nft/distributor/external/distributor.sol b/contracts/nft/distributor/external/distributor.sol index a5b4d9196..1c5a2c3f9 100644 --- a/contracts/nft/distributor/external/distributor.sol +++ b/contracts/nft/distributor/external/distributor.sol @@ -8,7 +8,7 @@ import "../internal/distributor.sol"; contract ext_distributor_NFT_v1 is sto_NFTDistributor, int_distributor_NFT_v1 { /** * @notice It gets the TellerNFT diamond instance used to mint. - * @return nft_ return the NFT instance + * @return nft_ returns the NFT instance */ function nft() external view returns (ITellerNFT nft_) { nft_ = distributorStore().nft; diff --git a/contracts/nft/distributor/internal/distributor.sol b/contracts/nft/distributor/internal/distributor.sol index 924142c83..d3fa3156a 100644 --- a/contracts/nft/distributor/internal/distributor.sol +++ b/contracts/nft/distributor/internal/distributor.sol @@ -37,8 +37,9 @@ contract int_distributor_NFT_v1 is sto_NFTDistributor { { uint256 claimedWordIndex = nodeIndex / 256; uint256 claimedBitIndex = nodeIndex % 256; - uint256 claimedWord = - distributorStore().claimedBitMap[merkleIndex][claimedWordIndex]; + uint256 claimedWord = distributorStore().claimedBitMap[merkleIndex][ + claimedWordIndex + ]; uint256 mask = (1 << claimedBitIndex); return claimedWord & mask == mask; } diff --git a/contracts/price-aggregator/IsaLPPricer.sol b/contracts/price-aggregator/IsaLPPricer.sol new file mode 100644 index 000000000..8b52b7674 --- /dev/null +++ b/contracts/price-aggregator/IsaLPPricer.sol @@ -0,0 +1,39 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +interface IsaLPPricer { + /** + * @notice It returns the exchange rate of the single asset liquidity provider token. + * @param saLPToken address of the single asset liquidity provider token. + * @return Exchange rate for 1 saLP token in the underlying asset. + */ + function getRateFor(address saLPToken) external view returns (uint256); + + /** + * @notice It calculates the value of the protocol token amount into the underlying asset. + * @param saLPToken address of the single asset liquidity provider token + * @param amount Amount of the token to convert into the underlying asset. + * @return Value of the saLP token in the underlying asset. + */ + function getValueOf(address saLPToken, uint256 amount) + external + view + returns (uint256); + + /** + * @notice It calculates the balance of the underlying asset for {account}. + * @param saLPToken Address of the single asset liquidity provider token. + * @param account Address of the account to get the balance of. + * @return Balance of the underlying asset. + */ + function getBalanceOfUnderlying(address saLPToken, address account) + external + returns (uint256); + + /** + * @notice Gets the underlying asset address for the {saLPToken}. + * @param saLPToken address of the single asset liquidity provider token. + * @return Address of the underlying asset. + */ + function getUnderlying(address saLPToken) external view returns (address); +} diff --git a/contracts/price-aggregator/PriceAggFacet.sol b/contracts/price-aggregator/PriceAggFacet.sol index 9d8705834..4b6c4493c 100644 --- a/contracts/price-aggregator/PriceAggFacet.sol +++ b/contracts/price-aggregator/PriceAggFacet.sol @@ -1,229 +1,21 @@ // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; -// Libraries -import { SafeCast } from "@openzeppelin/contracts/utils/math/SafeCast.sol"; -import { ChainlinkLib } from "./chainlink/ChainlinkLib.sol"; -import { CompoundLib } from "../shared/libraries/CompoundLib.sol"; - -// Interfaces -import { - AggregatorV2V3Interface -} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol"; -import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol"; +// Contacts +import { RolesMods } from "../contexts2/access-control/roles/RolesMods.sol"; +import { ADMIN } from "../shared/roles.sol"; +import { PriceAggregator } from "./PriceAggregator.sol"; // Storage import { AppStorageLib } from "../storage/app.sol"; -contract PriceAggFacet { - uint256 internal constant TEN = 10; - - /** - * @notice It returns the price of the token pair as given from the Chainlink Aggregator. - * @dev It tries to use ETH as a pass through asset if the direct pair is not supported. - * @param src Source token address. - * @param dst Destination token address. - * @return int256 The latest answer as given from Chainlink. - */ - function getPriceFor(address src, address dst) +contract PriceAggFacet is RolesMods { + function setPriceAggregator(address priceAggAddress) external - view - returns (int256) - { - return _priceFor(src, dst); - } - - /** - * @notice It calculates the value of a token amount into another. - * @param src Source token address. - * @param dst Destination token address. - * @param srcAmount Amount of the source token to convert into the destination token. - * @return uint256 Value of the source token amount in destination tokens. - */ - function getValueFor( - address src, - address dst, - uint256 srcAmount - ) external view returns (uint256) { - return _valueFor(src, srcAmount, uint256(_priceFor(src, dst))); - } - - function _valueFor( - address src, - uint256 amount, - uint256 exchangeRate - ) internal view returns (uint256) { - return (amount * exchangeRate) / _oneToken(src); - } - - /** - * @notice it returns 10^{numberOfDecimals} for a token - * @param token the address to calculate the decimals for - * @return 10^number of decimals used to calculate the price and value of different token pairs - */ - function _oneToken(address token) internal view returns (uint256) { - return TEN**_decimalsFor(token); - } - - /** - * @notice It gets the number of decimals for a given token. - * @param addr Token address to get decimals for. - * @return uint8 Number of decimals the given token. - */ - function _decimalsFor(address addr) internal view returns (uint8) { - return ERC20(addr).decimals(); - } - - /** - * @notice it tries to calculate a price from Compound and Chainlink. - * @dev if no price is found on compound, then calculate it on chainlink - * @param src the token address to calculate the price for in dst - * @param dst the token address to retrieve the price of src - * @return price_ the price of src in dst - */ - function _priceFor(address src, address dst) - private - view - returns (int256 price_) - { - // If no Compound route, try Chainlink directly. - price_ = int256(_compoundPriceFor(src, dst)); - if (price_ == 0) { - price_ = _chainlinkPriceFor(src, dst); - if (price_ == 0) { - revert("Teller: cannot calc price"); - } - } - } - - /** - * @notice Tries to get a price from {src} to {dst} by checking if either tokens are from Compound. - * @param src the address of the src token - * @param dst the address of the dst token - * @return the price of the src token in dst token - - */ - function _compoundPriceFor(address src, address dst) - private - view - returns (uint256) - { - (bool isSrcCompound, address srcUnderlying) = _isCToken(src); - if (isSrcCompound) { - uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src)); - if (srcUnderlying == dst) { - return cRate; - } else { - return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate); - } - } else { - (bool isDstCompound, address dstUnderlying) = _isCToken(dst); - if (isDstCompound) { - uint256 cRate = - CompoundLib.valueOfUnderlying(dst, _oneToken(src)); - if (dstUnderlying == src) { - return cRate; - } else { - return - _calcPriceFromCompoundRate(src, dstUnderlying, cRate); - } - } - } - - return 0; - } - - /** - * @notice Tries to get a price from {src} to {dst} and then converts using a rate from Compound. - * @param src the source token to calculate price for with chainlink - * @param dst the destination token to calculate price for with chainlink - * @param cRate the compound rate to multiply with the price of the dst token - * @return the price of src in dst after scaling the difference in decimal values - */ - function _calcPriceFromCompoundRate( - address src, - address dst, - uint256 cRate - ) private view returns (uint256) { - uint256 rate = uint256(_chainlinkPriceFor(src, dst)); - uint256 value = (cRate * _oneToken(dst)) / rate; - return _scale(value, _decimalsFor(src), _decimalsFor(dst)); - } - - /** - * @notice Scales the {value} by the difference in decimal values. - * @param value the the value of the src in dst - * @param srcDecimals src token decimals - * @param dstDecimals dst token decimals - * @return the price of src in dst after scaling the difference in decimal values - */ - function _scale( - uint256 value, - uint256 srcDecimals, - uint256 dstDecimals - ) internal pure returns (uint256) { - if (dstDecimals > srcDecimals) { - return value * (TEN**(dstDecimals - srcDecimals)); - } else { - return value / (TEN**(srcDecimals - dstDecimals)); - } - } - - /** - * @notice it tries to calculate the price of {src} in {dst} - * @param src address of source token - * @param dst address of destination token - * @return the price of src token in dst - */ - function _chainlinkPriceFor(address src, address dst) - private - view - returns (int256) - { - (address agg, bool foundAgg, bool inverse) = - ChainlinkLib.aggregatorFor(src, dst); - if (foundAgg) { - uint256 price = - SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer()); - uint8 resDecimals = AggregatorV2V3Interface(agg).decimals(); - if (inverse) { - price = (TEN**(resDecimals + resDecimals)) / price; - } - return - SafeCast.toInt256( - (_scale(price, resDecimals, _decimalsFor(dst))) - ); - } else { - address WETH = AppStorageLib.store().assetAddresses["WETH"]; - if (dst != WETH) { - int256 price1 = _priceFor(src, WETH); - if (price1 > 0) { - int256 price2 = _priceFor(dst, WETH); - if (price2 > 0) { - uint256 dstFactor = TEN**_decimalsFor(dst); - return (price1 * int256(dstFactor)) / price2; - } - } - } - } - - return 0; - } - - /** - * @notice it checks if a token is a cToken. If it is, then get the underlying address - * @param token address of the token - * @return isCToken boolean whether it's a cToken - * @return underlying the address of the cToken - */ - function _isCToken(address token) - private - view - returns (bool isCToken, address underlying) + authorized(ADMIN, msg.sender) { - isCToken = CompoundLib.isCompoundToken(token); - if (isCToken) { - underlying = CompoundLib.getUnderlying(token); - } + AppStorageLib.store().priceAggregator = PriceAggregator( + priceAggAddress + ); } } diff --git a/contracts/price-aggregator/PriceAggLib.sol b/contracts/price-aggregator/PriceAggLib.sol deleted file mode 100644 index e253311c4..000000000 --- a/contracts/price-aggregator/PriceAggLib.sol +++ /dev/null @@ -1,42 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity ^0.8.0; - -import { PriceAggFacet } from "./PriceAggFacet.sol"; - -// Storage -import { AppStorageLib } from "../storage/app.sol"; - -/** - * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor} - */ -library PriceAggLib { - /** - * @notice It calculates the value of one token amount into another - * @param src the source token - * @param dst the destination token - * @param srcAmount the amount of source token - * @return value_ the returned value of src in dst - */ - function valueFor( - address src, - address dst, - uint256 srcAmount - ) internal view returns (uint256 value_) { - value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount); - } - - /** - * @notice It returns the price of the token pair as given from Compound. - * @dev if no compound price is calculated, then it checks Chainlink price Aggregator - * @param src the address of the source token - * @param dst the address of the desitnation token - * @return price_ gets the price of src in dst - */ - function priceFor(address src, address dst) - internal - view - returns (int256 price_) - { - price_ = PriceAggFacet(address(this)).getPriceFor(src, dst); - } -} diff --git a/contracts/price-aggregator/PriceAggregator.sol b/contracts/price-aggregator/PriceAggregator.sol new file mode 100644 index 000000000..b848309ff --- /dev/null +++ b/contracts/price-aggregator/PriceAggregator.sol @@ -0,0 +1,265 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +// Contracts +import { ChainlinkPricer } from "./pricers/ChainlinkPricer.sol"; + +// Interfaces +import { IsaLPPricer } from "./IsaLPPricer.sol"; +import { + AggregatorV2V3Interface +} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol"; +import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol"; + +contract PriceAggregator { + uint256 internal constant TEN = 10; + address public immutable wETH; + + mapping(address => IsaLPPricer) public saLPPricer; + ChainlinkPricer public chainlinkPricer; + + constructor(address wETHAddress, address chainlinkPricerAddress) { + wETH = wETHAddress; + chainlinkPricer = ChainlinkPricer(chainlinkPricerAddress); + } + + function setAssetPricers(address pricer, address[] calldata assets) + external + { + for (uint256 i; i < assets.length; i++) { + setAssetPricer(assets[i], pricer); + } + } + + function setAssetPricer(address asset, address pricer) public { + saLPPricer[asset] = IsaLPPricer(pricer); + } + + /** + * @notice It returns the price of the token pair as given from the Chainlink Aggregator. + * @dev It tries to use ETH as a pass through asset if the direct pair is not supported. + * @param src Source token address. + * @param dst Destination token address. + * @return uint256 The latest answer as given from Chainlink. + */ + function getPriceFor(address src, address dst) + external + view + returns (uint256) + { + return _priceFor(src, dst); + } + + /** + * @notice It calculates the value of a token amount into another. + * @param src Source token address. + * @param dst Destination token address. + * @param srcAmount Amount of the source token to convert into the destination token. + * @return uint256 Value of the source token amount in destination tokens. + */ + function getValueFor( + address src, + address dst, + uint256 srcAmount + ) external view returns (uint256) { + return _valueFor(src, srcAmount, uint256(_priceFor(src, dst))); + } + + /** + * @notice It calculates the value of the {src} token balance in {dst} token for the {account}. + * @param account Address of the account to get the balance value of. + * @param src Source token address. + * @param dst Destination token address. + * @return Value of the {src} token balance denoted in {dst} tokens. + */ + function getBalanceOfFor( + address account, + address src, + address dst + ) external returns (uint256) { + IsaLPPricer srcPricer = saLPPricer[src]; + IsaLPPricer dstPricer = saLPPricer[dst]; + + uint256 srcBalance; + if (address(srcPricer) == address(0)) { + srcBalance = ERC20(src).balanceOf(account); + } else { + srcBalance = srcPricer.getBalanceOfUnderlying(src, account); + src = srcPricer.getUnderlying(src); + } + + return _valueFor(src, srcBalance, uint256(_priceFor(src, dst))); + } + + /** + * @notice It calculates the value of a token amount into another. + * @param src Source token address. + * @param amount Amount of the source token to convert into the destination token. + * @param exchangeRate The calculated exchange rate between the tokens. + * @return uint256 Value of the source token amount given an exchange rate peg. + */ + function _valueFor( + address src, + uint256 amount, + uint256 exchangeRate + ) internal view returns (uint256) { + return (amount * exchangeRate) / _oneToken(src); + } + + /** + * @notice it returns 10^{numberOfDecimals} for a token + * @param token the address to calculate the decimals for + * @return 10^number of decimals used to calculate the price and value of different token pairs + */ + function _oneToken(address token) internal view returns (uint256) { + return TEN**_decimalsFor(token); + } + + /** + * @notice It gets the number of decimals for a given token. + * @param addr Token address to get decimals for. + * @return uint8 Number of decimals the given token. + */ + function _decimalsFor(address addr) internal view returns (uint8) { + return ERC20(addr).decimals(); + } + + /** + * @notice it tries to calculate a price from Compound and Chainlink. + * @dev if no price is found on compound, then calculate it on chainlink + * @param src the token address to calculate the price for in dst + * @param dst the token address to retrieve the price of src + * @return price_ the price of src in dst + */ + function _priceFor(address src, address dst) + private + view + returns (uint256 price_) + { + IsaLPPricer srcPricer = saLPPricer[src]; + IsaLPPricer dstPricer = saLPPricer[dst]; + + // ETH / ASSET + if (src == wETH && address(dstPricer) == address(0)) { + // Get destination asset Chainlink price in ETH + uint256 dstEthPrice = chainlinkPricer.getEthPrice(dst); + // Since the source asset is ETH and the price is in ETH, we need the inverse + return _scale(_inverseRate(dstEthPrice, 18), 18, _decimalsFor(dst)); + } + + // ASSET / ETH + if (dst == wETH && address(srcPricer) == address(0)) { + // Get source asset Chainlink price in ETH + uint256 srcEthPrice = chainlinkPricer.getEthPrice(src); + return srcEthPrice; + } + + // ASSET / ASSET + if ( + address(srcPricer) == address(0) && address(dstPricer) == address(0) + ) { + // Get source asset Chainlink price in ETH + uint256 srcEthPrice = chainlinkPricer.getEthPrice(src); + // Get destination asset Chainlink price in ETH + uint256 dstEthPrice = chainlinkPricer.getEthPrice(dst); + // Merge the 2 rates + return _mergeRates(srcEthPrice, dstEthPrice, dst); + } + + // saLP / ASSET + if ( + address(srcPricer) != address(0) && address(dstPricer) == address(0) + ) { + // Get the underlying source asset + address srcUnderlying = srcPricer.getUnderlying(src); + // Get source asset exchange rate for the underlying asset + uint256 srcExchangeRate = srcPricer.getRateFor(src); + if (srcUnderlying == dst) { + return srcExchangeRate; + } else { + return + _mergeRates( + srcExchangeRate, + _priceFor(dst, srcUnderlying), + dst + ); + } + } + + // Get the underlying destination asset + address dstUnderlying = dstPricer.getUnderlying(dst); + + // ASSET / saLP + if ( + address(srcPricer) == address(0) && address(dstPricer) != address(0) + ) { + // Get destination asset exchange rate for the underlying asset + uint256 dstExchangeRate = dstPricer.getRateFor(dst); + // If the source asset and underlying destination asset are the same, inverse the saLP asset rate + if (src == dstUnderlying) { + return + _inverseRate( + _scale( + dstExchangeRate, + _decimalsFor(dst), + _decimalsFor(src) + ), + _decimalsFor(src) + ); + } else { + return + _mergeRates( + _priceFor(src, dstUnderlying), + dstExchangeRate, + dst + ); + } + } + + // saLP / saLP + + // Get the underlying destination asset + return + _valueFor( + dstUnderlying, + _priceFor(src, dstUnderlying), + _priceFor(dstUnderlying, dst) + ); + } + + /** + * @notice Scales the {value} by the difference in decimal values. + * @param value the the value of the src in dst + * @param srcDecimals src token decimals + * @param dstDecimals dst token decimals + * @return the price of src in dst after scaling the difference in decimal values + */ + function _scale( + uint256 value, + uint256 srcDecimals, + uint256 dstDecimals + ) internal pure returns (uint256) { + if (dstDecimals > srcDecimals) { + return value * (TEN**(dstDecimals - srcDecimals)); + } else { + return value / (TEN**(srcDecimals - dstDecimals)); + } + } + + function _inverseRate(uint256 rate, uint8 dstDecimals) + internal + pure + returns (uint256) + { + return (TEN**(dstDecimals + dstDecimals)) / rate; + } + + function _mergeRates( + uint256 rate1, + uint256 rate2, + address dst + ) internal view returns (uint256) { + return + rate1 == 0 ? rate2 : ((rate1 * (TEN**_decimalsFor(dst))) / rate2); + } +} diff --git a/contracts/price-aggregator/chainlink/ChainlinkAggFacet.sol b/contracts/price-aggregator/chainlink/ChainlinkAggFacet.sol deleted file mode 100644 index 41b3a0e84..000000000 --- a/contracts/price-aggregator/chainlink/ChainlinkAggFacet.sol +++ /dev/null @@ -1,115 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity ^0.8.0; - -// Contracts -import { RolesMods } from "../../contexts2/access-control/roles/RolesMods.sol"; -import { ADMIN } from "../../shared/roles.sol"; - -// Libraries -import { Address } from "@openzeppelin/contracts/utils/Address.sol"; -import { - EnumerableSet -} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol"; -import { ChainlinkLib } from "./ChainlinkLib.sol"; - -// Storage -import { - PriceAggStorageLib, - PriceAggStorage -} from "../../storage/price-aggregator.sol"; - -contract ChainlinkAggFacet is RolesMods { - /** - * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported. - * @param src Source token address. - * @param dst Destination token address. - * @return agg The Chainlink Aggregator address. - * @return found whether or not the ChainlinkAggregator exists. - * @return inverse whether or not the values from the Aggregator should be considered inverted. - */ - function getChainlinkAggregatorFor(address src, address dst) - external - view - returns ( - address agg, - bool found, - bool inverse - ) - { - (agg, found, inverse) = ChainlinkLib.aggregatorFor(src, dst); - } - - /** - * @dev Checks if a token address is supported by Chainlink (has a pair aggregator). - * @param token Token address to check if is supported. - * @return isSupported_ true if there is at least 1 pair aggregator for {token} - */ - function isChainlinkTokenSupported(address token) - external - view - returns (bool) - { - return ChainlinkLib.isTokenSupported(token); - } - - /** - * @notice It allows for additional Chainlink Aggregators to be supported. - * @param src Source token address. - * @param dst Destination token address. - * @param aggregator Price aggregator address. - */ - function addChainlinkAggregator( - address src, - address dst, - address aggregator - ) external authorized(ADMIN, msg.sender) { - (, bool found, ) = ChainlinkLib.aggregatorFor(src, dst); - require(!found, "Teller: chainlink aggregator already exists"); - require(Address.isContract(src), "Teller: source token not contract"); - require( - Address.isContract(dst), - "Teller: destination token not contract" - ); - require( - Address.isContract(aggregator), - "Teller: chainlink aggregator not contract" - ); - - // Store now aggregator - ChainlinkLib.s().aggregators[src][dst] = aggregator; - // Make sure token addresses are known to be supported - EnumerableSet.add(ChainlinkLib.s().supportedTokens, src); - EnumerableSet.add(ChainlinkLib.s().supportedTokens, dst); - // Increment token pair counts - ChainlinkLib.s().pairCount[src]++; - ChainlinkLib.s().pairCount[dst]++; - } - - /** - * @notice It removes support for a Chainlink Aggregator pair. - * @param src Source token address. - * @param dst Destination token address. - */ - function removeChainlinkAggregator(address src, address dst) - external - authorized(ADMIN, msg.sender) - { - (, bool found, ) = ChainlinkLib.aggregatorFor(src, dst); - if (!found) { - return; - } - - // Delete aggregator storage - delete ChainlinkLib.s().aggregators[src][dst]; - // Decrement token pair counts - ChainlinkLib.s().pairCount[src]--; - ChainlinkLib.s().pairCount[dst]--; - // Remove token support if token pair length is 0 - if (ChainlinkLib.s().pairCount[src] == 0) { - EnumerableSet.remove(ChainlinkLib.s().supportedTokens, src); - } - if (ChainlinkLib.s().pairCount[dst] == 0) { - EnumerableSet.remove(ChainlinkLib.s().supportedTokens, dst); - } - } -} diff --git a/contracts/price-aggregator/chainlink/ChainlinkLib.sol b/contracts/price-aggregator/chainlink/ChainlinkLib.sol deleted file mode 100644 index 929dbc0fa..000000000 --- a/contracts/price-aggregator/chainlink/ChainlinkLib.sol +++ /dev/null @@ -1,61 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity ^0.8.0; - -// Libraries -import { - EnumerableSet -} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol"; - -// Storage -import { - PriceAggStorageLib, - ChainlinkAggStorage -} from "../../storage/price-aggregator.sol"; - -library ChainlinkLib { - function s() internal view returns (ChainlinkAggStorage storage) { - return PriceAggStorageLib.store().chainlink; - } - - /** - * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported. - * @param src Source token address. - * @param dst Destination token address. - * @return aggregator The Chainlink Aggregator address. - * @return found whether or not the ChainlinkAggregator exists. - * @return inverse whether or not the values from the Aggregator should be considered inverted. - */ - function aggregatorFor(address src, address dst) - internal - view - returns ( - address aggregator, - bool found, - bool inverse - ) - { - aggregator = s().aggregators[src][dst]; - if (aggregator != address(0)) { - found = true; - } else { - aggregator = s().aggregators[dst][src]; - if (aggregator != address(0)) { - found = true; - inverse = true; - } - } - } - - /** - * @dev Checks if a token address is supported by Chainlink (has a pair aggregator). - * @param token Token address to check if is supported. - * @return isSupported_ true if there is at least 1 pair aggregator for {token} - */ - function isTokenSupported(address token) - internal - view - returns (bool isSupported_) - { - isSupported_ = EnumerableSet.contains(s().supportedTokens, token); - } -} diff --git a/contracts/price-aggregator/pricers/AavePricer.sol b/contracts/price-aggregator/pricers/AavePricer.sol new file mode 100644 index 000000000..78534dd06 --- /dev/null +++ b/contracts/price-aggregator/pricers/AavePricer.sol @@ -0,0 +1,70 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +// Interfaces +import { IsaLPPricer } from "../IsaLPPricer.sol"; +import { IAToken } from "../../shared/interfaces/IAToken.sol"; +import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol"; + +contract AavePricer is IsaLPPricer { + /** + * @notice It returns the exchange rate of the aToken to the underlying asset. + * @dev The exchange ratio for Aave tokens is always 1:1, however the token balance is compounded silently + * using an index at the time of their last deposit. See {AavePricer.getBalanceOfUnderlying} + * @param saLPToken address of the single asset liquidity provider token. + * @return Exchange rate for 1 saLP token in the underlying asset. + */ + function getRateFor(address saLPToken) + public + view + override + returns (uint256) + { + return 10**ERC20(saLPToken).decimals(); + } + + /** + * @notice It calculates the value of the protocol token amount into the underlying asset. + * @dev The value of an Aave token is always the same as the underlying asset amount. See {AavePricer.getRateFor} + * @param saLPToken address of the single asset liquidity provider token + * @param amount Amount of the token to convert into the underlying asset. + * @return Value of the saLP token in the underlying asset. + */ + function getValueOf(address saLPToken, uint256 amount) + external + view + override + returns (uint256) + { + return amount; + } + + /** + * @notice It calculates the balance of the underlying asset for {account}. + * @param saLPToken Address of the single asset liquidity provider token. + * @param account Address of the account to get the balance of. + * @return Balance of the underlying asset. + */ + function getBalanceOfUnderlying(address saLPToken, address account) + external + override + returns (uint256) + { + return IAToken(saLPToken).balanceOf(account); + } + + /** + * @notice Gets the underlying asset address for the Compound token. + * @dev cETH is the only Compound token that does not support the {underlying} function. + * @param saLPToken address of the Compound token. + * @return address of the underlying saLPToken asset. + */ + function getUnderlying(address saLPToken) + public + view + override + returns (address) + { + return IAToken(saLPToken).UNDERLYING_ASSET_ADDRESS(); + } +} diff --git a/contracts/price-aggregator/pricers/ChainlinkPricer.sol b/contracts/price-aggregator/pricers/ChainlinkPricer.sol new file mode 100644 index 000000000..21f6a9c44 --- /dev/null +++ b/contracts/price-aggregator/pricers/ChainlinkPricer.sol @@ -0,0 +1,53 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +// Interfaces +import { + AggregatorV2V3Interface as ChainlinkAgg +} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol"; +import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol"; + +// Libraries +import { ENS } from "../../shared/libraries/ENSLib.sol"; +import { StringsLib } from "../../shared/libraries/StringsLib.sol"; +import { SafeCast } from "@openzeppelin/contracts/utils/math/SafeCast.sol"; + +contract ChainlinkPricer { + using StringsLib for string; + + // Chainlink ENS resolver + address public immutable ENS_RESOLVER; + // namehash of `data.eth` domain + bytes32 public constant ENS_DOMAIN = + 0x4a9dd6923a809a49d009b308182940df46ac3a45ee16c1133f90db66596dae1f; + + constructor(address ensResolver) { + ENS_RESOLVER = ensResolver; + } + + function getEthPrice(address token) external view returns (uint256 price_) { + price_ = SafeCast.toUint256( + ChainlinkAgg(getEthAggregator(token)).latestAnswer() + ); + } + + function getEthAggregator(address token) public view returns (address) { + string memory name = _getTokenSymbol(token).concat("-eth"); + return ENS.resolve(ENS_RESOLVER, ENS.subnode(name, ENS_DOMAIN)); + } + + function _getTokenSymbol(address token) + internal + view + returns (string memory) + { + string memory symbol_ = ERC20(token).symbol(); + if (symbol_.compareTo("WBTC")) { + return "btc"; + } + if (symbol_.compareTo("WMATIC")) { + return "matic"; + } + return symbol_.lower(); + } +} diff --git a/contracts/price-aggregator/pricers/CompoundPricer.sol b/contracts/price-aggregator/pricers/CompoundPricer.sol new file mode 100644 index 000000000..20578dd24 --- /dev/null +++ b/contracts/price-aggregator/pricers/CompoundPricer.sol @@ -0,0 +1,88 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +// Interfaces +import { IsaLPPricer } from "../IsaLPPricer.sol"; +import { ICErc20 } from "../../shared/interfaces/ICErc20.sol"; +import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol"; + +contract CompoundPricer is IsaLPPricer { + // Compounds exchange rate is scaled by 18 decimals (10^18) + uint256 internal constant EXCHANGE_RATE_SCALE = 1e18; + uint256 internal constant CTOKEN_DECIMALS = 1e8; + address public immutable wETH; + address public immutable cETH; + + constructor(address wETHAddress, address cETHAddress) { + wETH = wETHAddress; + cETH = cETHAddress; + } + + /** + * @notice It returns the exchange rate of the single asset liquidity provider token. + * @param saLPToken address of the single asset liquidity provider token. + * @return Exchange rate for 1 saLP token in the underlying asset. + */ + function getRateFor(address saLPToken) + public + view + override + returns (uint256) + { + return + (ICErc20(saLPToken).exchangeRateStored() * CTOKEN_DECIMALS) / + EXCHANGE_RATE_SCALE; + } + + /** + * @notice It calculates the value of the protocol token amount into the underlying asset. + * @param saLPToken address of the single asset liquidity provider token + * @param amount Amount of the token to convert into the underlying asset. + * @return Value of the saLP token in the underlying asset. + */ + function getValueOf(address saLPToken, uint256 amount) + external + view + override + returns (uint256) + { + return (amount * getRateFor(saLPToken)) / EXCHANGE_RATE_SCALE; + } + + /** + * @notice It calculates the balance of the underlying asset for {account}. + * @param saLPToken Address of the single asset liquidity provider token. + * @param account Address of the account to get the balance of. + * @return Balance of the underlying asset. + */ + function getBalanceOfUnderlying(address saLPToken, address account) + external + override + returns (uint256) + { + return ICErc20(saLPToken).balanceOfUnderlying(account); + } + + /** + * @notice Gets the underlying asset address for the Compound token. + * @dev cETH is the only Compound token that does not support the {underlying} function. + * @param saLPToken Address of the Compound token. + * @return Address of the underlying saLPToken asset. Null address if token not supported. + */ + function getUnderlying(address saLPToken) + public + view + override + returns (address) + { + if (saLPToken == cETH) { + return wETH; + } + + (bool success, bytes memory data) = saLPToken.staticcall( + abi.encodeWithSelector(ICErc20.underlying.selector) + ); + require(success, "Teller: unsupported cToken"); + return abi.decode(data, (address)); + } +} diff --git a/contracts/price-aggregator/pricers/PoolTogetherPricer.sol b/contracts/price-aggregator/pricers/PoolTogetherPricer.sol new file mode 100644 index 000000000..65f0c66c5 --- /dev/null +++ b/contracts/price-aggregator/pricers/PoolTogetherPricer.sol @@ -0,0 +1,85 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +// Interfaces +import { IsaLPPricer } from "../IsaLPPricer.sol"; +import { + PrizePoolInterface +} from "../../shared/interfaces/pooltogether/PrizePoolInterface.sol"; +import { + IControlledToken +} from "../../shared/interfaces/pooltogether/IControlledToken.sol"; +import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol"; + +contract PoolTogetherPricer is IsaLPPricer { + // TODO: not currently being used + /** + * @notice It returns the exchange rate of the aToken to the underlying asset. + * @dev The exchange ratio for Aave tokens is always 1:1, however the token balance is compounded silently + * using an index at the time of their last deposit. See {AavePricer.getBalanceOfUnderlying} + * @param saLPToken address of the single asset liquidity provider token. + * @return Exchange rate for 1 saLP token in the underlying asset. + */ + function getRateFor(address saLPToken) + public + view + override + returns (uint256) + { + return 0; + } + + // TODO: not currently being used + /** + * @notice It calculates the value of the protocol token amount into the underlying asset. + * @dev The value of an Aave token is always the same as the underlying asset amount. See {AavePricer.getRateFor} + * @param saLPToken address of the single asset liquidity provider token + * @param amount Amount of the token to convert into the underlying asset. + * @return Value of the saLP token in the underlying asset. + */ + function getValueOf(address saLPToken, uint256 amount) + external + view + override + returns (uint256) + { + return 0; + } + + /** + * @notice It calculates the balance of the underlying asset for {account}. + * @param saLPToken Address of the single asset liquidity provider token. + * @param account Address of the account to get the balance of. + * @return Balance of the underlying asset. + */ + function getBalanceOfUnderlying(address saLPToken, address account) + external + override + returns (uint256) + { + return _getPrizePool(saLPToken).balanceOfCredit(account, saLPToken); + } + + /** + * @notice Gets the underlying asset address for the Compound token. + * @dev cETH is the only Compound token that does not support the {underlying} function. + * @param saLPToken address of the Compound token. + * @return address of the underlying saLPToken asset. + */ + function getUnderlying(address saLPToken) + public + view + override + returns (address) + { + return _getPrizePool(saLPToken).token(); + } + + function _getPrizePool(address saLPToken) + private + view + returns (PrizePoolInterface) + { + return IControlledToken(saLPToken).controller(); + } +} diff --git a/contracts/price-aggregator/types.sol b/contracts/price-aggregator/types.sol new file mode 100644 index 000000000..478347e4f --- /dev/null +++ b/contracts/price-aggregator/types.sol @@ -0,0 +1,3 @@ +import "@ensdomains/ens-contracts/contracts/registry/ENS.sol"; +import "@ensdomains/ens-contracts/contracts/registry/ENSRegistry.sol"; +import "@ensdomains/ens-contracts/contracts/resolvers/PublicResolver.sol"; diff --git a/contracts/settings/SettingsFacet.sol b/contracts/settings/SettingsFacet.sol index 8644f52ca..60c951c16 100644 --- a/contracts/settings/SettingsFacet.sol +++ b/contracts/settings/SettingsFacet.sol @@ -8,30 +8,29 @@ import { UpgradeableBeaconFactory } from "../shared/proxy/beacon/UpgradeableBeaconFactory.sol"; import { TellerNFT } from "../nft/TellerNFT.sol"; +import { TellerNFTDictionary } from "../nft/TellerNFTDictionary.sol"; +import { PriceAggregator } from "../price-aggregator/PriceAggregator.sol"; // Interfaces import { IUniswapV2Router } from "../shared/interfaces/IUniswapV2Router.sol"; // Libraries import { RolesLib } from "../contexts2/access-control/roles/RolesLib.sol"; +import { NFTLib } from "../nft/libraries/NFTLib.sol"; // Storage import { AppStorageLib, AppStorage } from "../storage/app.sol"; -struct InitAssets { - string sym; - address addr; -} - struct InitArgs { address admin; - InitAssets[] assets; - address[] cTokens; address tellerNFT; address loansEscrowBeacon; address collateralEscrowBeacon; address tTokenBeacon; address nftLiquidationController; + address wrappedNativeToken; + address nftDictionary; + address priceAggregator; } contract SettingsFacet is RolesMods { @@ -115,6 +114,7 @@ contract SettingsFacet is RolesMods { */ function getNFTLiquidationController() external + view returns (address controller_) { controller_ = AppStorageLib.store().nftLiquidationController; @@ -133,13 +133,6 @@ contract SettingsFacet is RolesMods { RolesLib.grantRole(ADMIN, _args.admin); RolesLib.grantRole(PAUSER, _args.admin); - for (uint256 i; i < _args.assets.length; i++) { - s.assetAddresses[_args.assets[i].sym] = _args.assets[i].addr; - } - for (uint256 i; i < _args.cTokens.length; i++) { - s.cTokenRegistry[_args.cTokens[i]] = true; - } - s.nft = TellerNFT(_args.tellerNFT); s.loansEscrowBeacon = UpgradeableBeaconFactory(_args.loansEscrowBeacon); s.collateralEscrowBeacon = UpgradeableBeaconFactory( @@ -147,5 +140,9 @@ contract SettingsFacet is RolesMods { ); s.tTokenBeacon = UpgradeableBeaconFactory(_args.tTokenBeacon); s.nftLiquidationController = _args.nftLiquidationController; + s.wrappedNativeToken = _args.wrappedNativeToken; + s.priceAggregator = PriceAggregator(_args.priceAggregator); + + NFTLib.s().nftDictionary = TellerNFTDictionary(_args.nftDictionary); } } diff --git a/contracts/settings/asset/AssetSettingsDataFacet.sol b/contracts/settings/asset/AssetSettingsDataFacet.sol index 070051ddf..6da6ae0be 100644 --- a/contracts/settings/asset/AssetSettingsDataFacet.sol +++ b/contracts/settings/asset/AssetSettingsDataFacet.sol @@ -7,6 +7,8 @@ import { ADMIN, AUTHORIZED } from "../../shared/roles.sol"; // Interfaces import { ICErc20 } from "../../shared/interfaces/ICErc20.sol"; +import { IAToken } from "../../shared/interfaces/IAToken.sol"; +import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; // Libraries import { @@ -15,11 +17,19 @@ import { CacheType } from "../../shared/libraries/CacheLib.sol"; import { AssetCTokenLib } from "./libraries/AssetCTokenLib.sol"; +import { AssetATokenLib } from "./libraries/AssetATokenLib.sol"; +import { AssetPPoolLib } from "./libraries/AssetPPoolLib.sol"; +import { + PoolTogetherLib +} from "../../escrow/dapps/libraries/PoolTogetherLib.sol"; import { MaxLoanAmountLib } from "./libraries/MaxLoanAmountLib.sol"; import { MaxTVLLib } from "./libraries/MaxTVLLib.sol"; // Storage import { AppStorageLib, AppStorage } from "../../storage/app.sol"; +import { + PrizePoolInterface +} from "../../shared/interfaces/pooltogether/PrizePoolInterface.sol"; /** * @notice View function to get asset setting values. @@ -57,4 +67,20 @@ contract AssetSettingsDataFacet { function getAssetCToken(address asset) external view returns (ICErc20) { return AssetCTokenLib.get(asset); } + + function getAssetAToken(address asset) external view returns (IAToken) { + return AssetATokenLib.get(asset); + } + + function getAssetPPool(address asset) + external + view + returns (PrizePoolInterface) + { + return AssetPPoolLib.get(asset); + } + + function getAssetPPoolTicket(address asset) external view returns (IERC20) { + return IERC20(PoolTogetherLib.getTicketAddress(asset)); + } } diff --git a/contracts/settings/asset/libraries/AssetATokenLib.sol b/contracts/settings/asset/libraries/AssetATokenLib.sol index 70c9b9260..d845542b1 100644 --- a/contracts/settings/asset/libraries/AssetATokenLib.sol +++ b/contracts/settings/asset/libraries/AssetATokenLib.sol @@ -7,7 +7,7 @@ import { Cache, CacheType } from "../../../shared/libraries/CacheLib.sol"; -import { IAToken } from "../../../escrow/dapps/interfaces/IAToken.sol"; +import { IAToken } from "../../../shared/interfaces/IAToken.sol"; // Storage import { AppStorageLib } from "../../../storage/app.sol"; diff --git a/contracts/settings/asset/libraries/AssetPPoolLib.sol b/contracts/settings/asset/libraries/AssetPPoolLib.sol index 05096e023..c2424ca4e 100644 --- a/contracts/settings/asset/libraries/AssetPPoolLib.sol +++ b/contracts/settings/asset/libraries/AssetPPoolLib.sol @@ -9,7 +9,7 @@ import { } from "../../../shared/libraries/CacheLib.sol"; import { PrizePoolInterface -} from "../../../escrow/dapps/interfaces/PrizePoolInterface.sol"; +} from "../../../shared/interfaces/pooltogether/PrizePoolInterface.sol"; // Storage import { AppStorageLib } from "../../../storage/app.sol"; @@ -20,7 +20,7 @@ import { AppStorageLib } from "../../../storage/app.sol"; * @author develop@teller.finance */ library AssetPPoolLib { - bytes32 private constant NAME = keccak256("pPoolAddress"); + bytes32 private constant NAME = keccak256("pPool"); function s(address asset) private view returns (Cache storage) { return AppStorageLib.store().assetSettings[asset]; diff --git a/contracts/shared/facets/DiamondLoupeFacet.sol b/contracts/shared/facets/DiamondLoupeFacet.sol index 248e9959a..36a5ce285 100644 --- a/contracts/shared/facets/DiamondLoupeFacet.sol +++ b/contracts/shared/facets/DiamondLoupeFacet.sol @@ -31,9 +31,8 @@ contract DiamondLoupeFacet is IDiamondLoupe, IERC165 { for (uint256 i; i < numFacets; i++) { address facetAddress_ = ds.facetAddresses[i]; facets_[i].facetAddress = facetAddress_; - facets_[i].functionSelectors = ds.facetFunctionSelectors[ - facetAddress_ - ] + facets_[i].functionSelectors = ds + .facetFunctionSelectors[facetAddress_] .functionSelectors; } } @@ -48,7 +47,8 @@ contract DiamondLoupeFacet is IDiamondLoupe, IERC165 { returns (bytes4[] memory facetFunctionSelectors_) { LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage(); - facetFunctionSelectors_ = ds.facetFunctionSelectors[_facet] + facetFunctionSelectors_ = ds + .facetFunctionSelectors[_facet] .functionSelectors; } @@ -75,7 +75,8 @@ contract DiamondLoupeFacet is IDiamondLoupe, IERC165 { returns (address facetAddress_) { LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage(); - facetAddress_ = ds.selectorToFacetAndPosition[_functionSelector] + facetAddress_ = ds + .selectorToFacetAndPosition[_functionSelector] .facetAddress; } diff --git a/contracts/escrow/dapps/interfaces/DataTypes.sol b/contracts/shared/interfaces/DataTypes.sol similarity index 95% rename from contracts/escrow/dapps/interfaces/DataTypes.sol rename to contracts/shared/interfaces/DataTypes.sol index 9ce978c4e..96ae707bf 100644 --- a/contracts/escrow/dapps/interfaces/DataTypes.sol +++ b/contracts/shared/interfaces/DataTypes.sol @@ -45,5 +45,9 @@ library DataTypes { uint256 data; } - enum InterestRateMode { NONE, STABLE, VARIABLE } + enum InterestRateMode { + NONE, + STABLE, + VARIABLE + } } diff --git a/contracts/escrow/dapps/interfaces/IAToken.sol b/contracts/shared/interfaces/IAToken.sol similarity index 95% rename from contracts/escrow/dapps/interfaces/IAToken.sol rename to contracts/shared/interfaces/IAToken.sol index f7faa0318..e7fa13a29 100644 --- a/contracts/escrow/dapps/interfaces/IAToken.sol +++ b/contracts/shared/interfaces/IAToken.sol @@ -2,6 +2,12 @@ pragma solidity ^0.8.0; interface IAToken { + /** + * @dev Returns the underlying token address + * @return address of the underlying token + */ + function UNDERLYING_ASSET_ADDRESS() external view returns (address); + /** * @dev Mints `amount` aTokens to `user` * @param user The address receiving the minted tokens diff --git a/contracts/escrow/dapps/interfaces/IAaveLendingPool.sol b/contracts/shared/interfaces/IAaveLendingPool.sol similarity index 100% rename from contracts/escrow/dapps/interfaces/IAaveLendingPool.sol rename to contracts/shared/interfaces/IAaveLendingPool.sol diff --git a/contracts/escrow/dapps/interfaces/IAaveLendingPoolAddressesProvider.sol b/contracts/shared/interfaces/IAaveLendingPoolAddressesProvider.sol similarity index 100% rename from contracts/escrow/dapps/interfaces/IAaveLendingPoolAddressesProvider.sol rename to contracts/shared/interfaces/IAaveLendingPoolAddressesProvider.sol diff --git a/contracts/shared/interfaces/IComptroller.sol b/contracts/shared/interfaces/IComptroller.sol index 2fc48a889..5ad6a80a0 100644 --- a/contracts/shared/interfaces/IComptroller.sol +++ b/contracts/shared/interfaces/IComptroller.sol @@ -264,4 +264,10 @@ interface IComptroller { * @return The address of COMP */ function getCompAddress() external view returns (address); + + /** + * @notice Return the amount of COMP accrued + * @return The number of COMP + */ + function compAccrued(address holder) external view returns (uint256); } diff --git a/contracts/shared/interfaces/IDiamondCut.sol b/contracts/shared/interfaces/IDiamondCut.sol index 08e66f280..e03f0799c 100644 --- a/contracts/shared/interfaces/IDiamondCut.sol +++ b/contracts/shared/interfaces/IDiamondCut.sol @@ -6,7 +6,11 @@ pragma solidity ^0.8.0; /******************************************************************************/ interface IDiamondCut { - enum FacetCutAction { Add, Replace, Remove } + enum FacetCutAction { + Add, + Replace, + Remove + } struct FacetCut { address facetAddress; diff --git a/contracts/shared/interfaces/ITellerDiamond.sol b/contracts/shared/interfaces/ITellerDiamond.sol index 8cc4d1a2d..e7fa9f54e 100644 --- a/contracts/shared/interfaces/ITellerDiamond.sol +++ b/contracts/shared/interfaces/ITellerDiamond.sol @@ -15,19 +15,21 @@ import { AssetSettingsFacet } from "../../settings/asset/AssetSettingsFacet.sol"; import { PausableFacet } from "../../settings/pausable/PausableFacet.sol"; -import { PriceAggFacet } from "../../price-aggregator/PriceAggFacet.sol"; -import { - ChainlinkAggFacet -} from "../../price-aggregator/chainlink/ChainlinkAggFacet.sol"; import { LendingFacet } from "../../lending/LendingFacet.sol"; import { CreateLoanFacet } from "../../market/CreateLoanFacet.sol"; +import { CreateLoanNFTFacet } from "../../market/CreateLoanNFTFacet.sol"; +import { CreateLoanSnarkFacet } from "../../market/CreateLoanSnarkFacet.sol"; import { LoanDataFacet } from "../../market/LoanDataFacet.sol"; import { RepayFacet } from "../../market/RepayFacet.sol"; import { SignersFacet } from "../../market/SignersFacet.sol"; import { NFTFacet } from "../../nft/NFTFacet.sol"; import { CollateralFacet } from "../../market/CollateralFacet.sol"; import { CompoundFacet } from "../../escrow/dapps/CompoundFacet.sol"; -import { UniswapFacet } from "../../escrow/dapps/UniswapFacet.sol"; +import { + CompoundClaimCompFacet +} from "../../escrow/dapps/CompoundClaimComp.sol"; +import { AaveFacet } from "../../escrow/dapps/AaveFacet.sol"; +import { PoolTogetherFacet } from "../../escrow/dapps/PoolTogetherFacet.sol"; import { ProviderFactoryFacet } from "../../market/ProviderFactoryFacet.sol"; // When adding a new Facet, kindly make sure to order the inherited contracts around so @@ -41,17 +43,19 @@ abstract contract ITellerDiamond is AssetSettingsDataFacet, AssetSettingsFacet, PausableFacet, - PriceAggFacet, - ChainlinkAggFacet, LendingFacet, CollateralFacet, CreateLoanFacet, + CreateLoanNFTFacet, + CreateLoanSnarkFacet, LoanDataFacet, RepayFacet, SignersFacet, NFTFacet, CompoundFacet, - UniswapFacet, + CompoundClaimCompFacet, + AaveFacet, + PoolTogetherFacet, IDiamondCut, IDiamondLoupe, ProviderFactoryFacet diff --git a/contracts/shared/interfaces/IUniswapV2Router.sol b/contracts/shared/interfaces/IUniswapV2Router.sol index f35d8196e..d24640c57 100644 --- a/contracts/shared/interfaces/IUniswapV2Router.sol +++ b/contracts/shared/interfaces/IUniswapV2Router.sol @@ -7,7 +7,7 @@ pragma solidity ^0.8.0; */ interface IUniswapV2Router { function factory() external pure returns (address); - + function addLiquidity( address tokenA, address tokenB, diff --git a/contracts/shared/interfaces/pooltogether/IControlledToken.sol b/contracts/shared/interfaces/pooltogether/IControlledToken.sol new file mode 100644 index 000000000..cb2ab1d7e --- /dev/null +++ b/contracts/shared/interfaces/pooltogether/IControlledToken.sol @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +// Interfaces +import { PrizePoolInterface } from "./PrizePoolInterface.sol"; + +interface IControlledToken { + function controller() external view returns (PrizePoolInterface); +} diff --git a/contracts/escrow/dapps/interfaces/PrizePoolInterface.sol b/contracts/shared/interfaces/pooltogether/PrizePoolInterface.sol similarity index 100% rename from contracts/escrow/dapps/interfaces/PrizePoolInterface.sol rename to contracts/shared/interfaces/pooltogether/PrizePoolInterface.sol diff --git a/contracts/shared/libraries/CacheLib.sol b/contracts/shared/libraries/CacheLib.sol index 13441fdf3..a66e784ed 100644 --- a/contracts/shared/libraries/CacheLib.sol +++ b/contracts/shared/libraries/CacheLib.sol @@ -1,7 +1,13 @@ // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; -enum CacheType { Address, Uint, Int, Byte, Bool } +enum CacheType { + Address, + Uint, + Int, + Byte, + Bool +} /** * @notice This struct manages the cache of the library instance. diff --git a/contracts/shared/libraries/CompoundLib.sol b/contracts/shared/libraries/CompoundLib.sol deleted file mode 100644 index 69747b786..000000000 --- a/contracts/shared/libraries/CompoundLib.sol +++ /dev/null @@ -1,76 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity ^0.8.0; - -// Interfaces -import { ICErc20 } from "../interfaces/ICErc20.sol"; - -// Storage -import { AppStorageLib } from "../../storage/app.sol"; - -/** - * @notice Utility library to calculate the value of a Compound cToken and its underlying asset. - * - * @author develop@teller.finance - */ -library CompoundLib { - /** - * @dev Compounds exchange rate is scaled by 18 decimals (10^18) - */ - uint256 internal constant EXCHANGE_RATE_SCALE = 1e18; - - function exchangeRate(address cToken) internal view returns (uint256) { - return ICErc20(cToken).exchangeRateStored(); - } - - /** - * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate. - * @param cToken Address of the Compound token. - * @param cTokenAmount Amount of the Compound asset. - * @return value of the Compound token amount in underlying tokens. - */ - function valueInUnderlying(address cToken, uint256 cTokenAmount) - internal - view - returns (uint256) - { - return - (cTokenAmount * ICErc20(cToken).exchangeRateStored()) / - EXCHANGE_RATE_SCALE; - } - - /** - * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate. - * @param cToken Address of the Compound token. - * @param underlyingAmount Amount of the underlying asset for the Compound token. - * @return value of the underlying amount in Compound tokens. - */ - function valueOfUnderlying(address cToken, uint256 underlyingAmount) - internal - view - returns (uint256) - { - return - (underlyingAmount * EXCHANGE_RATE_SCALE) / - ICErc20(cToken).exchangeRateStored(); - } - - function isCompoundToken(address token) internal view returns (bool) { - return AppStorageLib.store().cTokenRegistry[token]; - } - - /** - * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise. - * @dev CETH is the only Compound token that does not support the {underlying} function. - * @param cToken address of the compound token - * @return address of the underlying cToken - */ - function getUnderlying(address cToken) internal view returns (address) { - (bool success, bytes memory data) = - cToken.staticcall(abi.encode(ICErc20.underlying.selector)); - if (success) { - return abi.decode(data, (address)); - } - - return AppStorageLib.store().assetAddresses["WETH"]; - } -} diff --git a/contracts/shared/libraries/ENSLib.sol b/contracts/shared/libraries/ENSLib.sol new file mode 100644 index 000000000..0a16beb7c --- /dev/null +++ b/contracts/shared/libraries/ENSLib.sol @@ -0,0 +1,54 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +import { + ENSRegistry +} from "@ensdomains/ens-contracts/contracts/registry/ENSRegistry.sol"; +import { + PublicResolver +} from "@ensdomains/ens-contracts/contracts/resolvers/PublicResolver.sol"; + +library ENS { + bytes32 public constant ETH_NAMEHASH = + 0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae; + + function registryResolve(address registry, bytes32 node) + internal + view + returns (address) + { + return resolve(resolver(registry, node), node); + } + + function resolve(address resolver, bytes32 node) + internal + view + returns (address) + { + return PublicResolver(resolver).addr(node); + } + + function resolver(address registry, bytes32 node) + internal + view + returns (address) + { + return ENSRegistry(registry).resolver(node); + } + + function subnode(string memory name, bytes32 node) + internal + pure + returns (bytes32 namehash_) + { + namehash_ = subnode(keccak256(abi.encodePacked(name)), node); + } + + function subnode(bytes32 label, bytes32 node) + internal + pure + returns (bytes32 namehash_) + { + namehash_ = keccak256(abi.encodePacked(node, label)); + } +} diff --git a/contracts/shared/libraries/LibDiamond.sol b/contracts/shared/libraries/LibDiamond.sol index 9b6c6158e..f48822d54 100644 --- a/contracts/shared/libraries/LibDiamond.sol +++ b/contracts/shared/libraries/LibDiamond.sol @@ -167,19 +167,17 @@ library LibDiamond { _facetAddress != address(0), "LibDiamondCut: Add facet can't be address(0)" ); - uint16 selectorPosition = - uint16( - ds.facetFunctionSelectors[_facetAddress] - .functionSelectors - .length - ); + uint16 selectorPosition = uint16( + ds.facetFunctionSelectors[_facetAddress].functionSelectors.length + ); // add new facet address if it does not exist if (selectorPosition == 0) { enforceHasContractCode( _facetAddress, "LibDiamondCut: New facet has no code" ); - ds.facetFunctionSelectors[_facetAddress] + ds + .facetFunctionSelectors[_facetAddress] .facetAddressPosition = uint16(ds.facetAddresses.length); ds.facetAddresses.push(_facetAddress); } @@ -189,8 +187,9 @@ library LibDiamond { selectorIndex++ ) { bytes4 selector = _functionSelectors[selectorIndex]; - address oldFacetAddress = - ds.selectorToFacetAndPosition[selector].facetAddress; + address oldFacetAddress = ds + .selectorToFacetAndPosition[selector] + .facetAddress; require( oldFacetAddress == address(0), "LibDiamondCut: Can't add function that already exists" @@ -198,9 +197,11 @@ library LibDiamond { ds.facetFunctionSelectors[_facetAddress].functionSelectors.push( selector ); - ds.selectorToFacetAndPosition[selector] + ds + .selectorToFacetAndPosition[selector] .facetAddress = _facetAddress; - ds.selectorToFacetAndPosition[selector] + ds + .selectorToFacetAndPosition[selector] .functionSelectorPosition = selectorPosition; selectorPosition++; } @@ -219,19 +220,17 @@ library LibDiamond { _facetAddress != address(0), "LibDiamondCut: Add facet can't be address(0)" ); - uint16 selectorPosition = - uint16( - ds.facetFunctionSelectors[_facetAddress] - .functionSelectors - .length - ); + uint16 selectorPosition = uint16( + ds.facetFunctionSelectors[_facetAddress].functionSelectors.length + ); // add new facet address if it does not exist if (selectorPosition == 0) { enforceHasContractCode( _facetAddress, "LibDiamondCut: New facet has no code" ); - ds.facetFunctionSelectors[_facetAddress] + ds + .facetFunctionSelectors[_facetAddress] .facetAddressPosition = uint16(ds.facetAddresses.length); ds.facetAddresses.push(_facetAddress); } @@ -241,20 +240,23 @@ library LibDiamond { selectorIndex++ ) { bytes4 selector = _functionSelectors[selectorIndex]; - address oldFacetAddress = - ds.selectorToFacetAndPosition[selector].facetAddress; + address oldFacetAddress = ds + .selectorToFacetAndPosition[selector] + .facetAddress; require( oldFacetAddress != _facetAddress, "LibDiamondCut: Can't replace function with same function" ); removeFunction(oldFacetAddress, selector); // add function - ds.selectorToFacetAndPosition[selector] + ds + .selectorToFacetAndPosition[selector] .functionSelectorPosition = selectorPosition; ds.facetFunctionSelectors[_facetAddress].functionSelectors.push( selector ); - ds.selectorToFacetAndPosition[selector] + ds + .selectorToFacetAndPosition[selector] .facetAddress = _facetAddress; selectorPosition++; } @@ -280,8 +282,9 @@ library LibDiamond { selectorIndex++ ) { bytes4 selector = _functionSelectors[selectorIndex]; - address oldFacetAddress = - ds.selectorToFacetAndPosition[selector].facetAddress; + address oldFacetAddress = ds + .selectorToFacetAndPosition[selector] + .facetAddress; removeFunction(oldFacetAddress, selector); } } @@ -298,21 +301,23 @@ library LibDiamond { "LibDiamondCut: Can't remove immutable function" ); // replace selector with last selector, then delete last selector - uint256 selectorPosition = - ds.selectorToFacetAndPosition[_selector].functionSelectorPosition; - uint256 lastSelectorPosition = - ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - - 1; + uint256 selectorPosition = ds + .selectorToFacetAndPosition[_selector] + .functionSelectorPosition; + uint256 lastSelectorPosition = ds + .facetFunctionSelectors[_facetAddress] + .functionSelectors + .length - 1; // if not the same then replace _selector with lastSelector if (selectorPosition != lastSelectorPosition) { - bytes4 lastSelector = - ds.facetFunctionSelectors[_facetAddress].functionSelectors[ - lastSelectorPosition - ]; + bytes4 lastSelector = ds + .facetFunctionSelectors[_facetAddress] + .functionSelectors[lastSelectorPosition]; ds.facetFunctionSelectors[_facetAddress].functionSelectors[ selectorPosition ] = lastSelector; - ds.selectorToFacetAndPosition[lastSelector] + ds + .selectorToFacetAndPosition[lastSelector] .functionSelectorPosition = uint16(selectorPosition); } // delete the last selector @@ -323,17 +328,21 @@ library LibDiamond { if (lastSelectorPosition == 0) { // replace facet address with last facet address and delete last facet address uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1; - uint256 facetAddressPosition = - ds.facetFunctionSelectors[_facetAddress].facetAddressPosition; + uint256 facetAddressPosition = ds + .facetFunctionSelectors[_facetAddress] + .facetAddressPosition; if (facetAddressPosition != lastFacetAddressPosition) { - address lastFacetAddress = - ds.facetAddresses[lastFacetAddressPosition]; + address lastFacetAddress = ds.facetAddresses[ + lastFacetAddressPosition + ]; ds.facetAddresses[facetAddressPosition] = lastFacetAddress; - ds.facetFunctionSelectors[lastFacetAddress] + ds + .facetFunctionSelectors[lastFacetAddress] .facetAddressPosition = uint16(facetAddressPosition); } ds.facetAddresses.pop(); - delete ds.facetFunctionSelectors[_facetAddress] + delete ds + .facetFunctionSelectors[_facetAddress] .facetAddressPosition; } } diff --git a/contracts/shared/libraries/NumbersLib.sol b/contracts/shared/libraries/NumbersLib.sol index f2744cd16..6a506ec31 100644 --- a/contracts/shared/libraries/NumbersLib.sol +++ b/contracts/shared/libraries/NumbersLib.sol @@ -1,6 +1,9 @@ // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; +// Libraries +import { SafeCast } from "@openzeppelin/contracts/utils/math/SafeCast.sol"; + /** * @dev Utility library for uint256 numbers * @@ -35,7 +38,7 @@ library NumbersLib { /** * @notice it returns the absolute number of a specified parameter - * @param self the number to be returned in it's absolute + * @param self the number to be returned in it's absolute * @return the absolute number */ function abs(int256 self) internal pure returns (uint256) { @@ -53,6 +56,9 @@ library NumbersLib { pure returns (uint16) { - return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2); + return + num2 == 0 + ? 0 + : SafeCast.toUint16((num1 * ONE_HUNDRED_PERCENT) / num2); } } diff --git a/contracts/shared/libraries/StringsLib.sol b/contracts/shared/libraries/StringsLib.sol new file mode 100644 index 000000000..cf19c17b7 --- /dev/null +++ b/contracts/shared/libraries/StringsLib.sol @@ -0,0 +1,356 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +/** + * Strings Library + * + * In summary this is a simple library of string functions which make simple + * string operations less tedious in solidity. + * + * Please be aware these functions can be quite gas heavy so use them only when + * necessary not to clog the blockchain with expensive transactions. + * + * @author James Lockhart + */ +library StringsLib { + /** + * Concat + * + * Appends two strings together and returns a new value + * + * @param _base When being used for a data type this is the extended object + * otherwise this is the string which will be the concatenated + * prefix + * @param _value The value to be the concatenated suffix + * @return string The resulting string from combining the base and value + */ + function concat(string memory _base, string memory _value) + internal + pure + returns (string memory) + { + return string(abi.encodePacked(_base, _value)); + } + + /** + * Index Of + * + * Locates and returns the position of a character within a string + * + * @param _base When being used for a data type this is the extended object + * otherwise this is the string acting as the haystack to be + * searched + * @param _value The needle to search for, at present this is currently + * limited to one character + * @return int The position of the needle starting from 0 and returning -1 + * in the case of no matches found + */ + function indexOf(string memory _base, string memory _value) + internal + pure + returns (int256) + { + return _indexOf(_base, _value, 0); + } + + /** + * Index Of + * + * Locates and returns the position of a character within a string starting + * from a defined offset + * + * @param _base When being used for a data type this is the extended object + * otherwise this is the string acting as the haystack to be + * searched + * @param _value The needle to search for, at present this is currently + * limited to one character + * @param _offset The starting point to start searching from which can start + * from 0, but must not exceed the length of the string + * @return int The position of the needle starting from 0 and returning -1 + * in the case of no matches found + */ + function _indexOf( + string memory _base, + string memory _value, + uint256 _offset + ) internal pure returns (int256) { + bytes memory _baseBytes = bytes(_base); + bytes memory _valueBytes = bytes(_value); + + assert(_valueBytes.length == 1); + + for (uint256 i = _offset; i < _baseBytes.length; i++) { + if (_baseBytes[i] == _valueBytes[0]) { + return int256(i); + } + } + + return -1; + } + + /** + * Length + * + * Returns the length of the specified string + * + * @param _base When being used for a data type this is the extended object + * otherwise this is the string to be measured + * @return uint The length of the passed string + */ + function length(string memory _base) internal pure returns (uint256) { + bytes memory _baseBytes = bytes(_base); + return _baseBytes.length; + } + + /** + * Sub String + * + * Extracts the beginning part of a string based on the desired length + * + * @param _base When being used for a data type this is the extended object + * otherwise this is the string that will be used for + * extracting the sub string from + * @param _length The length of the sub string to be extracted from the base + * @return string The extracted sub string + */ + function substring(string memory _base, int256 _length) + internal + pure + returns (string memory) + { + return _substring(_base, _length, 0); + } + + /** + * Sub String + * + * Extracts the part of a string based on the desired length and offset. The + * offset and length must not exceed the lenth of the base string. + * + * @param _base When being used for a data type this is the extended object + * otherwise this is the string that will be used for + * extracting the sub string from + * @param _length The length of the sub string to be extracted from the base + * @param _offset The starting point to extract the sub string from + * @return string The extracted sub string + */ + function _substring( + string memory _base, + int256 _length, + int256 _offset + ) internal pure returns (string memory) { + bytes memory _baseBytes = bytes(_base); + + assert(uint256(_offset + _length) <= _baseBytes.length); + + string memory _tmp = new string(uint256(_length)); + bytes memory _tmpBytes = bytes(_tmp); + + uint256 j = 0; + for ( + uint256 i = uint256(_offset); + i < uint256(_offset + _length); + i++ + ) { + _tmpBytes[j++] = _baseBytes[i]; + } + + return string(_tmpBytes); + } + + /** + * String Split (Very high gas cost) + * + * Splits a string into an array of strings based off the delimiter value. + * Please note this can be quite a gas expensive function due to the use of + * storage so only use if really required. + * + * @param _base When being used for a data type this is the extended object + * otherwise this is the string value to be split. + * @param _value The delimiter to split the string on which must be a single + * character + * @return splitArr An array of values split based off the delimiter, but + * do not container the delimiter. + */ + function split(string memory _base, string memory _value) + internal + pure + returns (string[] memory splitArr) + { + bytes memory _baseBytes = bytes(_base); + + uint256 _offset = 0; + uint256 _splitsCount = 1; + while (_offset < _baseBytes.length - 1) { + int256 _limit = _indexOf(_base, _value, _offset); + if (_limit == -1) break; + else { + _splitsCount++; + _offset = uint256(_limit) + 1; + } + } + + splitArr = new string[](_splitsCount); + + _offset = 0; + _splitsCount = 0; + while (_offset < _baseBytes.length - 1) { + int256 _limit = _indexOf(_base, _value, _offset); + if (_limit == -1) { + _limit = int256(_baseBytes.length); + } + + string memory _tmp = new string(uint256(_limit) - _offset); + bytes memory _tmpBytes = bytes(_tmp); + + uint256 j = 0; + for (uint256 i = _offset; i < uint256(_limit); i++) { + _tmpBytes[j++] = _baseBytes[i]; + } + _offset = uint256(_limit) + 1; + splitArr[_splitsCount++] = string(_tmpBytes); + } + return splitArr; + } + + /** + * Compare To + * + * Compares the characters of two strings, to ensure that they have an + * identical footprint + * + * @param _base When being used for a data type this is the extended object + * otherwise this is the string base to compare against + * @param _value The string the base is being compared to + * @return bool Simply notates if the two string have an equivalent + */ + function compareTo(string memory _base, string memory _value) + internal + pure + returns (bool) + { + bytes memory _baseBytes = bytes(_base); + bytes memory _valueBytes = bytes(_value); + + if (_baseBytes.length != _valueBytes.length) { + return false; + } + + for (uint256 i = 0; i < _baseBytes.length; i++) { + if (_baseBytes[i] != _valueBytes[i]) { + return false; + } + } + + return true; + } + + /** + * Compare To Ignore Case (High gas cost) + * + * Compares the characters of two strings, converting them to the same case + * where applicable to alphabetic characters to distinguish if the values + * match. + * + * @param _base When being used for a data type this is the extended object + * otherwise this is the string base to compare against + * @param _value The string the base is being compared to + * @return bool Simply notates if the two string have an equivalent value + * discarding case + */ + function compareToIgnoreCase(string memory _base, string memory _value) + internal + pure + returns (bool) + { + bytes memory _baseBytes = bytes(_base); + bytes memory _valueBytes = bytes(_value); + + if (_baseBytes.length != _valueBytes.length) { + return false; + } + + for (uint256 i = 0; i < _baseBytes.length; i++) { + if ( + _baseBytes[i] != _valueBytes[i] && + _upper(_baseBytes[i]) != _upper(_valueBytes[i]) + ) { + return false; + } + } + + return true; + } + + /** + * Upper + * + * Converts all the values of a string to their corresponding upper case + * value. + * + * @param _base When being used for a data type this is the extended object + * otherwise this is the string base to convert to upper case + * @return string + */ + function upper(string memory _base) internal pure returns (string memory) { + bytes memory _baseBytes = bytes(_base); + for (uint256 i = 0; i < _baseBytes.length; i++) { + _baseBytes[i] = _upper(_baseBytes[i]); + } + return string(_baseBytes); + } + + /** + * Lower + * + * Converts all the values of a string to their corresponding lower case + * value. + * + * @param _base When being used for a data type this is the extended object + * otherwise this is the string base to convert to lower case + * @return string + */ + function lower(string memory _base) internal pure returns (string memory) { + bytes memory _baseBytes = bytes(_base); + for (uint256 i = 0; i < _baseBytes.length; i++) { + _baseBytes[i] = _lower(_baseBytes[i]); + } + return string(_baseBytes); + } + + /** + * Upper + * + * Convert an alphabetic character to upper case and return the original + * value when not alphabetic + * + * @param _b1 The byte to be converted to upper case + * @return bytes1 The converted value if the passed value was alphabetic + * and in a lower case otherwise returns the original value + */ + function _upper(bytes1 _b1) private pure returns (bytes1) { + if (_b1 >= 0x61 && _b1 <= 0x7A) { + return bytes1(uint8(_b1) - 32); + } + + return _b1; + } + + /** + * Lower + * + * Convert an alphabetic character to lower case and return the original + * value when not alphabetic + * + * @param _b1 The byte to be converted to lower case + * @return bytes1 The converted value if the passed value was alphabetic + * and in a upper case otherwise returns the original value + */ + function _lower(bytes1 _b1) private pure returns (bytes1) { + if (_b1 >= 0x41 && _b1 <= 0x5A) { + return bytes1(uint8(_b1) + 32); + } + + return _b1; + } +} diff --git a/contracts/storage/app.sol b/contracts/storage/app.sol index 4e6a1a9d0..962dad769 100644 --- a/contracts/storage/app.sol +++ b/contracts/storage/app.sol @@ -3,8 +3,7 @@ pragma solidity ^0.8.0; // Contracts import { TellerNFT } from "../nft/TellerNFT.sol"; - -// Interfaces +import { PriceAggregator } from "../price-aggregator/PriceAggregator.sol"; // Libraries import { @@ -25,13 +24,15 @@ struct AppStorage { //p mapping(bytes32 => PlatformSetting) platformSettings; mapping(address => Cache) assetSettings; - mapping(string => address) assetAddresses; - mapping(address => bool) cTokenRegistry; + mapping(string => address) _assetAddresses; // DEPRECATED + mapping(address => bool) _cTokenRegistry; // DEPRECATED TellerNFT nft; UpgradeableBeaconFactory loansEscrowBeacon; UpgradeableBeaconFactory collateralEscrowBeacon; address nftLiquidationController; UpgradeableBeaconFactory tTokenBeacon; + address wrappedNativeToken; + PriceAggregator priceAggregator; } library AppStorageLib { diff --git a/contracts/storage/market.sol b/contracts/storage/market.sol index 1f9d59ee3..7ecbb6c81 100644 --- a/contracts/storage/market.sol +++ b/contracts/storage/market.sol @@ -15,6 +15,7 @@ import { Verifier } from "../market/cra/verifier.sol"; import { ILoansEscrow } from "../escrow/escrow/ILoansEscrow.sol"; import { ICollateralEscrow } from "../market/collateral/ICollateralEscrow.sol"; import { ITToken } from "../lending/ttoken/ITToken.sol"; +import { States } from "../market/data/states.sol"; // DEPRECATED struct LoanTerms { @@ -24,7 +25,13 @@ struct LoanTerms { uint32 termsExpiry; } -enum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated } +enum LoanStatus { + NonExistent, + TermsSet, + Active, + Closed, + Liquidated +} struct Loan { // Account that owns the loan @@ -56,6 +63,12 @@ struct LoanDebt { uint256 interestOwed; } +struct LoanRequestNFT { + address payable borrower; + address assetAddress; + uint32 duration; +} + /** * @notice our loan request to be sent to our borrow function to verify Proof with the witness, verify our signature data, process the market score to get our interest rate, then create a loan @@ -66,7 +79,7 @@ struct LoanDebt { * @param witness the witness that contains our identifier, score and commitment data * @param signatureData the signatureData that is used to validate against the commitments we construct */ -struct LoanRequest { +struct LoanRequestSnark { LoanUserRequest request; address marketHandlerAddress; Verifier.Proof snarkProof; @@ -92,6 +105,7 @@ struct LoanUserRequest { uint32 duration; uint256 collateralAmount; uint256 assetAmount; + States.StatesCode code; } /** @@ -114,6 +128,16 @@ struct LoanConsensusResponse { Signature signature; } +/** + * @notice Loan request object with the cra responses + * @param request the loan user request + * @param responses the cra responses + */ +struct LoanRequestWithResponse { + LoanUserRequest request; + LoanConsensusResponse[] responses; +} + /** * @notice Represents a user signature * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int diff --git a/contracts/storage/price-aggregator.sol b/contracts/storage/price-aggregator.sol deleted file mode 100644 index 00e80ea1a..000000000 --- a/contracts/storage/price-aggregator.sol +++ /dev/null @@ -1,32 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity ^0.8.0; - -import { - EnumerableSet -} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol"; - -struct ChainlinkAggStorage { - // Maps source token => destination token => Chainlink Aggregator - mapping(address => mapping(address => address)) aggregators; - // Maps token address to number of supported Chainlink pairs - mapping(address => uint256) pairCount; - // Stores set of token addresses supported by Chainlink - EnumerableSet.AddressSet supportedTokens; -} - -struct PriceAggStorage { - ChainlinkAggStorage chainlink; -} - -bytes32 constant PRICE_AGG_STORAGE_POS = keccak256( - "teller.price.aggregator.storage" -); - -library PriceAggStorageLib { - function store() internal pure returns (PriceAggStorage storage s) { - bytes32 pos = PRICE_AGG_STORAGE_POS; - assembly { - s.slot := pos - } - } -} diff --git a/deploy/asset-settings.ts b/deploy/asset-settings.ts index 5efab03e1..78ede809d 100644 --- a/deploy/asset-settings.ts +++ b/deploy/asset-settings.ts @@ -35,11 +35,16 @@ const createAssetSettings: DeployFunction = async (hre) => { let value: string let cacheType: CacheType switch (setting.type) { - case AssetType.Address: + case AssetType.Token: value = tokens.all[setting.value] cacheType = CacheType.Address break + case AssetType.Address: + value = setting.value + cacheType = CacheType.Address + break + case AssetType.Amount: value = toBN(setting.value, decimals).toHexString() cacheType = CacheType.Uint diff --git a/deploy/markets.ts b/deploy/markets.ts index d3737b29b..dd11c7a6f 100644 --- a/deploy/markets.ts +++ b/deploy/markets.ts @@ -3,7 +3,7 @@ import { ContractTransaction } from 'ethers' import { HardhatRuntimeEnvironment } from 'hardhat/types' import { DeployFunction } from 'hardhat-deploy/types' -import { getMarkets, getSigners, getTokens } from '../config' +import { getDappAddresses, getMarkets, getSigners, getTokens } from '../config' import { ITellerDiamond, ITToken } from '../types/typechain' import { NULL_ADDRESS } from '../utils/consts' import { deploy } from '../utils/deploy-helpers' @@ -24,6 +24,7 @@ const initializeMarkets: DeployFunction = async (hre) => { log('') const tokenAddresses = getTokens(network) + const dappAddresses = getDappAddresses(network) const markets = getMarkets(network) const diamond = await contracts.get('TellerDiamond', { @@ -128,7 +129,8 @@ const initializeMarkets: DeployFunction = async (hre) => { switch (type) { case 'TokenSymbol': return tokenAddresses.all[value] - case 'Address': + case 'ProtocolAddressConstant': + return dappAddresses[value] case 'Number': return value } diff --git a/deploy/price-agg.ts b/deploy/price-agg.ts index c1e94b2fb..af854eb12 100644 --- a/deploy/price-agg.ts +++ b/deploy/price-agg.ts @@ -1,66 +1,259 @@ +import colors from 'colors' +import { HardhatRuntimeEnvironment } from 'hardhat/types' import { DeployFunction } from 'hardhat-deploy/types' -import { getChainlink, getTokens } from '../config' -import { ITellerDiamond } from '../types/typechain' -import { NULL_ADDRESS } from '../utils/consts' +import { getChainlink, getNetworkName, getTokens } from '../config' +import { Tokens } from '../types/custom/config-types' +import { + ChainlinkPricer, + ENSRegistry, + IsaLPPricer, + PriceAggregator, + PublicResolver, +} from '../types/typechain' +import { DUMMY_ADDRESS } from '../utils/consts' +import { deploy } from '../utils/deploy-helpers' const registerPriceAggregators: DeployFunction = async (hre) => { - const { getNamedAccounts, contracts, network, log } = hre - const { deployer } = await getNamedAccounts() + const { network, log } = hre + + const tokens = getTokens(network) log('********** Chainlink **********', { indent: 1 }) log('') - const tokens = getTokens(network) - const chainlink = getChainlink(network) + const chainlinkPricer = await deployChainlinkPricer(hre) - const diamond = await contracts.get('TellerDiamond', { - from: deployer, + const priceAgg = await deploy({ + contract: 'PriceAggregator', + args: [tokens.all.WETH, chainlinkPricer.address], + skipIfAlreadyDeployed: true, + hre, }) - for (const chainlinkPair of Object.values(chainlink)) { - const { address, baseTokenName, quoteTokenName } = chainlinkPair - - log( - `Registering aggregator for ${baseTokenName}/${quoteTokenName} pair: `, - { indent: 2, star: true, nl: false } - ) - - // Check that the aggregator is already registered - const { agg } = await diamond.getChainlinkAggregatorFor( - tokens.all[baseTokenName], - tokens.all[quoteTokenName] - ) - if (agg === address) { - log(`${address} already registered`) - } else if (agg !== NULL_ADDRESS) { - log('') - log( - `!! Chainlink Aggregator already registered with a different address !!` - ) - log( - `!! Please check your config !!` - ) - log(`Current: ${agg}`, { indent: 2, star: true }) - log(`New: ${address}`, { indent: 2, star: true }) - } else { - // Try to register the Chainlink aggregator address - const receipt = await diamond - .addChainlinkAggregator( - tokens.all[baseTokenName], - tokens.all[quoteTokenName], - address - ) + await addCompoundPricer(priceAgg, hre) + await addAavePricer(priceAgg, hre) + await addPoolTogetherPricer(priceAgg, hre) + + log('') +} + +const deployChainlinkPricer = async ( + hre: HardhatRuntimeEnvironment +): Promise => { + let resolverAddress: string + switch (getNetworkName(hre.network)) { + case 'mainnet': + case 'kovan': + case 'rinkeby': + case 'ropsten': + resolverAddress = '0x122eb74f9d0F1a5ed587F43D120C1c2BbDb9360B' + break + + case 'polygon': + case 'polygon_mumbai': + resolverAddress = await deployChainlinkENS(hre) + break + + default: + throw new Error('Invalid network name') + } + + const chainlinkPricer = await deploy({ + contract: 'ChainlinkPricer', + args: [resolverAddress], + skipIfAlreadyDeployed: true, + hre, + }) + + return chainlinkPricer +} + +const deployChainlinkENS = async ( + hre: HardhatRuntimeEnvironment +): Promise => { + const deployer = await hre.getNamedSigner('deployer') + const deployerAddress = await deployer.getAddress() + + const ensRegistry = await deploy({ + contract: 'ENSRegistry', + skipIfAlreadyDeployed: true, + hre, + }) + const resolver = await deploy({ + contract: 'PublicResolver', + args: [ensRegistry.address, DUMMY_ADDRESS], + skipIfAlreadyDeployed: true, + hre, + }) + + const tld = 'eth' + const tldLabel = hre.ethers.utils.id(tld) + const tldNode = hre.ethers.utils.namehash(tld) + + const mainDomain = 'data' + const dataLabel = hre.ethers.utils.id(mainDomain) + const dataNode = hre.ethers.utils.namehash(`${mainDomain}.${tld}`) + + if (ensRegistry.deployResult.newlyDeployed) { + await ensRegistry + .connect(deployer) + .setSubnodeOwner(Buffer.alloc(32), tldLabel, deployerAddress) + .then(({ wait }) => wait()) + await ensRegistry + .connect(deployer) + .setSubnodeOwner(tldNode, dataLabel, deployerAddress) + .then(({ wait }) => wait()) + await ensRegistry + .connect(deployer) + .setResolver(tldNode, resolver.address) + .then(({ wait }) => wait()) + await ensRegistry + .connect(deployer) + .setResolver(dataNode, resolver.address) + .then(({ wait }) => wait()) + await resolver + .connect(deployer) + ['setAddr(bytes32,address)'](tldNode, resolver.address) + .then(({ wait }) => wait()) + await resolver + .connect(deployer) + ['setAddr(bytes32,address)'](dataNode, resolver.address) + .then(({ wait }) => wait()) + } + + hre.log('') + hre.log('Registering Chainlink ENS names', { star: true, indent: 1 }) + + const chainlink = getChainlink(hre.network) + for (const config of Object.values(chainlink)) { + const chainlinkAggSubdomain = `${config.baseTokenName.toLowerCase()}-${config.quoteTokenName.toLowerCase()}` + const chainlinkAggDomain = `${chainlinkAggSubdomain}.${mainDomain}.${tld}` + const chainlinkAggLabel = hre.ethers.utils.id(chainlinkAggSubdomain) + const chainlinkAggNode = hre.ethers.utils.namehash(chainlinkAggDomain) + const address = await resolver['addr(bytes32)'](chainlinkAggNode) + + hre.log(`${colors.underline(chainlinkAggSubdomain)}: ${config.address}`, { + star: true, + nl: false, + indent: 2, + }) + + if (address != config.address) { + await ensRegistry + .connect(deployer) + .setSubnodeOwner(dataNode, chainlinkAggLabel, deployerAddress) + .then(({ wait }) => wait()) + const receipt = await resolver + .connect(deployer) + ['setAddr(bytes32,address)'](chainlinkAggNode, config.address) .then(({ wait }) => wait()) - log(`${address} with ${receipt.gasUsed} gas`) + const gas = `${receipt.gasUsed.toString()} gas` + hre.log(` ${colors.green('new')} with ${colors.cyan(gas)}`) + } else { + hre.log(` ${colors.yellow('reusing')}`) } } - log('') + return resolver.address +} + +const addCompoundPricer = async ( + priceAgg: PriceAggregator, + hre: HardhatRuntimeEnvironment +): Promise => { + const { all: allTokens, compound: tokens } = getTokens(hre.network) + + if (tokens == null) return + + const pricer = await deploy({ + contract: 'CompoundPricer', + args: [allTokens.WETH, tokens.CETH], + skipIfAlreadyDeployed: true, + hre, + }) + + await addPricer({ + priceAgg, + pricer, + tokens, + hre, + }) +} + +const addAavePricer = async ( + priceAgg: PriceAggregator, + hre: HardhatRuntimeEnvironment +): Promise => { + const { aave: tokens } = getTokens(hre.network) + + const pricer = await deploy({ + contract: 'AavePricer', + skipIfAlreadyDeployed: true, + hre, + }) + + await addPricer({ + priceAgg, + pricer, + tokens, + hre, + }) +} + +const addPoolTogetherPricer = async ( + priceAgg: PriceAggregator, + hre: HardhatRuntimeEnvironment +): Promise => { + const { poolTogether: tokens } = getTokens(hre.network) + + const pricer = await deploy({ + contract: 'PoolTogetherPricer', + skipIfAlreadyDeployed: true, + hre, + }) + + await addPricer({ + priceAgg, + pricer, + tokens, + hre, + }) +} + +interface AddPricerArgs { + priceAgg: PriceAggregator + pricer: IsaLPPricer + tokens?: Tokens + hre: HardhatRuntimeEnvironment +} + +const addPricer = async (args: AddPricerArgs): Promise => { + const { priceAgg, pricer, tokens, hre } = args + + // Check if the tokens map exists + if (tokens == null) return + + // Loop each token address and check if any need to be set + const tokensToSet: string[] = [] + for (const tokenAddress of Object.values(tokens)) { + const pricerAddress = await priceAgg.saLPPricer(tokenAddress) + if (pricerAddress !== pricer.address) { + tokensToSet.push(tokenAddress) + } + } + + // Set pricer for tokens if needed + if (tokensToSet.length > 0) { + await priceAgg + .connect(await hre.getNamedSigner('deployer')) + .setAssetPricers(pricer.address, tokensToSet) + .then(({ wait }) => wait()) + } } registerPriceAggregators.tags = ['price-agg'] -registerPriceAggregators.dependencies = ['protocol'] +registerPriceAggregators.dependencies = ['setup'] export default registerPriceAggregators diff --git a/deploy/protocol.ts b/deploy/protocol.ts index 7d4acb7ec..72be026ac 100644 --- a/deploy/protocol.ts +++ b/deploy/protocol.ts @@ -1,7 +1,7 @@ import { HardhatRuntimeEnvironment } from 'hardhat/types' import { DeployFunction } from 'hardhat-deploy/types' -import { getNetworkName, getTokens } from '../config' +import { getDappAddresses, getNativeToken, getNetworkName } from '../config' import { ICollateralEscrow, ILoansEscrow, @@ -28,6 +28,11 @@ const deployProtocol: DeployFunction = async (hre) => { const market = await deployMarket(hre) const collateralEscrowBeacon = await deployCollateralEscrowBeacon(hre) const tTokenBeacon = await deployTTokenBeacon(hre) + const nftDictionary = await contracts.get('TellerNFTDictionary') + const priceAggregator = await contracts.get('PriceAggregator') + + const wrappedNativeToken = getNativeToken(network) + const dappAddresses = getDappAddresses(network) let execute: DeployDiamondArgs['execute'] @@ -36,17 +41,15 @@ const deployProtocol: DeployFunction = async (hre) => { await contracts.get('TellerDiamond') // If deployment exists execute upgrade function - const executeMethod = undefined - const upgradeExecute: DeployDiamondArgs< - ITellerDiamond, - typeof executeMethod - >['execute'] = undefined + const executeMethod = 'setPriceAggregator' + const upgradeExecute = { + methodName: executeMethod, + args: [priceAggregator.address], + } execute = upgradeExecute } catch { // Else execute initialize function - - const tokens = getTokens(network) const executeMethod = 'init' const initExecute: DeployDiamondArgs< ITellerDiamond, @@ -56,11 +59,6 @@ const deployProtocol: DeployFunction = async (hre) => { args: [ { admin: deployer, - assets: Object.entries(tokens.erc20).map(([sym, addr]) => ({ - sym, - addr, - })), - cTokens: Object.values(tokens.compound), tellerNFT: nftAddress, loansEscrowBeacon: loansEscrowBeacon.address, collateralEscrowBeacon: collateralEscrowBeacon.address, @@ -68,6 +66,9 @@ const deployProtocol: DeployFunction = async (hre) => { // Teller Gnosis Safe contract nftLiquidationController: '0x95143890162bd671d77ae9b771881a1cb76c29a4', + wrappedNativeToken: wrappedNativeToken, + nftDictionary: nftDictionary.address, + priceAggregator: priceAggregator.address, }, ], } @@ -80,37 +81,33 @@ const deployProtocol: DeployFunction = async (hre) => { // Settings { contract: 'SettingsFacet', - skipIfAlreadyDeployed: true, + skipIfAlreadyDeployed: false, }, { contract: 'PlatformSettingsFacet', - skipIfAlreadyDeployed: true, + skipIfAlreadyDeployed: false, }, { contract: 'AssetSettingsDataFacet', - skipIfAlreadyDeployed: true, + skipIfAlreadyDeployed: false, }, { contract: 'AssetSettingsFacet', - skipIfAlreadyDeployed: true, + skipIfAlreadyDeployed: false, }, { contract: 'PausableFacet', - skipIfAlreadyDeployed: true, + skipIfAlreadyDeployed: false, }, // Pricing { contract: 'PriceAggFacet', - skipIfAlreadyDeployed: true, - }, - { - contract: 'ChainlinkAggFacet', - skipIfAlreadyDeployed: true, + skipIfAlreadyDeployed: false, }, // Lending { contract: 'LendingFacet', - skipIfAlreadyDeployed: true, + skipIfAlreadyDeployed: false, }, // Loans { @@ -126,7 +123,7 @@ const deployProtocol: DeployFunction = async (hre) => { }, { contract: 'LoanDataFacet', - skipIfAlreadyDeployed: true, + skipIfAlreadyDeployed: false, }, { contract: 'RepayFacet', @@ -134,6 +131,10 @@ const deployProtocol: DeployFunction = async (hre) => { }, { contract: 'SignersFacet', + skipIfAlreadyDeployed: false, + }, + { + contract: 'ProviderFactoryFacet', skipIfAlreadyDeployed: true, }, { @@ -145,11 +146,16 @@ const deployProtocol: DeployFunction = async (hre) => { contract: 'NFTFacet', skipIfAlreadyDeployed: false, }, - // // Dapps - // { - // contract: 'AaveFacet', - // skipIfAlreadyDeployed: true, - // }, + // Dapps + { + contract: 'AaveFacet', + skipIfAlreadyDeployed: false, + args: [dappAddresses.aaveLendingPoolAddressProvider], + }, + { + contract: 'PoolTogetherFacet', + skipIfAlreadyDeployed: false, + }, ] // Network specify Facets @@ -162,22 +168,37 @@ const deployProtocol: DeployFunction = async (hre) => { // Dapps { contract: 'UniswapFacet', - skipIfAlreadyDeployed: true, + skipIfAlreadyDeployed: false, + args: [dappAddresses.uniswapV2RouterAddress], }, { contract: 'CompoundFacet', - skipIfAlreadyDeployed: true, + skipIfAlreadyDeployed: false, + }, + { + contract: 'CompoundClaimCompFacet', + skipIfAlreadyDeployed: false, + args: [dappAddresses.compoundComptrollerAddress], } + // disable for now + // { + // contract: 'YearnFacet', + // skipIfAlreadyDeployed: false, + // } ) break case 'polygon': + case 'polygon_mumbai': + case 'localhost': + case 'hardhat': facets.push( // Dapps { contract: 'SushiswapFacet', - skipIfAlreadyDeployed: true, + skipIfAlreadyDeployed: false, + args: [dappAddresses.sushiswapV2RouterAddress], } ) @@ -245,7 +266,9 @@ const deployMarket = async (hre: HardhatRuntimeEnvironment): Promise => { contract: 'ProcessRequestLib', log: true, }) - const maxInterestRate = 10000 + + // teller market values + const maxInterestRate = 3500 const maxCollateralRatio = 15000 const maxLoanAmount = 25000 const tellerMarketHandler = await deploy({ @@ -259,7 +282,9 @@ const deployMarket = async (hre: HardhatRuntimeEnvironment): Promise => { const deployLoansEscrowBeacon = async ( hre: HardhatRuntimeEnvironment ): Promise => { - const { ethers, log } = hre + const { getNamedSigner, ethers, log } = hre + + const deployer = await getNamedSigner('deployer') log('********** Loans Escrow Beacon **********', { indent: 2 }) log('') @@ -275,7 +300,7 @@ const deployLoansEscrowBeacon = async ( const beaconProxy = await deploy({ hre, contract: 'InitializeableBeaconProxy', - log: false, + indent: 4, }) const beacon = await deploy({ @@ -283,7 +308,7 @@ const deployLoansEscrowBeacon = async ( contract: 'UpgradeableBeaconFactory', name: 'EscrowBeaconFactory', args: [beaconProxy.address, loansEscrowLogic.address], - indent: 3, + indent: 4, }) // Check to see if we need to upgrade @@ -293,10 +318,13 @@ const deployLoansEscrowBeacon = async ( ethers.utils.getAddress(loansEscrowLogic.address) ) { log(`Upgrading Loans Escrow logic: ${loansEscrowLogic.address}`, { - indent: 4, + indent: 5, star: true, }) - await beacon.upgradeTo(loansEscrowLogic.address).then(({ wait }) => wait()) + await beacon + .connect(deployer) + .upgradeTo(loansEscrowLogic.address) + .then(({ wait }) => wait()) } log('') @@ -307,7 +335,9 @@ const deployLoansEscrowBeacon = async ( const deployCollateralEscrowBeacon = async ( hre: HardhatRuntimeEnvironment ): Promise => { - const { ethers, log } = hre + const { getNamedSigner, ethers, log } = hre + + const deployer = await getNamedSigner('deployer') log('********** Collateral Escrow Beacon **********', { indent: 2 }) log('') @@ -323,7 +353,7 @@ const deployCollateralEscrowBeacon = async ( const beaconProxy = await deploy({ hre, contract: 'InitializeableBeaconProxy', - log: false, + indent: 4, }) const beacon = await deploy({ @@ -331,7 +361,7 @@ const deployCollateralEscrowBeacon = async ( contract: 'UpgradeableBeaconFactory', name: 'CollateralEscrowBeaconFactory', args: [beaconProxy.address, collateralEscrowLogic.address], - indent: 3, + indent: 4, }) // Check to see if we need to upgrade @@ -341,10 +371,11 @@ const deployCollateralEscrowBeacon = async ( ethers.utils.getAddress(collateralEscrowLogic.address) ) { log(`Upgrading Collateral Escrow logic: ${collateralEscrowLogic.address}`, { - indent: 4, + indent: 5, star: true, }) await beacon + .connect(deployer) .upgradeTo(collateralEscrowLogic.address) .then(({ wait }) => wait()) } @@ -357,12 +388,14 @@ const deployCollateralEscrowBeacon = async ( const deployTTokenBeacon = async ( hre: HardhatRuntimeEnvironment ): Promise => { - const { ethers, log } = hre + const { getNamedSigner, ethers, log } = hre + + const deployer = await getNamedSigner('deployer') log('********** Teller Token (TToken) Beacon **********', { indent: 2 }) log('') - const logicVersion = 1 + const logicVersion = 2 const tTokenLogic = await deploy({ hre, @@ -373,7 +406,7 @@ const deployTTokenBeacon = async ( const beaconProxy = await deploy({ hre, contract: 'InitializeableBeaconProxy', - log: false, + indent: 4, }) const beacon = await deploy({ @@ -381,7 +414,7 @@ const deployTTokenBeacon = async ( contract: 'UpgradeableBeaconFactory', name: 'TTokenBeaconFactory', args: [beaconProxy.address, tTokenLogic.address], - indent: 3, + indent: 4, }) // Check to see if we need to upgrade @@ -391,10 +424,13 @@ const deployTTokenBeacon = async ( ethers.utils.getAddress(tTokenLogic.address) ) { log(`Upgrading Teller Token logic: ${tTokenLogic.address}`, { - indent: 4, + indent: 5, star: true, }) - await beacon.upgradeTo(tTokenLogic.address).then(({ wait }) => wait()) + await beacon + .connect(deployer) + .upgradeTo(tTokenLogic.address) + .then(({ wait }) => wait()) } log('') @@ -403,6 +439,6 @@ const deployTTokenBeacon = async ( } deployProtocol.tags = ['protocol'] -deployProtocol.dependencies = ['setup', 'nft'] +deployProtocol.dependencies = ['setup', 'nft', 'price-agg'] export default deployProtocol diff --git a/deployments/kovan/.latestDeploymentBlock b/deployments/kovan/.latestDeploymentBlock index 6eb3d2d55..710780bef 100644 --- a/deployments/kovan/.latestDeploymentBlock +++ b/deployments/kovan/.latestDeploymentBlock @@ -1 +1 @@ -25521615 \ No newline at end of file +25672048 \ No newline at end of file diff --git a/deployments/kovan/RepayFacet.json b/deployments/kovan/RepayFacet.json index 0ac8f2ddd..7071eccef 100644 --- a/deployments/kovan/RepayFacet.json +++ b/deployments/kovan/RepayFacet.json @@ -1,5 +1,5 @@ { - "address": "0xe6fc54F4e4346b03636a0911Efd51ECa21242Bb7", + "address": "0x33B74a5AbFc9FB0c8AC9f463361AEFCDe38cE886", "abi": [ { "anonymous": false, @@ -176,27 +176,27 @@ } ], "artifactName": "RepayFacet", - "transactionHash": "0xc82ec063e1fb7747b28039b653e7bffdc003edf3d5af1efc52c2c5a301db91f1", + "transactionHash": "0x2ff94ff6f65c60f583ffb76b4c85b9f8d628bef3032f089388dd047d7fad2163", "receipt": { "to": null, "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", - "contractAddress": "0xe6fc54F4e4346b03636a0911Efd51ECa21242Bb7", + "contractAddress": "0x33B74a5AbFc9FB0c8AC9f463361AEFCDe38cE886", "transactionIndex": 0, - "gasUsed": "1914533", + "gasUsed": "1929835", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "blockHash": "0xde4ed8012c33bda2dfb8e2b7a93e92fe7bcced3d55afca0b55da14cf6dba8787", - "transactionHash": "0xc82ec063e1fb7747b28039b653e7bffdc003edf3d5af1efc52c2c5a301db91f1", + "blockHash": "0xc60ff308022d9479ef415ece8189aab744fd2d93d4463caf5c7208df9280e463", + "transactionHash": "0x2ff94ff6f65c60f583ffb76b4c85b9f8d628bef3032f089388dd047d7fad2163", "logs": [], - "blockNumber": 25521611, - "cumulativeGasUsed": "1914533", + "blockNumber": 25672046, + "cumulativeGasUsed": "1929835", "status": 1, "byzantium": true }, "args": [], - "solcInputHash": "1389136e56e3a43cff4f2990a46ef548", - "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"liquidator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"reward\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokensIn\",\"type\":\"uint256\"}],\"name\":\"LoanLiquidated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountPaid\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"totalOwed\",\"type\":\"uint256\"}],\"name\":\"LoanRepaid\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"}],\"name\":\"TokensClaimed\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"claimTokens\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"escrowRepay\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLiquidationReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"inLending_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"inCollateral_\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"liquidateLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"repayLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"params\":{\"borrower\":\"Account address of the borrower\",\"liquidator\":\"Account address of the liquidator\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"reward\":\"Value in lending token paid out to liquidator\",\"tokensIn\":\"Percentage of the collateral price paid by the liquidator to the lending pool\"}},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"params\":{\"amountPaid\":\"Amount of the loan paid back\",\"borrower\":\"Account address of the borrower\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"payer\":\"Account address of the payer\",\"totalOwed\":\"Total amount of the loan to be repaid\"}}},\"kind\":\"dev\",\"methods\":{\"claimTokens(uint256)\":{\"params\":{\"loanID\":\"The id of the loan being used.\"}},\"escrowRepay(uint256,uint256)\":{\"details\":\"If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\",\"params\":{\"amount\":\"The amount being repaid.\",\"loanID\":\"The id of the loan being used.\"}},\"getLiquidationReward(uint256)\":{\"params\":{\"loanID\":\"The loan ID to get the info.\"},\"returns\":{\"inCollateral_\":\"The value the liquidator will receive denoted in collateral tokens.\",\"inLending_\":\"The value the liquidator will receive denoted in lending tokens.\"}},\"liquidateLoan(uint256)\":{\"params\":{\"loanID\":\"The ID of the loan to be liquidated\"}},\"repayLoan(uint256,uint256)\":{\"params\":{\"amount\":\"The amount of tokens to pay back to the loan\",\"loanID\":\"The ID of the loan the payment is for\"}}},\"version\":1},\"userdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully liquidated\"},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully repaid\"},\"TokensClaimed(address)\":{\"notice\":\"Notifies when the Escrow's tokens have been claimed.\"}},\"kind\":\"user\",\"methods\":{\"claimTokens(uint256)\":{\"notice\":\"Sends the tokens owned by this escrow to the owner.\"},\"escrowRepay(uint256,uint256)\":{\"notice\":\"Repay this Escrow's loan.\"},\"getLiquidationReward(uint256)\":{\"notice\":\"It gets the current liquidation reward for a given loan.\"},\"liquidateLoan(uint256)\":{\"notice\":\"Liquidate a loan if it is expired or under collateralized\"},\"repayLoan(uint256,uint256)\":{\"notice\":\"Make a payment to a loan\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/market/RepayFacet.sol\":\"RepayFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Trees proofs.\\n *\\n * The proofs can be generated using the JavaScript library\\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\\n *\\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n bytes32 computedHash = leaf;\\n\\n for (uint256 i = 0; i < proof.length; i++) {\\n bytes32 proofElement = proof[i];\\n\\n if (computedHash <= proofElement) {\\n // Hash(current computed hash + current element of the proof)\\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\\n } else {\\n // Hash(current element of the proof + current computed hash)\\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\\n }\\n }\\n\\n // Check if the computed hash (root) is equal to the provided root\\n return computedHash == root;\\n }\\n}\\n\",\"keccak256\":\"0xeee34bfb413657b6cd6c8e1e15c2080ba5ebaac479578515922804346fb63f7c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/reentry/ReentryMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nabstract contract ReentryMods {\\n modifier nonReentry(bytes32 id) {\\n AccessControlStorage storage s = AccessControlStorageLib.store();\\n require(!s.entered[id], \\\"AccessControl: reentered\\\");\\n s.entered[id] = true;\\n _;\\n s.entered[id] = false;\\n }\\n}\\n\",\"keccak256\":\"0x033c1164af25ef7d35a38a60973bf379b1cc603596914ffd85dcbcf0acdb6970\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/EscrowClaimTokens.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\n\\n// Interfaces\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, LoanStatus } from \\\"../storage/market.sol\\\";\\n\\n// Libraries\\nimport { LibLoans } from \\\"../market/libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"./libraries/LibEscrow.sol\\\";\\n\\n/**\\n * @notice Contains functionality to claim tokens that are in an escrow contract for a loan.\\n */\\ncontract EscrowClaimTokens is PausableMods {\\n /**\\n * @notice Notifies when the Escrow's tokens have been claimed.\\n * @param recipient address where the tokens where sent to.\\n */\\n event TokensClaimed(address recipient);\\n\\n /**\\n * @notice Sends the tokens owned by this escrow to the owner.\\n * @param loanID The id of the loan being used.\\n */\\n function claimTokens(uint256 loanID) external paused(\\\"\\\", false) {\\n require(\\n LibLoans.loan(loanID).borrower == msg.sender,\\n \\\"Teller: claim not borrower\\\"\\n );\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Closed,\\n \\\"Teller: loan not closed\\\"\\n );\\n\\n __claimEscrowTokens(loanID);\\n }\\n\\n function __claimEscrowTokens(uint256 loanID) internal {\\n __claimToken(loanID, LibLoans.loan(loanID).lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n __claimToken(loanID, EnumerableSet.at(tokens, i));\\n }\\n\\n emit TokensClaimed(msg.sender);\\n }\\n\\n function __claimToken(uint256 loanID, address token) private {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n if (balance > 0) {\\n LibEscrow.e(loanID).claimToken(\\n token,\\n LibLoans.loan(loanID).borrower,\\n balance\\n );\\n }\\n }\\n}\\n\",\"keccak256\":\"0xae189ea2a13c10f013f255f98ec50f34466c375bd7503275587d6abe5d25696c\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../interfaces/IAToken.sol\\\";\\nimport { IAaveLendingPool } from \\\"../interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x8030b206c87d0073fb7dbebfa2ee8a3e93c479d976d6cdaa0c939f2fedaa1525\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n /**\\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\\n * @param dappAddress address of the target contract address\\n * @param dappData encoded abi of the function in our contract we want to call\\n * @return the called data in bytes\\n */\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n /**\\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\\n * @param token address of the respective ERC20 token to approve for the spender\\n * @param spender address of the respective spender who is approved by the token contract\\n */\\n function setTokenAllowance(address token, address spender) external;\\n\\n /**\\n * @notice it allows user to claim their escrow tokens\\n * @dev only the owner (TellerDiamond) can make this call on behalf of the users\\n * @param token address of the respective token contract to claim tokens from\\n * @param to address where the tokens should be transferred to\\n * @param amount uint256 amount of tokens to be claimed\\n */\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xaf67fc4454ffaa4d2f7e46fe7101876e8ebdb1a5426c30f87b8e18cc573ac019\",\"license\":\"MIT\"},\"contracts/escrow/libraries/LibEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibDapps } from \\\"../dapps/libraries/LibDapps.sol\\\";\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibEscrow {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\\n e_ = s().loanEscrows[loanID];\\n }\\n\\n /**\\n * @notice It returns a list of tokens owned by a loan escrow\\n * @param loanID uint256 index used to return our token list\\n * @return t_ which is a list of tokens \\n */\\n function getEscrowTokens(uint256 loanID)\\n internal\\n view\\n returns (EnumerableSet.AddressSet storage t_)\\n {\\n t_ = s().escrowTokens[loanID];\\n }\\n\\n /**\\n * @notice It returns the balance of a respective token in a loan escrow\\n * @param loanID uint256 index used to point to our loan escrow\\n * @param token address of respective token to give us the balance of in our loan escrow\\n * @return uint256 balance of respective token returned in an escrow loan\\n */\\n function balanceOf(uint256 loanID, address token)\\n internal\\n view\\n returns (uint256)\\n {\\n return IERC20(token).balanceOf(address(e(loanID)));\\n }\\n\\n /**\\n * @notice Adds or removes tokens held by the Escrow contract\\n * @param loanID The loan ID to update the token list for\\n * @param tokenAddress The token address to be added or removed\\n */\\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\\n // Skip if is lending token\\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\\n\\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\\n if (balanceOf(loanID, tokenAddress) > 0) {\\n if (!contains) {\\n EnumerableSet.add(tokens, tokenAddress);\\n }\\n } else if (contains) {\\n EnumerableSet.remove(tokens, tokenAddress);\\n }\\n }\\n\\n /**\\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\\n * @param loanID The loan ID to calculate value for\\n * @return value_ Escrow total value denoted in the lending token.\\n */\\n function calculateTotalValue(uint256 loanID)\\n internal\\n view\\n returns (uint256 value_)\\n {\\n address lendingToken = LibLoans.loan(loanID).lendingToken;\\n value_ += balanceOf(loanID, lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\\n if (EnumerableSet.length(tokens) > 0) {\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n uint256 tokenBal =\\n balanceOf(loanID, EnumerableSet.at(tokens, i));\\n value_ += PriceAggLib.valueFor(\\n EnumerableSet.at(tokens, i),\\n lendingToken,\\n tokenBal\\n );\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x17a7c6b11d6f280948e320525d1e131b89c23f80216918aa070df437a851d915\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when a user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when a user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n * @return ERC20 token\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n * @return balance_ the balance of the account\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice It calculates the total supply of the underlying asset.\\n * @return totalSupply_ the total supply denoted in the underlying asset.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given market.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n \\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfill the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n * @return mintAmount_ the amount minted of the specified token\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n * @return address of the strategy contract\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n * @param state boolean value that resembles the platform's state\\n */\\n function restrict(bool state) external virtual;\\n\\n /**\\n * @notice it initializes the Teller Token\\n * @param admin address of the admin to the respective Teller Token\\n * @param underlying address of the ERC20 token\\n */\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xf30ac4ef491851477ff9a3dd04974ebe74b529c37a3ef4e05798c3f734ceeb3d\",\"license\":\"MIT\"},\"contracts/market/LoanDataFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { Loan, LoanDebt, LoanTerms } from \\\"../storage/market.sol\\\";\\n\\ncontract LoanDataFacet {\\n /**\\n * @notice Returns the information about the given {loanID}.\\n * @param loanID The loan ID to get information for.\\n * @return loan_ The loan data.\\n */\\n function getLoan(uint256 loanID) external view returns (Loan memory loan_) {\\n loan_ = LibLoans.s().loans[loanID];\\n }\\n\\n /**\\n * @notice DEPRECATED\\n * @notice Returns the terms for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanTerms The terms that the loan weer created with.\\n */\\n function getLoanTerms(uint256 loanID)\\n external\\n view\\n returns (LoanTerms memory)\\n {\\n return LibLoans.terms(loanID);\\n }\\n\\n /**\\n * @notice Returns the loan IDs created by the {borrower} account.\\n * @param borrower The account to get loan IDs for.\\n * @return loanIDs The IDs for loans created by the {borrower}\\n */\\n function getBorrowerLoans(address borrower)\\n external\\n view\\n returns (uint128[] memory loanIDs)\\n {\\n return LibLoans.s().borrowerLoans[borrower];\\n }\\n\\n /**\\n * @notice Returns the debt owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanDebt The principal and interest owed amount.\\n */\\n function getDebtOwed(uint256 loanID)\\n external\\n view\\n returns (LoanDebt memory)\\n {\\n return LibLoans.debt(loanID);\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) external view returns (uint256) {\\n return LibLoans.getTotalOwed(loanID);\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n external\\n view\\n returns (uint256)\\n {\\n return LibLoans.getInterestOwedFor(loanID, amountBorrow);\\n }\\n\\n /**\\n * @notice it returns the collateral needed for a loan\\n * @param loanID the identifier of the loan ID to retrieve collateral from\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n external\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n return LibLoans.getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the typed address of a loan escrow\\n * @param loanID the identifier of the respective escrow's loan\\n * @return escrow_ the typed address of the returned ILoanEscrow\\n */\\n function getLoanEscrow(uint256 loanID)\\n external\\n view\\n returns (address escrow_)\\n {\\n escrow_ = address(LibLoans.s().loanEscrows[loanID]);\\n }\\n\\n /**\\n * @notice it returns the escrow's total value by calculating the value all the escrow tokens\\n * @param loanID the identifier of the respective escrow's loan\\n * @return the total value of the loan escrow\\n */\\n function getLoanEscrowValue(uint256 loanID)\\n external\\n view\\n returns (uint256)\\n {\\n return LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n /**\\n * @notice it returns the total escrow tokens held by an escrow\\n * @param loanID the identifier of the respective escrow's loan\\n * @return tokens_ the tokens held at the escrow loan \\n */\\n function getEscrowTokens(uint256 loanID)\\n external\\n view\\n returns (address[] memory tokens_)\\n {\\n EnumerableSet.AddressSet storage escrowTokens =\\n LibEscrow.getEscrowTokens(loanID);\\n tokens_ = new address[](EnumerableSet.length(escrowTokens));\\n for (uint256 i; i < tokens_.length; i++) {\\n tokens_[i] = EnumerableSet.at(escrowTokens, i);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x9a57f5de00ce073af4ffb2f74e7d8a15e56bc017826f2c5a393ef5b64554145f\",\"license\":\"MIT\"},\"contracts/market/RepayFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\nimport {\\n ReentryMods\\n} from \\\"../contexts2/access-control/reentry/ReentryMods.sol\\\";\\nimport { AUTHORIZED } from \\\"../shared/roles.sol\\\";\\nimport { LoanDataFacet } from \\\"./LoanDataFacet.sol\\\";\\nimport { EscrowClaimTokens } from \\\"../escrow/EscrowClaimTokens.sol\\\";\\n\\n// Libraries\\nimport {\\n IERC20,\\n SafeERC20\\n} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibCollateral } from \\\"./libraries/LibCollateral.sol\\\";\\nimport { LibDapps } from \\\"../escrow/dapps/libraries/LibDapps.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { NumbersLib } from \\\"../shared/libraries/NumbersLib.sol\\\";\\nimport { PriceAggLib } from \\\"../price-aggregator/PriceAggLib.sol\\\";\\nimport { NFTLib } from \\\"../nft/libraries/NFTLib.sol\\\";\\n\\n// Interfaces\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus\\n} from \\\"../storage/market.sol\\\";\\n\\ncontract RepayFacet is RolesMods, ReentryMods, PausableMods, EscrowClaimTokens {\\n /**\\n @notice This event is emitted when a loan has been successfully repaid\\n @param loanID ID of loan from which collateral was withdrawn\\n @param borrower Account address of the borrower\\n @param amountPaid Amount of the loan paid back\\n @param payer Account address of the payer\\n @param totalOwed Total amount of the loan to be repaid\\n */\\n event LoanRepaid(\\n uint256 indexed loanID,\\n address indexed borrower,\\n uint256 amountPaid,\\n address payer,\\n uint256 totalOwed\\n );\\n\\n /**\\n * @notice This event is emitted when a loan has been successfully liquidated\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param borrower Account address of the borrower\\n * @param liquidator Account address of the liquidator\\n * @param reward Value in lending token paid out to liquidator\\n * @param tokensIn Percentage of the collateral price paid by the liquidator to the lending pool\\n */\\n event LoanLiquidated(\\n uint256 indexed loanID,\\n address indexed borrower,\\n address liquidator,\\n uint256 reward,\\n uint256 tokensIn\\n );\\n\\n /**\\n * @notice Repay this Escrow's loan.\\n * @dev If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.\\n * @dev Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\\n * @param loanID The id of the loan being used.\\n * @param amount The amount being repaid.\\n */\\n function escrowRepay(uint256 loanID, uint256 amount)\\n external\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n nonReentry(\\\"\\\")\\n {\\n uint256 balance =\\n LibEscrow.balanceOf(loanID, LibLoans.loan(loanID).lendingToken);\\n uint256 totalOwed = LibLoans.getTotalOwed(loanID);\\n // if there isn't enough balance in the escrow, then transfer amount needed to the escrow\\n if (balance < totalOwed && amount > balance) {\\n uint256 amountNeeded =\\n amount > totalOwed ? totalOwed - (balance) : amount - (balance);\\n\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n msg.sender,\\n address(LibEscrow.e(loanID)),\\n amountNeeded\\n );\\n }\\n\\n __repayLoan(loanID, amount, address(LibEscrow.e(loanID)), false);\\n }\\n\\n /**\\n * @notice Make a payment to a loan\\n * @param loanID The ID of the loan the payment is for\\n * @param amount The amount of tokens to pay back to the loan\\n */\\n function repayLoan(uint256 loanID, uint256 amount)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n __repayLoan(loanID, amount, msg.sender, false);\\n }\\n\\n /**\\n * @notice it repays the loan, either from an escrow or from a regular address\\n * @param loanID the identifier of the loan to repay\\n * @param amount the amount to repay the loan\\n * @param sender the address of the sender that wants to pay, can also be a loan escrow\\n * @param isLiquidation is this loan being liquidated?\\n * @return leftToPay_ the amount left to pay for the loan\\n */\\n function __repayLoan(\\n uint256 loanID,\\n uint256 amount,\\n address sender,\\n bool isLiquidation\\n ) private returns (uint256 leftToPay_) {\\n require(amount > 0, \\\"Teller: zero repay\\\");\\n\\n // calculate the actual amount to repay\\n leftToPay_ =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n if (leftToPay_ < amount) {\\n amount = leftToPay_;\\n leftToPay_ = 0;\\n } else {\\n leftToPay_ -= amount;\\n }\\n\\n // Get the Teller token for the loan\\n ITToken tToken =\\n MarketStorageLib.store().tTokens[\\n LibLoans.loan(loanID).lendingToken\\n ];\\n // Transfer funds from an escrow if an escrow is calling it\\n // Otherwise, transfer funds from an account\\n if (address(LibEscrow.e(loanID)) == sender) {\\n LibEscrow.e(loanID).claimToken(\\n LibLoans.loan(loanID).lendingToken,\\n address(tToken),\\n amount\\n );\\n } else {\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n sender,\\n address(tToken),\\n amount\\n );\\n }\\n\\n // Deduct the interest and principal owed\\n uint256 principalPaid;\\n uint256 interestPaid;\\n if (amount < LibLoans.debt(loanID).interestOwed) {\\n interestPaid = amount;\\n LibLoans.debt(loanID).interestOwed -= amount;\\n } else {\\n if (LibLoans.debt(loanID).interestOwed > 0) {\\n interestPaid = LibLoans.debt(loanID).interestOwed;\\n amount -= interestPaid;\\n LibLoans.debt(loanID).interestOwed = 0;\\n }\\n\\n if (amount > 0) {\\n principalPaid = amount;\\n LibLoans.debt(loanID).principalOwed -= amount;\\n }\\n }\\n\\n // Tell the Teller Token value has been deposited back into the pool.\\n tToken.repayLoan(principalPaid, interestPaid);\\n\\n if (isLiquidation) {\\n // Make sure there is nothing left to repay on the loan\\n require(leftToPay_ == 0, \\\"Teller: liquidate partial repay\\\");\\n\\n // Set loan status\\n LibLoans.loan(loanID).status = LoanStatus.Liquidated;\\n\\n // Transfer NFT if linked\\n NFTLib.liquidateNFT(loanID);\\n } else {\\n // if the loan is now fully paid, close it and withdraw borrower collateral\\n if (leftToPay_ == 0) {\\n LibLoans.loan(loanID).status = LoanStatus.Closed;\\n\\n // Check if the loan has a collateral token\\n if (LibLoans.loan(loanID).collateralToken != address(0)) {\\n LibCollateral.withdrawAll(\\n loanID,\\n LibLoans.loan(loanID).borrower\\n );\\n }\\n\\n // Claim tokens in the escrow for the loan if any\\n __claimEscrowTokens(loanID);\\n\\n // Restake any NFTs linked to loan for borrower\\n NFTLib.restakeLinked(loanID, LibLoans.loan(loanID).borrower);\\n }\\n\\n emit LoanRepaid(\\n loanID,\\n LibLoans.loan(loanID).borrower,\\n amount,\\n msg.sender,\\n leftToPay_\\n );\\n }\\n }\\n\\n /**\\n * @notice Liquidate a loan if it is expired or under collateralized\\n * @param loanID The ID of the loan to be liquidated\\n */\\n function liquidateLoan(uint256 loanID)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n uint256 collateralAmount = LibCollateral.e(loanID).loanSupply(loanID);\\n require(\\n RepayLib.isLiquidable(loanID, collateralAmount),\\n \\\"Teller: does not need liquidation\\\"\\n );\\n\\n // Calculate the reward before repaying the loan\\n (uint256 rewardInLending, uint256 collateralInLending) =\\n RepayLib.getLiquidationReward(loanID, collateralAmount);\\n\\n // The liquidator pays the amount still owed on the loan\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n __repayLoan(loanID, amountToLiquidate, msg.sender, true);\\n\\n // Payout the liquidator reward owed\\n if (rewardInLending > 0) {\\n RepayLib.payOutLiquidator(\\n loanID,\\n rewardInLending,\\n collateralInLending,\\n collateralAmount,\\n payable(msg.sender)\\n );\\n }\\n\\n emit LoanLiquidated(\\n loanID,\\n loan.borrower,\\n msg.sender,\\n rewardInLending,\\n amountToLiquidate\\n );\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @return inLending_ The value the liquidator will receive denoted in lending tokens.\\n * @return inCollateral_ The value the liquidator will receive denoted in collateral tokens.\\n */\\n function getLiquidationReward(uint256 loanID)\\n external\\n view\\n returns (uint256 inLending_, uint256 inCollateral_)\\n {\\n (inLending_, ) = RepayLib.getLiquidationReward(\\n loanID,\\n LibCollateral.e(loanID).loanSupply(loanID)\\n );\\n inCollateral_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n inLending_\\n );\\n }\\n}\\n\\nlibrary RepayLib {\\n /**\\n * @notice It checks if a loan can be liquidated.\\n * @param loanID The loan ID to check.\\n * @return true if the loan is liquidable.\\n */\\n function isLiquidable(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (bool)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n // Check if loan can be liquidated\\n if (loan.status != LoanStatus.Active) {\\n return false;\\n }\\n\\n if (loan.collateralRatio > 0) {\\n // If loan has a collateral ratio, check how much is needed\\n (, uint256 neededInCollateral, ) =\\n LoanDataFacet(address(this)).getCollateralNeededInfo(loanID);\\n if (neededInCollateral > collateralAmount) {\\n return true;\\n }\\n }\\n\\n // Otherwise, check if the loan has expired\\n return block.timestamp >= loan.loanStartTime + loan.duration;\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @param collateralAmount The amount of collateral for the {loanID}. Passed in to save gas calling the collateral escrow multiple times.\\n * @return reward_ The value the liquidator will receive denoted in lending tokens.\\n */\\n function getLiquidationReward(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (uint256 reward_, uint256 collateralValue_)\\n {\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n // Max reward is amount repaid on loan plus extra percentage\\n uint256 maxReward =\\n amountToLiquidate +\\n NumbersLib.percent(\\n amountToLiquidate,\\n uint16(PlatformSettingsLib.getLiquidateRewardPercent())\\n );\\n\\n // Calculate available collateral for reward\\n if (collateralAmount > 0) {\\n collateralValue_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).collateralToken,\\n LibLoans.loan(loanID).lendingToken,\\n collateralAmount\\n );\\n reward_ += collateralValue_;\\n }\\n\\n // Calculate loan escrow value if collateral not enough to cover reward\\n if (reward_ < maxReward) {\\n reward_ += LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n // Cap the reward to max\\n if (reward_ > maxReward) {\\n reward_ = maxReward;\\n }\\n }\\n\\n /**\\n * @notice Checks if the loan has an Escrow and claims any tokens then pays out the loan collateral.\\n * @dev See Escrow.claimTokens for more info.\\n * @param loanID The loan ID which is being liquidated\\n * @param rewardInLending The total amount of reward based in the lending token to pay the liquidator\\n * @param collateralInLending The amount of collateral that is available for the loan denoted in lending tokens\\n * @param collateralAmount The amount of collateral that is available for the loan\\n * @param liquidator The address of the liquidator where the liquidation reward will be sent to\\n */\\n function payOutLiquidator(\\n uint256 loanID,\\n uint256 rewardInLending,\\n uint256 collateralInLending,\\n uint256 collateralAmount,\\n address payable liquidator\\n ) internal {\\n // check if loan is liquidated\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Liquidated,\\n \\\"Teller: loan not liquidated\\\"\\n );\\n\\n // if the lending reward is less than the collateral lending tokens, then aggregate\\n // the value for the lending token with the collateral token and send it to the liquidator\\n if (rewardInLending <= collateralInLending) {\\n uint256 rewardInCollateral =\\n PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n rewardInLending\\n );\\n\\n LibCollateral.withdraw(loanID, rewardInCollateral, liquidator);\\n } else {\\n // Payout whats available in the collateral token\\n LibCollateral.withdraw(loanID, collateralAmount, liquidator);\\n\\n // Claim remaining reward value from the loan escrow\\n claimEscrowTokensByValue(\\n loanID,\\n liquidator,\\n rewardInLending - collateralInLending\\n );\\n }\\n }\\n\\n /**\\n * @dev Send the equivalent of tokens owned by the loan escrow (in lending value) to the recipient,\\n * @param loanID The loan ID to clam tokens from\\n * @param recipient address to send the tokens to\\n * @param value The value of escrow held tokens to be claimed based in lending value\\n */\\n function claimEscrowTokensByValue(\\n uint256 loanID,\\n address recipient,\\n uint256 value\\n ) private {\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n uint256 valueLeftToTransfer = value;\\n\\n // Start with the lending token\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n LibLoans.loan(loanID).lendingToken,\\n recipient,\\n valueLeftToTransfer\\n );\\n\\n // Cycle through remaining tokens\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n if (valueLeftToTransfer == 0) {\\n return;\\n }\\n\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n EnumerableSet.at(tokens, i),\\n recipient,\\n valueLeftToTransfer\\n );\\n }\\n }\\n\\n /**\\n * @notice it claims the escrow tokens for the liquidator\\n * @notice it keeps claiming escrow tokens until there aren't anymore tokens or the valueLeftToTransfer is zero\\n * @param loanID the identifier of the escrow loan to claim tokens from\\n * @param token the address of the token asset to claim\\n * @param recipient the address of the recipient to transfer the tokens to\\n * @param valueLeftToTransfer the value left to transfer to the liquidator that is returned back\\n * @return the value left to transfer\\n */\\n function claimEscrowToken(\\n uint256 loanID,\\n address token,\\n address recipient,\\n uint256 valueLeftToTransfer\\n ) private returns (uint256) {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n // get value of token balance in lending value\\n if (balance > 0) {\\n // If token not the lending token, get value of token\\n uint256 balanceInLending;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n balanceInLending = balance;\\n } else {\\n balanceInLending = PriceAggLib.valueFor(\\n token,\\n LibLoans.loan(loanID).lendingToken,\\n balance\\n );\\n }\\n\\n if (balanceInLending <= valueLeftToTransfer) {\\n LibEscrow.e(loanID).claimToken(token, recipient, balance);\\n valueLeftToTransfer -= balanceInLending;\\n } else {\\n // Token balance is more than enough so calculate ratio of balance to transfer\\n uint256 valueToTransfer;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n valueToTransfer = valueLeftToTransfer;\\n } else {\\n valueToTransfer = NumbersLib.percent(\\n balance,\\n NumbersLib.ratioOf(\\n valueLeftToTransfer,\\n balanceInLending\\n )\\n );\\n }\\n\\n LibEscrow.e(loanID).claimToken(\\n token,\\n recipient,\\n valueToTransfer\\n );\\n valueLeftToTransfer = 0;\\n }\\n }\\n return valueLeftToTransfer;\\n }\\n}\\n\",\"keccak256\":\"0xc440b61519f74c4eba549f1f531726b1cd8b3da60ba7654cccd4eb9bd9fd7020\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n /**\\n * @notice it initializes an escrow\\n * @param tokenAddress the address of the collateral token to be stored\\n * @param isWETH check if it's wrapped Ethereum\\n */\\n function init(address tokenAddress, bool isWETH) external;\\n\\n /**\\n * @notice it deposits an amount of the respective collateral token into the escrow\\n * @param loanID the ID of the loan\\n * @param amount the amount of collateral tokens to be deposited\\n */\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n /**\\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\\n * @dev only the TellerDiamond can make this call on behalf of the borrower\\n * @param loanID identifier of the loan\\n * @param amount number of collateral tokens to send\\n * @param receiver payable address to transfer money to\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n /**\\n * @notice it returns the supply of the respective loan\\n * @param loanID the respective loan ID\\n * @return supply_ the amount in collateral of the respective loan\\n */\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n /**\\n * @notice it returns the total supply of the collateral token held by the contract\\n * @return supply_ the total amount of collateral\\n */\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x900fed2311f919ba1451a6583ddbf9f3bc8afa8f5189500fff51f0c049258ed3\",\"license\":\"MIT\"},\"contracts/market/libraries/LibCollateral.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport { ICollateralEscrow } from \\\"../collateral/ICollateralEscrow.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\nimport { MarketStorageLib } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibCollateral {\\n /**\\n * @notice This event is emitted when collateral has been deposited for the loan\\n * @param loanID ID of the loan for which collateral was deposited\\n * @param depositor Account that deposited funds\\n * @param amount Amount of collateral deposited\\n */\\n event CollateralDeposited(\\n uint256 indexed loanID,\\n address indexed depositor,\\n uint256 amount\\n );\\n\\n /**\\n * @notice This event is emitted when collateral has been withdrawn\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param receiver Account that received funds\\n * @param amount Value of collateral withdrawn\\n */\\n event CollateralWithdrawn(\\n uint256 indexed loanID,\\n address indexed receiver,\\n uint256 amount\\n );\\n\\n /**\\n * @notice it gets MarketStorage's collateral escrow using the loanID\\n * @param loanID the loanID to be used\\n * @return c_ which is the collateral escrow\\n */\\n function e(uint256 loanID) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[\\n MarketStorageLib.store().loans[loanID].collateralToken\\n ];\\n }\\n\\n function e(address token) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[token];\\n }\\n\\n /**\\n * @notice it deposits an amount of collateral into a collateral escrow's address of a respective loan\\n * @param loanID the respective loan ID\\n * @param amount the amount of collateral to deposit\\n */\\n function deposit(uint256 loanID, uint256 amount) internal {\\n e(loanID).deposit{ value: amount }(loanID, amount);\\n\\n emit CollateralDeposited(loanID, msg.sender, amount);\\n }\\n\\n /**\\n * @notice it withdraws an amount from the collateral escrow\\n * @param loanID the respective loanID to withdraw from\\n * @param amount the number of collateral tokens to withdraw\\n * @param receiver the address who receives the withdrawal\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) internal {\\n e(loanID).withdraw(loanID, amount, receiver);\\n\\n emit CollateralWithdrawn(loanID, receiver, amount);\\n }\\n\\n /**\\n * @notice it withdraws the entire supply in collateral of a respective loan to an address\\n * @param loanID the respective loan's ID\\n * @param receiver the address of the receiver to withdraw tokens from\\n */\\n function withdrawAll(uint256 loanID, address payable receiver) internal {\\n withdraw(loanID, e(loanID).loanSupply(loanID), receiver);\\n }\\n\\n /**\\n * @notice it initializes a new escrow collateral to hold collateral tokens\\n * @param token address of the collateral token it holds\\n */\\n function createEscrow(address token) internal {\\n // Check if collateral escrow exists\\n if (address(e(token)) == address(0)) {\\n // Create escrow\\n address escrow =\\n AppStorageLib.store().collateralEscrowBeacon.cloneProxy(\\\"\\\");\\n ICollateralEscrow(escrow).init(\\n token,\\n // Check if collateral token is WETH\\n token == AppStorageLib.store().assetAddresses[\\\"WETH\\\"]\\n );\\n\\n // Set max allowance\\n IERC20(token).approve(escrow, type(uint256).max);\\n // Save escrow address for loan\\n MarketStorageLib.store().collateralEscrows[\\n token\\n ] = ICollateralEscrow(escrow);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x84dbab8283357a1cc4210e34642fc8247841a58973778f4f6570398cc3046947\",\"license\":\"MIT\"},\"contracts/market/libraries/LibLoans.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibEscrow } from \\\"../../escrow/libraries/LibEscrow.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus,\\n LoanDebt,\\n LoanTerms\\n} from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibLoans {\\n using NumbersLib for int256;\\n using NumbersLib for uint256;\\n\\n bytes32 internal constant ID = keccak256(\\\"LOANS\\\");\\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n * @notice it returns the loan\\n * @param loanID the ID of the respective loan\\n * @return l_ the loan \\n */\\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\\n l_ = s().loans[loanID];\\n }\\n\\n /**\\n * @notice it returns the loan debt from a respective loan\\n * @param loanID the ID of the respective loan\\n * @return d_ the loan debt from a respective loan\\n */\\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\\n d_ = s().loanDebt[loanID];\\n }\\n\\n // DEPRECATED\\n function terms(uint256 loanID)\\n internal\\n view\\n returns (LoanTerms storage t_)\\n {\\n t_ = s()._loanTerms[loanID];\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return owed_ uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID)\\n internal\\n view\\n returns (uint256 owed_)\\n {\\n if (loan(loanID).status == LoanStatus.Active) {\\n owed_ = debt(loanID).principalOwed + (debt(loanID).interestOwed);\\n }\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n internal\\n view\\n returns (uint256)\\n {\\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\\n }\\n \\n function getCollateralNeeded(uint256 loanID)\\n internal\\n view\\n returns (uint256 _needed)\\n {\\n (, _needed, ) = getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the total collateral needed in lending tokens, in collateral tokens and in escrowed loan values\\n * @param loanID the loanID to get the total collateral needed\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n internal\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\\n loanID\\n );\\n\\n // check if needed lending tokens is zero. if true, then needed collateral tokens is zero. else,\\n if (neededInLendingTokens == 0) {\\n neededInCollateralTokens = 0;\\n } else {\\n neededInCollateralTokens = PriceAggLib.valueFor(\\n loan(loanID).lendingToken,\\n loan(loanID).collateralToken,\\n neededInLendingTokens\\n );\\n }\\n }\\n\\n /**\\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\\n * @param loanID The loan ID to get needed collateral info for.\\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\\n */\\n function getCollateralNeededInTokens(uint256 loanID)\\n internal\\n view\\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\\n {\\n if (loan(loanID).collateralRatio == 0) {\\n return (0, 0);\\n }\\n\\n /*\\n The collateral to principal owed ratio is the sum of:\\n * collateral buffer percent\\n * loan interest rate\\n * liquidation reward percent\\n * X factor of additional collateral\\n */\\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n neededInLendingTokens = loan(loanID).borrowedAmount.percent(\\n loan(loanID).collateralRatio\\n );\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n uint16 requiredRatio =\\n loan(loanID).collateralRatio -\\n getInterestRatio(loanID) -\\n uint16(PlatformSettingsLib.getCollateralBufferValue());\\n\\n neededInLendingTokens =\\n debt(loanID).principalOwed +\\n debt(loanID).interestOwed;\\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\\n if (\\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\\n ) {\\n neededInLendingTokens -= escrowLoanValue;\\n }\\n neededInLendingTokens = neededInLendingTokens.percent(\\n requiredRatio\\n );\\n }\\n }\\n\\n /**\\n * @notice check if a loan can go to end of auction with a collateral ratio\\n * @return bool checking if collateralRatio is >= the over collateralized buffer value\\n */\\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\\n internal\\n view\\n returns (bool)\\n {\\n return\\n collateralRatio >=\\n PlatformSettingsLib.getOverCollateralizedBufferValue();\\n }\\n\\n /**\\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\\n * @notice There is a minimum threshold of 1%.\\n * @dev The interest rate is APY (annual percentage yield).\\n * @param loanID The loan ID to get the interest rate for.\\n */\\n function getInterestRatio(uint256 loanID)\\n internal\\n view\\n returns (uint16 ratio_)\\n {\\n ratio_ = uint16(\\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\\n SECONDS_PER_YEAR\\n );\\n\\n if (ratio_ == 0) {\\n ratio_ = 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0xe48b287a583b40e534654e4023422f59a9e6d7dd265d68ae4af43f8da58c09d9\",\"license\":\"MIT\"},\"contracts/nft/IStakeableNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IStakeableNFT {\\n function tokenBaseLoanSize(uint256 tokenId) external view returns (uint256);\\n\\n function tokenURIHash(uint256 tokenId)\\n external\\n view\\n returns (string memory);\\n\\n function tokenContributionAsset(uint256 tokenId)\\n external\\n view\\n returns (address);\\n\\n function tokenContributionSize(uint256 tokenId)\\n external\\n view\\n returns (uint256);\\n\\n function tokenContributionMultiplier(uint256 tokenId)\\n external\\n view\\n returns (uint8);\\n}\\n\",\"keccak256\":\"0xfbf44350ad91a54de26f39195d714580d7dade556ea4c7991a51eef5aa839105\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x417b75f5d92be67993efc54db7d453be5b5058a9a54d8916380e0281d3299526\",\"license\":\"MIT\"},\"contracts/nft/TellerNFTDictionary.sol\":{\"content\":\"/**\\n * @notice TellerNFTDictionary Version 1.02\\n *\\n * @notice This contract is used to gather data for TellerV1 NFTs more efficiently.\\n * @notice This contract has data which must be continuously synchronized with the TellerV1 NFT data\\n *\\n * @author develop@teller.finance\\n */\\n\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Interfaces\\nimport \\\"./IStakeableNFT.sol\\\";\\n\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFTDictionary is IStakeableNFT, AccessControlUpgradeable {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n mapping(uint256 => uint256) public baseLoanSizes;\\n mapping(uint256 => string[]) public hashes;\\n mapping(uint256 => address) public contributionAssets;\\n mapping(uint256 => uint256) public contributionSizes;\\n mapping(uint256 => uint8) public contributionMultipliers;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n\\n /* State Variables */\\n\\n mapping(uint256 => uint256) public _tokenTierMappingCompressed;\\n bool public _tokenTierMappingCompressedSet;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFTDictionary: not admin\\\");\\n _;\\n }\\n\\n function initialize(address initialAdmin) public {\\n _setupRole(ADMIN, initialAdmin);\\n _setRoleAdmin(ADMIN, ADMIN);\\n\\n __AccessControl_init();\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTierIndex(uint256 tokenId)\\n public\\n view\\n returns (uint8 index_)\\n {\\n //32 * 8 = 256 - each uint256 holds the data of 32 tokens . 8 bits each.\\n\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 compressedRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n //use 31 instead of 32 to account for the '0x' in the start.\\n //the '31 -' reverses our bytes order which is necessary\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint8 tierIndex = uint8((compressedRegister >> offset));\\n\\n return tierIndex;\\n }\\n\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory)\\n {\\n return hashes[tierIndex];\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTier(uint256 index, Tier memory newTier)\\n external\\n onlyAdmin\\n returns (bool)\\n {\\n baseLoanSizes[index] = newTier.baseLoanSize;\\n hashes[index] = newTier.hashes;\\n contributionAssets[index] = newTier.contributionAsset;\\n contributionSizes[index] = newTier.contributionSize;\\n contributionMultipliers[index] = newTier.contributionMultiplier;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param tiersMapping Information about the new tiers to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setAllTokenTierMappings(uint256[] memory tiersMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n require(\\n !_tokenTierMappingCompressedSet,\\n \\\"TellerNFTDictionary: token tier mapping already set\\\"\\n );\\n for (uint256 i = 0; i < tiersMapping.length; i++) {\\n _tokenTierMappingCompressed[i] = tiersMapping[i];\\n }\\n\\n _tokenTierMappingCompressedSet = true;\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param index the mapping row, each holds data for 32 tokens\\n * @param tierMapping Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierMapping(uint256 index, uint256 tierMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n _tokenTierMappingCompressed[index] = tierMapping;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenIds the NFT token Ids for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenIds(\\n uint256[] calldata tokenIds,\\n uint256 tokenTier\\n ) public onlyAdmin returns (bool) {\\n for (uint256 i; i < tokenIds.length; i++) {\\n setTokenTierForTokenId(tokenIds[i], tokenTier);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenId the NFT token Id for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenId(uint256 tokenId, uint256 tokenTier)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 existingRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint256 updateMaskShifted =\\n 0x00000000000000000000000000000000000000000000000000000000000000FF <<\\n offset;\\n\\n uint256 updateMaskShiftedNegated = ~updateMaskShifted;\\n\\n uint256 tokenTierShifted =\\n ((0x0000000000000000000000000000000000000000000000000000000000000000 |\\n tokenTier) << offset);\\n\\n uint256 existingRegisterClearedWithMask =\\n existingRegister & updateMaskShiftedNegated;\\n\\n uint256 updatedRegister =\\n existingRegisterClearedWithMask | tokenTierShifted;\\n\\n _tokenTierMappingCompressed[mappingIndex] = updatedRegister;\\n\\n return true;\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(IStakeableNFT).interfaceId ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n New methods for the dictionary\\n */\\n\\n /**\\n * @notice It returns Base Loan Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenBaseLoanSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return baseLoanSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Token URI Hash for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenURIHash(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n string[] memory tierImageHashes = hashes[tokenTier];\\n return tierImageHashes[tokenId % (tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice It returns Contribution Asset for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionAsset(uint256 tokenId)\\n public\\n view\\n override\\n returns (address)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionAssets[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Multiplier for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionMultiplier(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint8)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionMultipliers[tokenTier];\\n }\\n}\\n\",\"keccak256\":\"0xf33e3fa1f609fdd2abb3b5fb9c232269d13363a3e4fa5697ea96269e361e74fa\"},\"contracts/nft/libraries/NFTLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../TellerNFT.sol\\\";\\n\\n// Libraries\\nimport {\\n MerkleProof\\n} from \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\nimport { NFTStorageLib, NFTStorage } from \\\"../../storage/nft.sol\\\";\\n\\nlibrary NFTLib {\\n function s() internal pure returns (NFTStorage storage s_) {\\n s_ = NFTStorageLib.store();\\n }\\n\\n function nft() internal view returns (TellerNFT nft_) {\\n nft_ = AppStorageLib.store().nft;\\n }\\n\\n /**s\\n * @notice it transfers the NFT from the sender to the diamond to stake then adds the NFTID to the list of the owner's stakedNFTs\\n * @param nftID the ID of the NFT to stake\\n * @param owner the owner of the NFT who will stake the NFT\\n */\\n function stake(uint256 nftID, address owner) internal {\\n // Transfer to diamond\\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\\n // Add NFT ID to user set\\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\\n }\\n\\n /**\\n * @notice it unstakes the NFT by removing the NFT ID from the list of the user's staked NFTs\\n * @param nftID the ID of the NFT to remove from the list of the user's staked NFTs\\n * @return success_ the boolean value telling us if the user has unsuccessfully unstaked the NFT\\n */\\n function unstake(uint256 nftID) internal returns (bool success_) {\\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\\n }\\n\\n /**\\n * @notice it gets the list of staked NFTs from the owner\\n * @param nftOwner the owner of the staked NFTs to pull from\\n * @return staked_ the array of the staked NFTs owned by the user\\n */\\n function stakedNFTs(address nftOwner)\\n internal\\n view\\n returns (uint256[] memory staked_)\\n {\\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\\n staked_ = new uint256[](EnumerableSet.length(nfts));\\n for (uint256 i; i < staked_.length; i++) {\\n staked_[i] = EnumerableSet.at(nfts, i);\\n }\\n }\\n\\n /**\\n * @notice if the user fails to pay his loan, then we liquidate the all the NFTs associated with the loan\\n * @param loanID the identifier of the loan to liquidate the NFTs from\\n */\\n function liquidateNFT(uint256 loanID) internal {\\n // Check if NFTs are linked\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n NFTLib.nft().transferFrom(\\n address(this),\\n AppStorageLib.store().nftLiquidationController,\\n EnumerableSet.at(nfts, i)\\n );\\n }\\n }\\n\\n /**\\n * @notice it unstakes an NFT and verifies the proof in order to apply the proof to a loan\\n * @param loanID the identifier of the loan\\n * @param nftID the NFT ID to apply to the loan\\n */\\n function applyToLoan(uint256 loanID, uint256 nftID) internal {\\n // NFT must be currently staked\\n // Remove NFT from being staked - returns bool\\n require(unstake(nftID), \\\"Teller: borrower nft not staked\\\");\\n\\n // Apply NFT to loan\\n EnumerableSet.add(s().loanNFTs[loanID], nftID);\\n }\\n\\n /**\\n * @notice it finds the loan's NFTs and adds them back to the owner's list of staked NFTs\\n * @param loanID the identifier of the respective loan to add the NFTs back to the user's staked NFTs\\n * @param owner the owner to add the unstaked NFTs back to the staked pile\\n */\\n function restakeLinked(uint256 loanID, address owner) internal {\\n // Get linked NFT\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n // Restake the NFT\\n EnumerableSet.add(s().stakedNFTs[owner], EnumerableSet.at(nfts, i));\\n }\\n }\\n}\\n\",\"keccak256\":\"0xccbd35c6e8d0130b38f5025ee81c47d55e4fa48c8fcb8bec6f70c21061e0ce61\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n /**\\n * @notice it returns 10^{numberOfDecimals} for a token\\n * @param token the address to calculate the decimals for\\n * @return 10^number of decimals used to calculate the price and value of different token pairs\\n */\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @notice It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @notice it tries to calculate a price from Compound and Chainlink.\\n * @dev if no price is found on compound, then calculate it on chainlink\\n * @param src the token address to calculate the price for in dst\\n * @param dst the token address to retrieve the price of src\\n * @return price_ the price of src in dst\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n * @param src the address of the src token\\n * @param dst the address of the dst token\\n * @return the price of the src token in dst token\\n\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n * @param src the source token to calculate price for with chainlink\\n * @param dst the destination token to calculate price for with chainlink\\n * @param cRate the compound rate to multiply with the price of the dst token\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @notice Scales the {value} by the difference in decimal values.\\n * @param value the the value of the src in dst\\n * @param srcDecimals src token decimals\\n * @param dstDecimals dst token decimals\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @notice it tries to calculate the price of {src} in {dst}\\n * @param src address of source token\\n * @param dst address of destination token\\n * @return the price of src token in dst\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address WETH = AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n if (dst != WETH) {\\n int256 price1 = _priceFor(src, WETH);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, WETH);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice it checks if a token is a cToken. If it is, then get the underlying address\\n * @param token address of the token\\n * @return isCToken boolean whether it's a cToken\\n * @return underlying the address of the cToken\\n */\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2efb3d71a1c0fb49f8c455c4fa30d04c69a1617d619035fc400dabdeb2ab0c9e\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { PriceAggFacet } from \\\"./PriceAggFacet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\n/**\\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\\n */\\nlibrary PriceAggLib {\\n /**\\n * @notice It calculates the value of one token amount into another\\n * @param src the source token\\n * @param dst the destination token\\n * @param srcAmount the amount of source token\\n * @return value_ the returned value of src in dst\\n */\\n function valueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) internal view returns (uint256 value_) {\\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\\n }\\n\\n /**\\n * @notice It returns the price of the token pair as given from Compound.\\n * @dev if no compound price is calculated, then it checks Chainlink price Aggregator\\n * @param src the address of the source token\\n * @param dst the address of the desitnation token\\n * @return price_ gets the price of src in dst\\n */\\n function priceFor(address src, address dst)\\n internal\\n view\\n returns (int256 price_)\\n {\\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\\n }\\n}\\n\",\"keccak256\":\"0xff59eee567fa4a7f5cac432e31d918be92834f04614f49572d3984a5b030ac79\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\nabstract contract PausableMods {\\n /**\\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\\n * @param id id of the facet to check if is paused.\\n * @param state Boolean that the protocol AND facet should be in.\\n */\\n modifier paused(bytes32 id, bool state) {\\n require(\\n __isPaused(\\\"\\\") == state && __isPaused(id) == state,\\n __pausedMessage(state)\\n );\\n _;\\n }\\n\\n /**\\n * @dev Checks if the given id is paused.\\n * @param id Encoded id of the facet to check if is paused.\\n * @return the bool to tell us if the facet is paused (true) or not (false)\\n */\\n function __isPaused(bytes32 id) private view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n\\n /**\\n * @dev Gets the message that should be reverted with given a state it should be in.\\n * @param state Boolean that an id should be in.\\n * @return a message stating whether the facet is paused or not\\n */\\n function __pausedMessage(bool state) private pure returns (string memory) {\\n return state ? \\\"Pausable: not paused\\\" : \\\"Pausable: paused\\\";\\n }\\n}\\n\",\"keccak256\":\"0x2d3f848ee56ae5fa365539c2509c03c167affc89c89f98bb98cb9b83fbe8ae4c\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"NFTInterestRate\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getNFTInterestRate() internal view returns (uint16 value_) {\\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0x44294be1af9f913b2ed391a40cd4b646537a4b463b8d5ff1fac8ead3988966c1\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for loans taken out with an NFT.\\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\\n */\\nbytes32 constant NFT_INTEREST_RATE = keccak256(\\\"NFTInterestRate\\\");\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xd68a7df42b2bbba6f935d5890b7b37997c1432e25ae113827b8bde87f94fd86f\",\"license\":\"MIT\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n /**\\n * @notice Checks if the account should be allowed to mint tokens in the given market\\n * @param cToken The market to verify the mint against\\n * @param minter The account which would get the minted tokens\\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates mint and reverts on rejection. May emit logs.\\n * @param cToken Asset being minted\\n * @param minter The address minting the tokens\\n * @param mintAmount The amount of the underlying asset being minted\\n * @param mintTokens The number of tokens being minted\\n */\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to redeem tokens in the given market\\n * @param cToken The market to verify the redeem against\\n * @param redeemer The account which would redeem the tokens\\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates redeem and reverts on rejection. May emit logs.\\n * @param cToken Asset being redeemed\\n * @param redeemer The address redeeming the tokens\\n * @param redeemAmount The amount of the underlying asset being redeemed\\n * @param redeemTokens The number of tokens being redeemed\\n */\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\\n * @param cToken The market to verify the borrow against\\n * @param borrower The account which would borrow the asset\\n * @param borrowAmount The amount of underlying the account would borrow\\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates borrow and reverts on rejection. May emit logs.\\n * @param cToken Asset whose underlying is being borrowed\\n * @param borrower The address borrowing the underlying\\n * @param borrowAmount The amount of the underlying asset requested to borrow\\n */\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to repay a borrow in the given market\\n * @param cToken The market to verify the repay against\\n * @param payer The account which would repay the asset\\n * @param borrower The account which would borrowed the asset\\n * @param repayAmount The amount of the underlying asset the account would repay\\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\\n * @param cToken Asset being repaid\\n * @param payer The address repaying the borrow\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param borrowerIndex the index of the borrower\\n */\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n /**\\n * @notice Checks if the liquidation should be allowed to occur\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n */\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the seizing of assets should be allowed to occur\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates seize and reverts on rejection. May emit logs.\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to transfer tokens in the given market\\n * @param cToken The market to verify the transfer against\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates transfer and reverts on rejection. May emit logs.\\n * @param cToken Asset being transferred\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n */\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in all markets\\n * @param holder The address to claim COMP for\\n */\\n function claimComp(address holder) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in the specified markets\\n * @param holder The address to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n */\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n /**\\n * @notice Claim all comp accrued by the holders\\n * @param holders The addresses to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n * @param borrowers Whether or not to claim COMP earned by borrowing\\n * @param suppliers Whether or not to claim COMP earned by supplying\\n */\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n /**\\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\\n * @param cTokenBorrowed The address of the borrowed cToken\\n * @param cTokenCollateral The address of the collateral cToken\\n * @param repayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\\n */\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n /**\\n * @notice Return the address of the COMP token\\n * @return The address of COMP\\n */\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x38a824a4a21ce9370fa581a616d1bb9d311f27d8982a6b96ebeba90bd5fd0adb\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n \\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x37849041e4bee2dfa825677f69078521fcc94804aa5120f67dd12cc4133efcec\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @dev CETH is the only Compound token that does not support the {underlying} function.\\n * @param cToken address of the compound token\\n * @return address of the underlying cToken\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x99206384c27b0e68b1ec7b82260f6a47965f611875c018bc076ff8a688a6c6d7\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n /**\\n * @notice it returns the absolute number of a specified parameter\\n * @param self the number to be returned in it's absolute \\n * @return the absolute number\\n */\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0xa852b8866a3d6d928c6575bf2bcf2ae784eed73717c78c0cadbdedf8b0ba3274\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0c52fdd76b33f74e233c3a27dd3b73b134e9643aab347b3aa649c504809c6559\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\n// DEPRECATED\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\nstruct LoanRequest {\\n LoanUserRequest request;\\n LoanConsensusResponse[] responses;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanUserRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanConsensusResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) _loanTerms; // DEPRECATED: DO NOT REMOVE\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb7e05aeec806b5621512def93f4a389b4ef88c50ef9fe7115a33f57db2f2304b\",\"license\":\"MIT\"},\"contracts/storage/nft.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"../nft/TellerNFTDictionary.sol\\\";\\n\\n// Utils\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct NFTStorage {\\n // Maps NFT owner to set of token IDs owned\\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\\n // Maps loanID to NFT IDs indicating NFT being used for the loan\\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\\n // Merkle root used for verifying nft IDs to base loan size\\n TellerNFTDictionary nftDictionary;\\n}\\n\\nbytes32 constant NFT_STORAGE_POS = keccak256(\\\"teller.staking.storage\\\");\\n\\nlibrary NFTStorageLib {\\n function store() internal pure returns (NFTStorage storage s) {\\n bytes32 pos = NFT_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd44f213be3125ea2e2de120c241832f1861be18b3ff2fd4c3baa52ea20b94812\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", - "bytecode": "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", - "deployedBytecode": "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", + "solcInputHash": "151024dde4edc20ecc11a6b585cef1b4", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"liquidator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"reward\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokensIn\",\"type\":\"uint256\"}],\"name\":\"LoanLiquidated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountPaid\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"totalOwed\",\"type\":\"uint256\"}],\"name\":\"LoanRepaid\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"}],\"name\":\"TokensClaimed\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"claimTokens\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"escrowRepay\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLiquidationReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"inLending_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"inCollateral_\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"liquidateLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"repayLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"params\":{\"borrower\":\"Account address of the borrower\",\"liquidator\":\"Account address of the liquidator\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"reward\":\"Value in lending token paid out to liquidator\",\"tokensIn\":\"Percentage of the collateral price paid by the liquidator to the lending pool\"}},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"params\":{\"amountPaid\":\"Amount of the loan paid back\",\"borrower\":\"Account address of the borrower\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"payer\":\"Account address of the payer\",\"totalOwed\":\"Total amount of the loan to be repaid\"}}},\"kind\":\"dev\",\"methods\":{\"claimTokens(uint256)\":{\"params\":{\"loanID\":\"The id of the loan being used.\"}},\"escrowRepay(uint256,uint256)\":{\"details\":\"If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\",\"params\":{\"amount\":\"The amount being repaid.\",\"loanID\":\"The id of the loan being used.\"}},\"getLiquidationReward(uint256)\":{\"params\":{\"loanID\":\"The loan ID to get the info.\"},\"returns\":{\"inCollateral_\":\"The value the liquidator will receive denoted in collateral tokens.\",\"inLending_\":\"The value the liquidator will receive denoted in lending tokens.\"}},\"liquidateLoan(uint256)\":{\"params\":{\"loanID\":\"The ID of the loan to be liquidated\"}},\"repayLoan(uint256,uint256)\":{\"params\":{\"amount\":\"The amount of tokens to pay back to the loan\",\"loanID\":\"The ID of the loan the payment is for\"}}},\"version\":1},\"userdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully liquidated\"},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully repaid\"},\"TokensClaimed(address)\":{\"notice\":\"Notifies when the Escrow's tokens have been claimed.\"}},\"kind\":\"user\",\"methods\":{\"claimTokens(uint256)\":{\"notice\":\"Sends the tokens owned by this escrow to the owner.\"},\"escrowRepay(uint256,uint256)\":{\"notice\":\"Repay this Escrow's loan.\"},\"getLiquidationReward(uint256)\":{\"notice\":\"It gets the current liquidation reward for a given loan.\"},\"liquidateLoan(uint256)\":{\"notice\":\"Liquidate a loan if it is expired or under collateralized\"},\"repayLoan(uint256,uint256)\":{\"notice\":\"Make a payment to a loan\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/market/RepayFacet.sol\":\"RepayFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Trees proofs.\\n *\\n * The proofs can be generated using the JavaScript library\\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\\n *\\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n bytes32 computedHash = leaf;\\n\\n for (uint256 i = 0; i < proof.length; i++) {\\n bytes32 proofElement = proof[i];\\n\\n if (computedHash <= proofElement) {\\n // Hash(current computed hash + current element of the proof)\\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\\n } else {\\n // Hash(current element of the proof + current computed hash)\\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\\n }\\n }\\n\\n // Check if the computed hash (root) is equal to the provided root\\n return computedHash == root;\\n }\\n}\\n\",\"keccak256\":\"0xeee34bfb413657b6cd6c8e1e15c2080ba5ebaac479578515922804346fb63f7c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/reentry/ReentryMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nabstract contract ReentryMods {\\n modifier nonReentry(bytes32 id) {\\n AccessControlStorage storage s = AccessControlStorageLib.store();\\n require(!s.entered[id], \\\"AccessControl: reentered\\\");\\n s.entered[id] = true;\\n _;\\n s.entered[id] = false;\\n }\\n}\\n\",\"keccak256\":\"0x033c1164af25ef7d35a38a60973bf379b1cc603596914ffd85dcbcf0acdb6970\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/EscrowClaimTokens.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\n\\n// Interfaces\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, LoanStatus } from \\\"../storage/market.sol\\\";\\n\\n// Libraries\\nimport { LibLoans } from \\\"../market/libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"./libraries/LibEscrow.sol\\\";\\n\\n/**\\n * @notice Contains functionality to claim tokens that are in an escrow contract for a loan.\\n */\\ncontract EscrowClaimTokens is PausableMods {\\n /**\\n * @notice Notifies when the Escrow's tokens have been claimed.\\n * @param recipient address where the tokens where sent to.\\n */\\n event TokensClaimed(address recipient);\\n\\n /**\\n * @notice Sends the tokens owned by this escrow to the owner.\\n * @param loanID The id of the loan being used.\\n */\\n function claimTokens(uint256 loanID) external paused(\\\"\\\", false) {\\n require(\\n LibLoans.loan(loanID).borrower == msg.sender,\\n \\\"Teller: claim not borrower\\\"\\n );\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Closed,\\n \\\"Teller: loan not closed\\\"\\n );\\n\\n __claimEscrowTokens(loanID);\\n }\\n\\n function __claimEscrowTokens(uint256 loanID) internal {\\n __claimToken(loanID, LibLoans.loan(loanID).lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n __claimToken(loanID, EnumerableSet.at(tokens, i));\\n }\\n\\n emit TokensClaimed(msg.sender);\\n }\\n\\n function __claimToken(uint256 loanID, address token) private {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n if (balance > 0) {\\n LibEscrow.e(loanID).claimToken(\\n token,\\n LibLoans.loan(loanID).borrower,\\n balance\\n );\\n }\\n }\\n}\\n\",\"keccak256\":\"0xae189ea2a13c10f013f255f98ec50f34466c375bd7503275587d6abe5d25696c\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../interfaces/IAToken.sol\\\";\\nimport { IAaveLendingPool } from \\\"../interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x8030b206c87d0073fb7dbebfa2ee8a3e93c479d976d6cdaa0c939f2fedaa1525\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n /**\\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\\n * @param dappAddress address of the target contract address\\n * @param dappData encoded abi of the function in our contract we want to call\\n * @return the called data in bytes\\n */\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n /**\\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\\n * @param token address of the respective ERC20 token to approve for the spender\\n * @param spender address of the respective spender who is approved by the token contract\\n */\\n function setTokenAllowance(address token, address spender) external;\\n\\n /**\\n * @notice it allows user to claim their escrow tokens\\n * @dev only the owner (TellerDiamond) can make this call on behalf of the users\\n * @param token address of the respective token contract to claim tokens from\\n * @param to address where the tokens should be transferred to\\n * @param amount uint256 amount of tokens to be claimed\\n */\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xaf67fc4454ffaa4d2f7e46fe7101876e8ebdb1a5426c30f87b8e18cc573ac019\",\"license\":\"MIT\"},\"contracts/escrow/libraries/LibEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibDapps } from \\\"../dapps/libraries/LibDapps.sol\\\";\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibEscrow {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\\n e_ = s().loanEscrows[loanID];\\n }\\n\\n function exists(uint256 loanID) internal view returns (bool) {\\n return address(e(loanID)) != address(0);\\n }\\n\\n /**\\n * @notice It returns a list of tokens owned by a loan escrow\\n * @param loanID uint256 index used to return our token list\\n * @return t_ which is a list of tokens\\n */\\n function getEscrowTokens(uint256 loanID)\\n internal\\n view\\n returns (EnumerableSet.AddressSet storage t_)\\n {\\n t_ = s().escrowTokens[loanID];\\n }\\n\\n /**\\n * @notice It returns the balance of a respective token in a loan escrow\\n * @param loanID uint256 index used to point to our loan escrow\\n * @param token address of respective token to give us the balance of in our loan escrow\\n * @return uint256 balance of respective token returned in an escrow loan\\n */\\n function balanceOf(uint256 loanID, address token)\\n internal\\n view\\n returns (uint256)\\n {\\n return exists(loanID) ? IERC20(token).balanceOf(address(e(loanID))) : 0;\\n }\\n\\n /**\\n * @notice Adds or removes tokens held by the Escrow contract\\n * @param loanID The loan ID to update the token list for\\n * @param tokenAddress The token address to be added or removed\\n */\\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\\n // Skip if is lending token\\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\\n\\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\\n if (balanceOf(loanID, tokenAddress) > 0) {\\n if (!contains) {\\n EnumerableSet.add(tokens, tokenAddress);\\n }\\n } else if (contains) {\\n EnumerableSet.remove(tokens, tokenAddress);\\n }\\n }\\n\\n /**\\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\\n * @param loanID The loan ID to calculate value for\\n * @return value_ Escrow total value denoted in the lending token.\\n */\\n function calculateTotalValue(uint256 loanID)\\n internal\\n view\\n returns (uint256 value_)\\n {\\n if (!exists(loanID)) {\\n return 0;\\n }\\n\\n address lendingToken = LibLoans.loan(loanID).lendingToken;\\n value_ += balanceOf(loanID, lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\\n if (EnumerableSet.length(tokens) > 0) {\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n uint256 tokenBal =\\n balanceOf(loanID, EnumerableSet.at(tokens, i));\\n value_ += PriceAggLib.valueFor(\\n EnumerableSet.at(tokens, i),\\n lendingToken,\\n tokenBal\\n );\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x9ef96410fb3d580843e005cd632174cbcec9860dc04bc949fb56e4637cc95062\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when a user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when a user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n * @return ERC20 token\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n * @return balance_ the balance of the account\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice It calculates the total supply of the underlying asset.\\n * @return totalSupply_ the total supply denoted in the underlying asset.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given market.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n \\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfill the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n * @return mintAmount_ the amount minted of the specified token\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n * @return address of the strategy contract\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n * @param state boolean value that resembles the platform's state\\n */\\n function restrict(bool state) external virtual;\\n\\n /**\\n * @notice it initializes the Teller Token\\n * @param admin address of the admin to the respective Teller Token\\n * @param underlying address of the ERC20 token\\n */\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xf30ac4ef491851477ff9a3dd04974ebe74b529c37a3ef4e05798c3f734ceeb3d\",\"license\":\"MIT\"},\"contracts/market/LoanDataFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { Loan, LoanDebt, LoanTerms } from \\\"../storage/market.sol\\\";\\n\\ncontract LoanDataFacet {\\n /**\\n * @notice Returns the information about the given {loanID}.\\n * @param loanID The loan ID to get information for.\\n * @return loan_ The loan data.\\n */\\n function getLoan(uint256 loanID) external view returns (Loan memory loan_) {\\n loan_ = LibLoans.s().loans[loanID];\\n }\\n\\n /**\\n * @notice DEPRECATED\\n * @notice Returns the terms for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanTerms The terms that the loan weer created with.\\n */\\n function getLoanTerms(uint256 loanID)\\n external\\n view\\n returns (LoanTerms memory)\\n {\\n return LibLoans.terms(loanID);\\n }\\n\\n /**\\n * @notice Returns the loan IDs created by the {borrower} account.\\n * @param borrower The account to get loan IDs for.\\n * @return loanIDs The IDs for loans created by the {borrower}\\n */\\n function getBorrowerLoans(address borrower)\\n external\\n view\\n returns (uint128[] memory loanIDs)\\n {\\n return LibLoans.s().borrowerLoans[borrower];\\n }\\n\\n /**\\n * @notice Returns the debt owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanDebt The principal and interest owed amount.\\n */\\n function getDebtOwed(uint256 loanID)\\n external\\n view\\n returns (LoanDebt memory)\\n {\\n return LibLoans.debt(loanID);\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) external view returns (uint256) {\\n return LibLoans.getTotalOwed(loanID);\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n external\\n view\\n returns (uint256)\\n {\\n return LibLoans.getInterestOwedFor(loanID, amountBorrow);\\n }\\n\\n /**\\n * @notice it returns the collateral needed for a loan\\n * @param loanID the identifier of the loan ID to retrieve collateral from\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n external\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n return LibLoans.getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the typed address of a loan escrow\\n * @param loanID the identifier of the respective escrow's loan\\n * @return escrow_ the typed address of the returned ILoanEscrow\\n */\\n function getLoanEscrow(uint256 loanID)\\n external\\n view\\n returns (address escrow_)\\n {\\n escrow_ = address(LibLoans.s().loanEscrows[loanID]);\\n }\\n\\n /**\\n * @notice it returns the escrow's total value by calculating the value all the escrow tokens\\n * @param loanID the identifier of the respective escrow's loan\\n * @return the total value of the loan escrow\\n */\\n function getLoanEscrowValue(uint256 loanID)\\n external\\n view\\n returns (uint256)\\n {\\n return LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n /**\\n * @notice it returns the total escrow tokens held by an escrow\\n * @param loanID the identifier of the respective escrow's loan\\n * @return tokens_ the tokens held at the escrow loan \\n */\\n function getEscrowTokens(uint256 loanID)\\n external\\n view\\n returns (address[] memory tokens_)\\n {\\n EnumerableSet.AddressSet storage escrowTokens =\\n LibEscrow.getEscrowTokens(loanID);\\n tokens_ = new address[](EnumerableSet.length(escrowTokens));\\n for (uint256 i; i < tokens_.length; i++) {\\n tokens_[i] = EnumerableSet.at(escrowTokens, i);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x9a57f5de00ce073af4ffb2f74e7d8a15e56bc017826f2c5a393ef5b64554145f\",\"license\":\"MIT\"},\"contracts/market/RepayFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\nimport {\\n ReentryMods\\n} from \\\"../contexts2/access-control/reentry/ReentryMods.sol\\\";\\nimport { AUTHORIZED } from \\\"../shared/roles.sol\\\";\\nimport { LoanDataFacet } from \\\"./LoanDataFacet.sol\\\";\\nimport { EscrowClaimTokens } from \\\"../escrow/EscrowClaimTokens.sol\\\";\\n\\n// Libraries\\nimport {\\n IERC20,\\n SafeERC20\\n} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibCollateral } from \\\"./libraries/LibCollateral.sol\\\";\\nimport { LibDapps } from \\\"../escrow/dapps/libraries/LibDapps.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { NumbersLib } from \\\"../shared/libraries/NumbersLib.sol\\\";\\nimport { PriceAggLib } from \\\"../price-aggregator/PriceAggLib.sol\\\";\\nimport { NFTLib } from \\\"../nft/libraries/NFTLib.sol\\\";\\n\\n// Interfaces\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus\\n} from \\\"../storage/market.sol\\\";\\n\\ncontract RepayFacet is RolesMods, ReentryMods, PausableMods, EscrowClaimTokens {\\n /**\\n @notice This event is emitted when a loan has been successfully repaid\\n @param loanID ID of loan from which collateral was withdrawn\\n @param borrower Account address of the borrower\\n @param amountPaid Amount of the loan paid back\\n @param payer Account address of the payer\\n @param totalOwed Total amount of the loan to be repaid\\n */\\n event LoanRepaid(\\n uint256 indexed loanID,\\n address indexed borrower,\\n uint256 amountPaid,\\n address payer,\\n uint256 totalOwed\\n );\\n\\n /**\\n * @notice This event is emitted when a loan has been successfully liquidated\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param borrower Account address of the borrower\\n * @param liquidator Account address of the liquidator\\n * @param reward Value in lending token paid out to liquidator\\n * @param tokensIn Percentage of the collateral price paid by the liquidator to the lending pool\\n */\\n event LoanLiquidated(\\n uint256 indexed loanID,\\n address indexed borrower,\\n address liquidator,\\n uint256 reward,\\n uint256 tokensIn\\n );\\n\\n /**\\n * @notice Repay this Escrow's loan.\\n * @dev If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.\\n * @dev Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\\n * @param loanID The id of the loan being used.\\n * @param amount The amount being repaid.\\n */\\n function escrowRepay(uint256 loanID, uint256 amount)\\n external\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n nonReentry(\\\"\\\")\\n {\\n uint256 balance =\\n LibEscrow.balanceOf(loanID, LibLoans.loan(loanID).lendingToken);\\n uint256 totalOwed = LibLoans.getTotalOwed(loanID);\\n // if there isn't enough balance in the escrow, then transfer amount needed to the escrow\\n if (balance < totalOwed && amount > balance) {\\n uint256 amountNeeded =\\n amount > totalOwed ? totalOwed - (balance) : amount - (balance);\\n\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n msg.sender,\\n address(LibEscrow.e(loanID)),\\n amountNeeded\\n );\\n }\\n\\n __repayLoan(loanID, amount, address(LibEscrow.e(loanID)), false);\\n }\\n\\n /**\\n * @notice Make a payment to a loan\\n * @param loanID The ID of the loan the payment is for\\n * @param amount The amount of tokens to pay back to the loan\\n */\\n function repayLoan(uint256 loanID, uint256 amount)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n __repayLoan(loanID, amount, msg.sender, false);\\n }\\n\\n /**\\n * @notice it repays the loan, either from an escrow or from a regular address\\n * @param loanID the identifier of the loan to repay\\n * @param amount the amount to repay the loan\\n * @param sender the address of the sender that wants to pay, can also be a loan escrow\\n * @param isLiquidation is this loan being liquidated?\\n * @return leftToPay_ the amount left to pay for the loan\\n */\\n function __repayLoan(\\n uint256 loanID,\\n uint256 amount,\\n address sender,\\n bool isLiquidation\\n ) private returns (uint256 leftToPay_) {\\n require(amount > 0, \\\"Teller: zero repay\\\");\\n\\n // calculate the actual amount to repay\\n leftToPay_ =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n if (leftToPay_ < amount) {\\n amount = leftToPay_;\\n leftToPay_ = 0;\\n } else {\\n leftToPay_ -= amount;\\n }\\n\\n // Get the Teller token for the loan\\n ITToken tToken =\\n MarketStorageLib.store().tTokens[\\n LibLoans.loan(loanID).lendingToken\\n ];\\n // Transfer funds from an escrow if an escrow is calling it\\n // Otherwise, transfer funds from an account\\n if (address(LibEscrow.e(loanID)) == sender) {\\n LibEscrow.e(loanID).claimToken(\\n LibLoans.loan(loanID).lendingToken,\\n address(tToken),\\n amount\\n );\\n } else {\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n sender,\\n address(tToken),\\n amount\\n );\\n }\\n\\n // Deduct the interest and principal owed\\n uint256 principalPaid;\\n uint256 interestPaid;\\n if (amount < LibLoans.debt(loanID).interestOwed) {\\n interestPaid = amount;\\n LibLoans.debt(loanID).interestOwed -= amount;\\n } else {\\n if (LibLoans.debt(loanID).interestOwed > 0) {\\n interestPaid = LibLoans.debt(loanID).interestOwed;\\n amount -= interestPaid;\\n LibLoans.debt(loanID).interestOwed = 0;\\n }\\n\\n if (amount > 0) {\\n principalPaid = amount;\\n LibLoans.debt(loanID).principalOwed -= amount;\\n }\\n }\\n\\n // Tell the Teller Token value has been deposited back into the pool.\\n tToken.repayLoan(principalPaid, interestPaid);\\n\\n if (isLiquidation) {\\n // Make sure there is nothing left to repay on the loan\\n require(leftToPay_ == 0, \\\"Teller: liquidate partial repay\\\");\\n\\n // Set loan status\\n LibLoans.loan(loanID).status = LoanStatus.Liquidated;\\n\\n // Transfer NFT if linked\\n NFTLib.liquidateNFT(loanID);\\n } else {\\n // if the loan is now fully paid, close it and withdraw borrower collateral\\n if (leftToPay_ == 0) {\\n LibLoans.loan(loanID).status = LoanStatus.Closed;\\n\\n // Check if the loan has a collateral token\\n if (LibLoans.loan(loanID).collateralToken != address(0)) {\\n LibCollateral.withdrawAll(\\n loanID,\\n LibLoans.loan(loanID).borrower\\n );\\n }\\n\\n // Claim tokens in the escrow for the loan if any\\n __claimEscrowTokens(loanID);\\n\\n // Restake any NFTs linked to loan for borrower\\n NFTLib.restakeLinked(loanID, LibLoans.loan(loanID).borrower);\\n }\\n\\n emit LoanRepaid(\\n loanID,\\n LibLoans.loan(loanID).borrower,\\n amount,\\n msg.sender,\\n leftToPay_\\n );\\n }\\n }\\n\\n /**\\n * @notice Liquidate a loan if it is expired or under collateralized\\n * @param loanID The ID of the loan to be liquidated\\n */\\n function liquidateLoan(uint256 loanID)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n uint256 collateralAmount = LibCollateral.e(loanID).loanSupply(loanID);\\n require(\\n RepayLib.isLiquidable(loanID, collateralAmount),\\n \\\"Teller: does not need liquidation\\\"\\n );\\n\\n // Calculate the reward before repaying the loan\\n (uint256 rewardInLending, uint256 collateralInLending) =\\n RepayLib.getLiquidationReward(loanID, collateralAmount);\\n\\n // The liquidator pays the amount still owed on the loan\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n __repayLoan(loanID, amountToLiquidate, msg.sender, true);\\n\\n // Payout the liquidator reward owed\\n if (rewardInLending > 0) {\\n RepayLib.payOutLiquidator(\\n loanID,\\n rewardInLending,\\n collateralInLending,\\n collateralAmount,\\n payable(msg.sender)\\n );\\n }\\n\\n emit LoanLiquidated(\\n loanID,\\n loan.borrower,\\n msg.sender,\\n rewardInLending,\\n amountToLiquidate\\n );\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @return inLending_ The value the liquidator will receive denoted in lending tokens.\\n * @return inCollateral_ The value the liquidator will receive denoted in collateral tokens.\\n */\\n function getLiquidationReward(uint256 loanID)\\n external\\n view\\n returns (uint256 inLending_, uint256 inCollateral_)\\n {\\n (inLending_, ) = RepayLib.getLiquidationReward(\\n loanID,\\n LibCollateral.e(loanID).loanSupply(loanID)\\n );\\n inCollateral_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n inLending_\\n );\\n }\\n}\\n\\nlibrary RepayLib {\\n /**\\n * @notice It checks if a loan can be liquidated.\\n * @param loanID The loan ID to check.\\n * @return true if the loan is liquidable.\\n */\\n function isLiquidable(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (bool)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n // Check if loan can be liquidated\\n if (loan.status != LoanStatus.Active) {\\n return false;\\n }\\n\\n if (loan.collateralRatio > 0) {\\n // If loan has a collateral ratio, check how much is needed\\n (, uint256 neededInCollateral, ) =\\n LoanDataFacet(address(this)).getCollateralNeededInfo(loanID);\\n if (neededInCollateral > collateralAmount) {\\n return true;\\n }\\n }\\n\\n // Otherwise, check if the loan has expired\\n return block.timestamp >= loan.loanStartTime + loan.duration;\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @param collateralAmount The amount of collateral for the {loanID}. Passed in to save gas calling the collateral escrow multiple times.\\n * @return reward_ The value the liquidator will receive denoted in lending tokens.\\n */\\n function getLiquidationReward(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (uint256 reward_, uint256 collateralValue_)\\n {\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n // Max reward is amount repaid on loan plus extra percentage\\n uint256 maxReward =\\n amountToLiquidate +\\n NumbersLib.percent(\\n amountToLiquidate,\\n uint16(PlatformSettingsLib.getLiquidateRewardPercent())\\n );\\n\\n // Calculate available collateral for reward\\n if (collateralAmount > 0) {\\n collateralValue_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).collateralToken,\\n LibLoans.loan(loanID).lendingToken,\\n collateralAmount\\n );\\n reward_ += collateralValue_;\\n }\\n\\n // Calculate loan escrow value if collateral not enough to cover reward\\n if (reward_ < maxReward) {\\n reward_ += LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n // Cap the reward to max\\n if (reward_ > maxReward) {\\n reward_ = maxReward;\\n }\\n }\\n\\n /**\\n * @notice Checks if the loan has an Escrow and claims any tokens then pays out the loan collateral.\\n * @dev See Escrow.claimTokens for more info.\\n * @param loanID The loan ID which is being liquidated\\n * @param rewardInLending The total amount of reward based in the lending token to pay the liquidator\\n * @param collateralInLending The amount of collateral that is available for the loan denoted in lending tokens\\n * @param collateralAmount The amount of collateral that is available for the loan\\n * @param liquidator The address of the liquidator where the liquidation reward will be sent to\\n */\\n function payOutLiquidator(\\n uint256 loanID,\\n uint256 rewardInLending,\\n uint256 collateralInLending,\\n uint256 collateralAmount,\\n address payable liquidator\\n ) internal {\\n // check if loan is liquidated\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Liquidated,\\n \\\"Teller: loan not liquidated\\\"\\n );\\n\\n // if the lending reward is less than the collateral lending tokens, then aggregate\\n // the value for the lending token with the collateral token and send it to the liquidator\\n if (rewardInLending <= collateralInLending) {\\n uint256 rewardInCollateral =\\n PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n rewardInLending\\n );\\n\\n LibCollateral.withdraw(loanID, rewardInCollateral, liquidator);\\n } else {\\n // Payout whats available in the collateral token\\n LibCollateral.withdraw(loanID, collateralAmount, liquidator);\\n\\n // Claim remaining reward value from the loan escrow\\n claimEscrowTokensByValue(\\n loanID,\\n liquidator,\\n rewardInLending - collateralInLending\\n );\\n }\\n }\\n\\n /**\\n * @dev Send the equivalent of tokens owned by the loan escrow (in lending value) to the recipient,\\n * @param loanID The loan ID to clam tokens from\\n * @param recipient address to send the tokens to\\n * @param value The value of escrow held tokens to be claimed based in lending value\\n */\\n function claimEscrowTokensByValue(\\n uint256 loanID,\\n address recipient,\\n uint256 value\\n ) private {\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n uint256 valueLeftToTransfer = value;\\n\\n // Start with the lending token\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n LibLoans.loan(loanID).lendingToken,\\n recipient,\\n valueLeftToTransfer\\n );\\n\\n // Cycle through remaining tokens\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n if (valueLeftToTransfer == 0) {\\n return;\\n }\\n\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n EnumerableSet.at(tokens, i),\\n recipient,\\n valueLeftToTransfer\\n );\\n }\\n }\\n\\n /**\\n * @notice it claims the escrow tokens for the liquidator\\n * @notice it keeps claiming escrow tokens until there aren't anymore tokens or the valueLeftToTransfer is zero\\n * @param loanID the identifier of the escrow loan to claim tokens from\\n * @param token the address of the token asset to claim\\n * @param recipient the address of the recipient to transfer the tokens to\\n * @param valueLeftToTransfer the value left to transfer to the liquidator that is returned back\\n * @return the value left to transfer\\n */\\n function claimEscrowToken(\\n uint256 loanID,\\n address token,\\n address recipient,\\n uint256 valueLeftToTransfer\\n ) private returns (uint256) {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n // get value of token balance in lending value\\n if (balance > 0) {\\n // If token not the lending token, get value of token\\n uint256 balanceInLending;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n balanceInLending = balance;\\n } else {\\n balanceInLending = PriceAggLib.valueFor(\\n token,\\n LibLoans.loan(loanID).lendingToken,\\n balance\\n );\\n }\\n\\n if (balanceInLending <= valueLeftToTransfer) {\\n LibEscrow.e(loanID).claimToken(token, recipient, balance);\\n valueLeftToTransfer -= balanceInLending;\\n } else {\\n // Token balance is more than enough so calculate ratio of balance to transfer\\n uint256 valueToTransfer;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n valueToTransfer = valueLeftToTransfer;\\n } else {\\n valueToTransfer = NumbersLib.percent(\\n balance,\\n NumbersLib.ratioOf(\\n valueLeftToTransfer,\\n balanceInLending\\n )\\n );\\n }\\n\\n LibEscrow.e(loanID).claimToken(\\n token,\\n recipient,\\n valueToTransfer\\n );\\n valueLeftToTransfer = 0;\\n }\\n }\\n return valueLeftToTransfer;\\n }\\n}\\n\",\"keccak256\":\"0xc440b61519f74c4eba549f1f531726b1cd8b3da60ba7654cccd4eb9bd9fd7020\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n /**\\n * @notice it initializes an escrow\\n * @param tokenAddress the address of the collateral token to be stored\\n * @param isWETH check if it's wrapped Ethereum\\n */\\n function init(address tokenAddress, bool isWETH) external;\\n\\n /**\\n * @notice it deposits an amount of the respective collateral token into the escrow\\n * @param loanID the ID of the loan\\n * @param amount the amount of collateral tokens to be deposited\\n */\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n /**\\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\\n * @dev only the TellerDiamond can make this call on behalf of the borrower\\n * @param loanID identifier of the loan\\n * @param amount number of collateral tokens to send\\n * @param receiver payable address to transfer money to\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n /**\\n * @notice it returns the supply of the respective loan\\n * @param loanID the respective loan ID\\n * @return supply_ the amount in collateral of the respective loan\\n */\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n /**\\n * @notice it returns the total supply of the collateral token held by the contract\\n * @return supply_ the total amount of collateral\\n */\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x900fed2311f919ba1451a6583ddbf9f3bc8afa8f5189500fff51f0c049258ed3\",\"license\":\"MIT\"},\"contracts/market/libraries/LibCollateral.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport { ICollateralEscrow } from \\\"../collateral/ICollateralEscrow.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\nimport { MarketStorageLib } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibCollateral {\\n /**\\n * @notice This event is emitted when collateral has been deposited for the loan\\n * @param loanID ID of the loan for which collateral was deposited\\n * @param depositor Account that deposited funds\\n * @param amount Amount of collateral deposited\\n */\\n event CollateralDeposited(\\n uint256 indexed loanID,\\n address indexed depositor,\\n uint256 amount\\n );\\n\\n /**\\n * @notice This event is emitted when collateral has been withdrawn\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param receiver Account that received funds\\n * @param amount Value of collateral withdrawn\\n */\\n event CollateralWithdrawn(\\n uint256 indexed loanID,\\n address indexed receiver,\\n uint256 amount\\n );\\n\\n /**\\n * @notice it gets MarketStorage's collateral escrow using the loanID\\n * @param loanID the loanID to be used\\n * @return c_ which is the collateral escrow\\n */\\n function e(uint256 loanID) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[\\n MarketStorageLib.store().loans[loanID].collateralToken\\n ];\\n }\\n\\n function e(address token) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[token];\\n }\\n\\n /**\\n * @notice it deposits an amount of collateral into a collateral escrow's address of a respective loan\\n * @param loanID the respective loan ID\\n * @param amount the amount of collateral to deposit\\n */\\n function deposit(uint256 loanID, uint256 amount) internal {\\n e(loanID).deposit{ value: amount }(loanID, amount);\\n\\n emit CollateralDeposited(loanID, msg.sender, amount);\\n }\\n\\n /**\\n * @notice it withdraws an amount from the collateral escrow\\n * @param loanID the respective loanID to withdraw from\\n * @param amount the number of collateral tokens to withdraw\\n * @param receiver the address who receives the withdrawal\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) internal {\\n e(loanID).withdraw(loanID, amount, receiver);\\n\\n emit CollateralWithdrawn(loanID, receiver, amount);\\n }\\n\\n /**\\n * @notice it withdraws the entire supply in collateral of a respective loan to an address\\n * @param loanID the respective loan's ID\\n * @param receiver the address of the receiver to withdraw tokens from\\n */\\n function withdrawAll(uint256 loanID, address payable receiver) internal {\\n withdraw(loanID, e(loanID).loanSupply(loanID), receiver);\\n }\\n\\n /**\\n * @notice it initializes a new escrow collateral to hold collateral tokens\\n * @param token address of the collateral token it holds\\n */\\n function createEscrow(address token) internal {\\n // Check if collateral escrow exists\\n if (address(e(token)) == address(0)) {\\n // Create escrow\\n address escrow =\\n AppStorageLib.store().collateralEscrowBeacon.cloneProxy(\\\"\\\");\\n ICollateralEscrow(escrow).init(\\n token,\\n // Check if collateral token is WETH\\n token == AppStorageLib.store().assetAddresses[\\\"WETH\\\"]\\n );\\n\\n // Set max allowance\\n IERC20(token).approve(escrow, type(uint256).max);\\n // Save escrow address for loan\\n MarketStorageLib.store().collateralEscrows[\\n token\\n ] = ICollateralEscrow(escrow);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x84dbab8283357a1cc4210e34642fc8247841a58973778f4f6570398cc3046947\",\"license\":\"MIT\"},\"contracts/market/libraries/LibLoans.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibEscrow } from \\\"../../escrow/libraries/LibEscrow.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus,\\n LoanDebt,\\n LoanTerms\\n} from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibLoans {\\n using NumbersLib for int256;\\n using NumbersLib for uint256;\\n\\n bytes32 internal constant ID = keccak256(\\\"LOANS\\\");\\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n * @notice it returns the loan\\n * @param loanID the ID of the respective loan\\n * @return l_ the loan \\n */\\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\\n l_ = s().loans[loanID];\\n }\\n\\n /**\\n * @notice it returns the loan debt from a respective loan\\n * @param loanID the ID of the respective loan\\n * @return d_ the loan debt from a respective loan\\n */\\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\\n d_ = s().loanDebt[loanID];\\n }\\n\\n // DEPRECATED\\n function terms(uint256 loanID)\\n internal\\n view\\n returns (LoanTerms storage t_)\\n {\\n t_ = s()._loanTerms[loanID];\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return owed_ uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID)\\n internal\\n view\\n returns (uint256 owed_)\\n {\\n if (loan(loanID).status == LoanStatus.Active) {\\n owed_ = debt(loanID).principalOwed + (debt(loanID).interestOwed);\\n }\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n internal\\n view\\n returns (uint256)\\n {\\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\\n }\\n \\n function getCollateralNeeded(uint256 loanID)\\n internal\\n view\\n returns (uint256 _needed)\\n {\\n (, _needed, ) = getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the total collateral needed in lending tokens, in collateral tokens and in escrowed loan values\\n * @param loanID the loanID to get the total collateral needed\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n internal\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\\n loanID\\n );\\n\\n // check if needed lending tokens is zero. if true, then needed collateral tokens is zero. else,\\n if (neededInLendingTokens == 0) {\\n neededInCollateralTokens = 0;\\n } else {\\n neededInCollateralTokens = PriceAggLib.valueFor(\\n loan(loanID).lendingToken,\\n loan(loanID).collateralToken,\\n neededInLendingTokens\\n );\\n }\\n }\\n\\n /**\\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\\n * @param loanID The loan ID to get needed collateral info for.\\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\\n */\\n function getCollateralNeededInTokens(uint256 loanID)\\n internal\\n view\\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\\n {\\n if (loan(loanID).collateralRatio == 0) {\\n return (0, 0);\\n }\\n\\n /*\\n The collateral to principal owed ratio is the sum of:\\n * collateral buffer percent\\n * loan interest rate\\n * liquidation reward percent\\n * X factor of additional collateral\\n */\\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n neededInLendingTokens = loan(loanID).borrowedAmount.percent(\\n loan(loanID).collateralRatio\\n );\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n uint16 requiredRatio =\\n loan(loanID).collateralRatio -\\n getInterestRatio(loanID) -\\n uint16(PlatformSettingsLib.getCollateralBufferValue());\\n\\n neededInLendingTokens =\\n debt(loanID).principalOwed +\\n debt(loanID).interestOwed;\\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\\n if (\\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\\n ) {\\n neededInLendingTokens -= escrowLoanValue;\\n }\\n neededInLendingTokens = neededInLendingTokens.percent(\\n requiredRatio\\n );\\n }\\n }\\n\\n /**\\n * @notice check if a loan can go to end of auction with a collateral ratio\\n * @return bool checking if collateralRatio is >= the over collateralized buffer value\\n */\\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\\n internal\\n view\\n returns (bool)\\n {\\n return\\n collateralRatio >=\\n PlatformSettingsLib.getOverCollateralizedBufferValue();\\n }\\n\\n /**\\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\\n * @notice There is a minimum threshold of 1%.\\n * @dev The interest rate is APY (annual percentage yield).\\n * @param loanID The loan ID to get the interest rate for.\\n */\\n function getInterestRatio(uint256 loanID)\\n internal\\n view\\n returns (uint16 ratio_)\\n {\\n ratio_ = uint16(\\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\\n SECONDS_PER_YEAR\\n );\\n\\n if (ratio_ == 0) {\\n ratio_ = 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0xe48b287a583b40e534654e4023422f59a9e6d7dd265d68ae4af43f8da58c09d9\",\"license\":\"MIT\"},\"contracts/nft/IStakeableNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IStakeableNFT {\\n function tokenBaseLoanSize(uint256 tokenId) external view returns (uint256);\\n\\n function tokenURIHash(uint256 tokenId)\\n external\\n view\\n returns (string memory);\\n\\n function tokenContributionAsset(uint256 tokenId)\\n external\\n view\\n returns (address);\\n\\n function tokenContributionSize(uint256 tokenId)\\n external\\n view\\n returns (uint256);\\n\\n function tokenContributionMultiplier(uint256 tokenId)\\n external\\n view\\n returns (uint8);\\n}\\n\",\"keccak256\":\"0xfbf44350ad91a54de26f39195d714580d7dade556ea4c7991a51eef5aa839105\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x417b75f5d92be67993efc54db7d453be5b5058a9a54d8916380e0281d3299526\",\"license\":\"MIT\"},\"contracts/nft/TellerNFTDictionary.sol\":{\"content\":\"/**\\n * @notice TellerNFTDictionary Version 1.02\\n *\\n * @notice This contract is used to gather data for TellerV1 NFTs more efficiently.\\n * @notice This contract has data which must be continuously synchronized with the TellerV1 NFT data\\n *\\n * @author develop@teller.finance\\n */\\n\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Interfaces\\nimport \\\"./IStakeableNFT.sol\\\";\\n\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFTDictionary is IStakeableNFT, AccessControlUpgradeable {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n mapping(uint256 => uint256) public baseLoanSizes;\\n mapping(uint256 => string[]) public hashes;\\n mapping(uint256 => address) public contributionAssets;\\n mapping(uint256 => uint256) public contributionSizes;\\n mapping(uint256 => uint8) public contributionMultipliers;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n\\n /* State Variables */\\n\\n mapping(uint256 => uint256) public _tokenTierMappingCompressed;\\n bool public _tokenTierMappingCompressedSet;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFTDictionary: not admin\\\");\\n _;\\n }\\n\\n function initialize(address initialAdmin) public {\\n _setupRole(ADMIN, initialAdmin);\\n _setRoleAdmin(ADMIN, ADMIN);\\n\\n __AccessControl_init();\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTierIndex(uint256 tokenId)\\n public\\n view\\n returns (uint8 index_)\\n {\\n //32 * 8 = 256 - each uint256 holds the data of 32 tokens . 8 bits each.\\n\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 compressedRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n //use 31 instead of 32 to account for the '0x' in the start.\\n //the '31 -' reverses our bytes order which is necessary\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint8 tierIndex = uint8((compressedRegister >> offset));\\n\\n return tierIndex;\\n }\\n\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory)\\n {\\n return hashes[tierIndex];\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTier(uint256 index, Tier memory newTier)\\n external\\n onlyAdmin\\n returns (bool)\\n {\\n baseLoanSizes[index] = newTier.baseLoanSize;\\n hashes[index] = newTier.hashes;\\n contributionAssets[index] = newTier.contributionAsset;\\n contributionSizes[index] = newTier.contributionSize;\\n contributionMultipliers[index] = newTier.contributionMultiplier;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param tiersMapping Information about the new tiers to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setAllTokenTierMappings(uint256[] memory tiersMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n require(\\n !_tokenTierMappingCompressedSet,\\n \\\"TellerNFTDictionary: token tier mapping already set\\\"\\n );\\n for (uint256 i = 0; i < tiersMapping.length; i++) {\\n _tokenTierMappingCompressed[i] = tiersMapping[i];\\n }\\n\\n _tokenTierMappingCompressedSet = true;\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param index the mapping row, each holds data for 32 tokens\\n * @param tierMapping Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierMapping(uint256 index, uint256 tierMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n _tokenTierMappingCompressed[index] = tierMapping;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenIds the NFT token Ids for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenIds(\\n uint256[] calldata tokenIds,\\n uint256 tokenTier\\n ) public onlyAdmin returns (bool) {\\n for (uint256 i; i < tokenIds.length; i++) {\\n setTokenTierForTokenId(tokenIds[i], tokenTier);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenId the NFT token Id for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenId(uint256 tokenId, uint256 tokenTier)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 existingRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint256 updateMaskShifted =\\n 0x00000000000000000000000000000000000000000000000000000000000000FF <<\\n offset;\\n\\n uint256 updateMaskShiftedNegated = ~updateMaskShifted;\\n\\n uint256 tokenTierShifted =\\n ((0x0000000000000000000000000000000000000000000000000000000000000000 |\\n tokenTier) << offset);\\n\\n uint256 existingRegisterClearedWithMask =\\n existingRegister & updateMaskShiftedNegated;\\n\\n uint256 updatedRegister =\\n existingRegisterClearedWithMask | tokenTierShifted;\\n\\n _tokenTierMappingCompressed[mappingIndex] = updatedRegister;\\n\\n return true;\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(IStakeableNFT).interfaceId ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n New methods for the dictionary\\n */\\n\\n /**\\n * @notice It returns Base Loan Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenBaseLoanSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return baseLoanSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Token URI Hash for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenURIHash(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n string[] memory tierImageHashes = hashes[tokenTier];\\n return tierImageHashes[tokenId % (tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice It returns Contribution Asset for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionAsset(uint256 tokenId)\\n public\\n view\\n override\\n returns (address)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionAssets[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Multiplier for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionMultiplier(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint8)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionMultipliers[tokenTier];\\n }\\n}\\n\",\"keccak256\":\"0xf33e3fa1f609fdd2abb3b5fb9c232269d13363a3e4fa5697ea96269e361e74fa\"},\"contracts/nft/libraries/NFTLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../TellerNFT.sol\\\";\\n\\n// Libraries\\nimport {\\n MerkleProof\\n} from \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\nimport { NFTStorageLib, NFTStorage } from \\\"../../storage/nft.sol\\\";\\n\\nlibrary NFTLib {\\n function s() internal pure returns (NFTStorage storage s_) {\\n s_ = NFTStorageLib.store();\\n }\\n\\n function nft() internal view returns (TellerNFT nft_) {\\n nft_ = AppStorageLib.store().nft;\\n }\\n\\n /**s\\n * @notice it transfers the NFT from the sender to the diamond to stake then adds the NFTID to the list of the owner's stakedNFTs\\n * @param nftID the ID of the NFT to stake\\n * @param owner the owner of the NFT who will stake the NFT\\n */\\n function stake(uint256 nftID, address owner) internal {\\n // Transfer to diamond\\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\\n // Add NFT ID to user set\\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\\n }\\n\\n /**\\n * @notice it unstakes the NFT by removing the NFT ID from the list of the user's staked NFTs\\n * @param nftID the ID of the NFT to remove from the list of the user's staked NFTs\\n * @return success_ the boolean value telling us if the user has unsuccessfully unstaked the NFT\\n */\\n function unstake(uint256 nftID) internal returns (bool success_) {\\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\\n }\\n\\n /**\\n * @notice it gets the list of staked NFTs from the owner\\n * @param nftOwner the owner of the staked NFTs to pull from\\n * @return staked_ the array of the staked NFTs owned by the user\\n */\\n function stakedNFTs(address nftOwner)\\n internal\\n view\\n returns (uint256[] memory staked_)\\n {\\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\\n staked_ = new uint256[](EnumerableSet.length(nfts));\\n for (uint256 i; i < staked_.length; i++) {\\n staked_[i] = EnumerableSet.at(nfts, i);\\n }\\n }\\n\\n /**\\n * @notice if the user fails to pay his loan, then we liquidate the all the NFTs associated with the loan\\n * @param loanID the identifier of the loan to liquidate the NFTs from\\n */\\n function liquidateNFT(uint256 loanID) internal {\\n // Check if NFTs are linked\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n NFTLib.nft().transferFrom(\\n address(this),\\n AppStorageLib.store().nftLiquidationController,\\n EnumerableSet.at(nfts, i)\\n );\\n }\\n }\\n\\n /**\\n * @notice it unstakes an NFT and verifies the proof in order to apply the proof to a loan\\n * @param loanID the identifier of the loan\\n * @param nftID the NFT ID to apply to the loan\\n */\\n function applyToLoan(uint256 loanID, uint256 nftID) internal {\\n // NFT must be currently staked\\n // Remove NFT from being staked - returns bool\\n require(unstake(nftID), \\\"Teller: borrower nft not staked\\\");\\n\\n // Apply NFT to loan\\n EnumerableSet.add(s().loanNFTs[loanID], nftID);\\n }\\n\\n /**\\n * @notice it finds the loan's NFTs and adds them back to the owner's list of staked NFTs\\n * @param loanID the identifier of the respective loan to add the NFTs back to the user's staked NFTs\\n * @param owner the owner to add the unstaked NFTs back to the staked pile\\n */\\n function restakeLinked(uint256 loanID, address owner) internal {\\n // Get linked NFT\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n // Restake the NFT\\n EnumerableSet.add(s().stakedNFTs[owner], EnumerableSet.at(nfts, i));\\n }\\n }\\n}\\n\",\"keccak256\":\"0xccbd35c6e8d0130b38f5025ee81c47d55e4fa48c8fcb8bec6f70c21061e0ce61\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n /**\\n * @notice it returns 10^{numberOfDecimals} for a token\\n * @param token the address to calculate the decimals for\\n * @return 10^number of decimals used to calculate the price and value of different token pairs\\n */\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @notice It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @notice it tries to calculate a price from Compound and Chainlink.\\n * @dev if no price is found on compound, then calculate it on chainlink\\n * @param src the token address to calculate the price for in dst\\n * @param dst the token address to retrieve the price of src\\n * @return price_ the price of src in dst\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n * @param src the address of the src token\\n * @param dst the address of the dst token\\n * @return the price of the src token in dst token\\n\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n * @param src the source token to calculate price for with chainlink\\n * @param dst the destination token to calculate price for with chainlink\\n * @param cRate the compound rate to multiply with the price of the dst token\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @notice Scales the {value} by the difference in decimal values.\\n * @param value the the value of the src in dst\\n * @param srcDecimals src token decimals\\n * @param dstDecimals dst token decimals\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @notice it tries to calculate the price of {src} in {dst}\\n * @param src address of source token\\n * @param dst address of destination token\\n * @return the price of src token in dst\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address WETH = AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n if (dst != WETH) {\\n int256 price1 = _priceFor(src, WETH);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, WETH);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice it checks if a token is a cToken. If it is, then get the underlying address\\n * @param token address of the token\\n * @return isCToken boolean whether it's a cToken\\n * @return underlying the address of the cToken\\n */\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2efb3d71a1c0fb49f8c455c4fa30d04c69a1617d619035fc400dabdeb2ab0c9e\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { PriceAggFacet } from \\\"./PriceAggFacet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\n/**\\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\\n */\\nlibrary PriceAggLib {\\n /**\\n * @notice It calculates the value of one token amount into another\\n * @param src the source token\\n * @param dst the destination token\\n * @param srcAmount the amount of source token\\n * @return value_ the returned value of src in dst\\n */\\n function valueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) internal view returns (uint256 value_) {\\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\\n }\\n\\n /**\\n * @notice It returns the price of the token pair as given from Compound.\\n * @dev if no compound price is calculated, then it checks Chainlink price Aggregator\\n * @param src the address of the source token\\n * @param dst the address of the desitnation token\\n * @return price_ gets the price of src in dst\\n */\\n function priceFor(address src, address dst)\\n internal\\n view\\n returns (int256 price_)\\n {\\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\\n }\\n}\\n\",\"keccak256\":\"0xff59eee567fa4a7f5cac432e31d918be92834f04614f49572d3984a5b030ac79\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\nabstract contract PausableMods {\\n /**\\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\\n * @param id id of the facet to check if is paused.\\n * @param state Boolean that the protocol AND facet should be in.\\n */\\n modifier paused(bytes32 id, bool state) {\\n require(\\n __isPaused(\\\"\\\") == state && __isPaused(id) == state,\\n __pausedMessage(state)\\n );\\n _;\\n }\\n\\n /**\\n * @dev Checks if the given id is paused.\\n * @param id Encoded id of the facet to check if is paused.\\n * @return the bool to tell us if the facet is paused (true) or not (false)\\n */\\n function __isPaused(bytes32 id) private view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n\\n /**\\n * @dev Gets the message that should be reverted with given a state it should be in.\\n * @param state Boolean that an id should be in.\\n * @return a message stating whether the facet is paused or not\\n */\\n function __pausedMessage(bool state) private pure returns (string memory) {\\n return state ? \\\"Pausable: not paused\\\" : \\\"Pausable: paused\\\";\\n }\\n}\\n\",\"keccak256\":\"0x2d3f848ee56ae5fa365539c2509c03c167affc89c89f98bb98cb9b83fbe8ae4c\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"NFTInterestRate\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getNFTInterestRate() internal view returns (uint16 value_) {\\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0x44294be1af9f913b2ed391a40cd4b646537a4b463b8d5ff1fac8ead3988966c1\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for loans taken out with an NFT.\\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\\n */\\nbytes32 constant NFT_INTEREST_RATE = keccak256(\\\"NFTInterestRate\\\");\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xd68a7df42b2bbba6f935d5890b7b37997c1432e25ae113827b8bde87f94fd86f\",\"license\":\"MIT\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n /**\\n * @notice Checks if the account should be allowed to mint tokens in the given market\\n * @param cToken The market to verify the mint against\\n * @param minter The account which would get the minted tokens\\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates mint and reverts on rejection. May emit logs.\\n * @param cToken Asset being minted\\n * @param minter The address minting the tokens\\n * @param mintAmount The amount of the underlying asset being minted\\n * @param mintTokens The number of tokens being minted\\n */\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to redeem tokens in the given market\\n * @param cToken The market to verify the redeem against\\n * @param redeemer The account which would redeem the tokens\\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates redeem and reverts on rejection. May emit logs.\\n * @param cToken Asset being redeemed\\n * @param redeemer The address redeeming the tokens\\n * @param redeemAmount The amount of the underlying asset being redeemed\\n * @param redeemTokens The number of tokens being redeemed\\n */\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\\n * @param cToken The market to verify the borrow against\\n * @param borrower The account which would borrow the asset\\n * @param borrowAmount The amount of underlying the account would borrow\\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates borrow and reverts on rejection. May emit logs.\\n * @param cToken Asset whose underlying is being borrowed\\n * @param borrower The address borrowing the underlying\\n * @param borrowAmount The amount of the underlying asset requested to borrow\\n */\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to repay a borrow in the given market\\n * @param cToken The market to verify the repay against\\n * @param payer The account which would repay the asset\\n * @param borrower The account which would borrowed the asset\\n * @param repayAmount The amount of the underlying asset the account would repay\\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\\n * @param cToken Asset being repaid\\n * @param payer The address repaying the borrow\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param borrowerIndex the index of the borrower\\n */\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n /**\\n * @notice Checks if the liquidation should be allowed to occur\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n */\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the seizing of assets should be allowed to occur\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates seize and reverts on rejection. May emit logs.\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to transfer tokens in the given market\\n * @param cToken The market to verify the transfer against\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates transfer and reverts on rejection. May emit logs.\\n * @param cToken Asset being transferred\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n */\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in all markets\\n * @param holder The address to claim COMP for\\n */\\n function claimComp(address holder) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in the specified markets\\n * @param holder The address to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n */\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n /**\\n * @notice Claim all comp accrued by the holders\\n * @param holders The addresses to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n * @param borrowers Whether or not to claim COMP earned by borrowing\\n * @param suppliers Whether or not to claim COMP earned by supplying\\n */\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n /**\\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\\n * @param cTokenBorrowed The address of the borrowed cToken\\n * @param cTokenCollateral The address of the collateral cToken\\n * @param repayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\\n */\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n /**\\n * @notice Return the address of the COMP token\\n * @return The address of COMP\\n */\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x38a824a4a21ce9370fa581a616d1bb9d311f27d8982a6b96ebeba90bd5fd0adb\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n \\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x37849041e4bee2dfa825677f69078521fcc94804aa5120f67dd12cc4133efcec\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @dev CETH is the only Compound token that does not support the {underlying} function.\\n * @param cToken address of the compound token\\n * @return address of the underlying cToken\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x99206384c27b0e68b1ec7b82260f6a47965f611875c018bc076ff8a688a6c6d7\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n /**\\n * @notice it returns the absolute number of a specified parameter\\n * @param self the number to be returned in it's absolute \\n * @return the absolute number\\n */\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0xa852b8866a3d6d928c6575bf2bcf2ae784eed73717c78c0cadbdedf8b0ba3274\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0c52fdd76b33f74e233c3a27dd3b73b134e9643aab347b3aa649c504809c6559\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\n// DEPRECATED\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\nstruct LoanRequest {\\n LoanUserRequest request;\\n LoanConsensusResponse[] responses;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanUserRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanConsensusResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) _loanTerms; // DEPRECATED: DO NOT REMOVE\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb7e05aeec806b5621512def93f4a389b4ef88c50ef9fe7115a33f57db2f2304b\",\"license\":\"MIT\"},\"contracts/storage/nft.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"../nft/TellerNFTDictionary.sol\\\";\\n\\n// Utils\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct NFTStorage {\\n // Maps NFT owner to set of token IDs owned\\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\\n // Maps loanID to NFT IDs indicating NFT being used for the loan\\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\\n // Merkle root used for verifying nft IDs to base loan size\\n TellerNFTDictionary nftDictionary;\\n}\\n\\nbytes32 constant NFT_STORAGE_POS = keccak256(\\\"teller.staking.storage\\\");\\n\\nlibrary NFTStorageLib {\\n function store() internal pure returns (NFTStorage storage s) {\\n bytes32 pos = NFT_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd44f213be3125ea2e2de120c241832f1861be18b3ff2fd4c3baa52ea20b94812\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", "history": [ { "address": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", @@ -2002,6 +2002,2107 @@ "storage": [], "types": null } + }, + { + "address": "0xe6fc54F4e4346b03636a0911Efd51ECa21242Bb7", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "RepayFacet", + "transactionHash": "0xc82ec063e1fb7747b28039b653e7bffdc003edf3d5af1efc52c2c5a301db91f1", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0xe6fc54F4e4346b03636a0911Efd51ECa21242Bb7", + "transactionIndex": 0, + "gasUsed": "1914533", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xde4ed8012c33bda2dfb8e2b7a93e92fe7bcced3d55afca0b55da14cf6dba8787", + "transactionHash": "0xc82ec063e1fb7747b28039b653e7bffdc003edf3d5af1efc52c2c5a301db91f1", + "logs": [], + "blockNumber": 25521611, + "cumulativeGasUsed": "1914533", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "1389136e56e3a43cff4f2990a46ef548", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"liquidator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"reward\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokensIn\",\"type\":\"uint256\"}],\"name\":\"LoanLiquidated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountPaid\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"totalOwed\",\"type\":\"uint256\"}],\"name\":\"LoanRepaid\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"}],\"name\":\"TokensClaimed\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"claimTokens\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"escrowRepay\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLiquidationReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"inLending_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"inCollateral_\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"liquidateLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"repayLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"params\":{\"borrower\":\"Account address of the borrower\",\"liquidator\":\"Account address of the liquidator\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"reward\":\"Value in lending token paid out to liquidator\",\"tokensIn\":\"Percentage of the collateral price paid by the liquidator to the lending pool\"}},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"params\":{\"amountPaid\":\"Amount of the loan paid back\",\"borrower\":\"Account address of the borrower\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"payer\":\"Account address of the payer\",\"totalOwed\":\"Total amount of the loan to be repaid\"}}},\"kind\":\"dev\",\"methods\":{\"claimTokens(uint256)\":{\"params\":{\"loanID\":\"The id of the loan being used.\"}},\"escrowRepay(uint256,uint256)\":{\"details\":\"If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\",\"params\":{\"amount\":\"The amount being repaid.\",\"loanID\":\"The id of the loan being used.\"}},\"getLiquidationReward(uint256)\":{\"params\":{\"loanID\":\"The loan ID to get the info.\"},\"returns\":{\"inCollateral_\":\"The value the liquidator will receive denoted in collateral tokens.\",\"inLending_\":\"The value the liquidator will receive denoted in lending tokens.\"}},\"liquidateLoan(uint256)\":{\"params\":{\"loanID\":\"The ID of the loan to be liquidated\"}},\"repayLoan(uint256,uint256)\":{\"params\":{\"amount\":\"The amount of tokens to pay back to the loan\",\"loanID\":\"The ID of the loan the payment is for\"}}},\"version\":1},\"userdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully liquidated\"},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully repaid\"},\"TokensClaimed(address)\":{\"notice\":\"Notifies when the Escrow's tokens have been claimed.\"}},\"kind\":\"user\",\"methods\":{\"claimTokens(uint256)\":{\"notice\":\"Sends the tokens owned by this escrow to the owner.\"},\"escrowRepay(uint256,uint256)\":{\"notice\":\"Repay this Escrow's loan.\"},\"getLiquidationReward(uint256)\":{\"notice\":\"It gets the current liquidation reward for a given loan.\"},\"liquidateLoan(uint256)\":{\"notice\":\"Liquidate a loan if it is expired or under collateralized\"},\"repayLoan(uint256,uint256)\":{\"notice\":\"Make a payment to a loan\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/market/RepayFacet.sol\":\"RepayFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Trees proofs.\\n *\\n * The proofs can be generated using the JavaScript library\\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\\n *\\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n bytes32 computedHash = leaf;\\n\\n for (uint256 i = 0; i < proof.length; i++) {\\n bytes32 proofElement = proof[i];\\n\\n if (computedHash <= proofElement) {\\n // Hash(current computed hash + current element of the proof)\\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\\n } else {\\n // Hash(current element of the proof + current computed hash)\\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\\n }\\n }\\n\\n // Check if the computed hash (root) is equal to the provided root\\n return computedHash == root;\\n }\\n}\\n\",\"keccak256\":\"0xeee34bfb413657b6cd6c8e1e15c2080ba5ebaac479578515922804346fb63f7c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/reentry/ReentryMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nabstract contract ReentryMods {\\n modifier nonReentry(bytes32 id) {\\n AccessControlStorage storage s = AccessControlStorageLib.store();\\n require(!s.entered[id], \\\"AccessControl: reentered\\\");\\n s.entered[id] = true;\\n _;\\n s.entered[id] = false;\\n }\\n}\\n\",\"keccak256\":\"0x033c1164af25ef7d35a38a60973bf379b1cc603596914ffd85dcbcf0acdb6970\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/EscrowClaimTokens.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\n\\n// Interfaces\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, LoanStatus } from \\\"../storage/market.sol\\\";\\n\\n// Libraries\\nimport { LibLoans } from \\\"../market/libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"./libraries/LibEscrow.sol\\\";\\n\\n/**\\n * @notice Contains functionality to claim tokens that are in an escrow contract for a loan.\\n */\\ncontract EscrowClaimTokens is PausableMods {\\n /**\\n * @notice Notifies when the Escrow's tokens have been claimed.\\n * @param recipient address where the tokens where sent to.\\n */\\n event TokensClaimed(address recipient);\\n\\n /**\\n * @notice Sends the tokens owned by this escrow to the owner.\\n * @param loanID The id of the loan being used.\\n */\\n function claimTokens(uint256 loanID) external paused(\\\"\\\", false) {\\n require(\\n LibLoans.loan(loanID).borrower == msg.sender,\\n \\\"Teller: claim not borrower\\\"\\n );\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Closed,\\n \\\"Teller: loan not closed\\\"\\n );\\n\\n __claimEscrowTokens(loanID);\\n }\\n\\n function __claimEscrowTokens(uint256 loanID) internal {\\n __claimToken(loanID, LibLoans.loan(loanID).lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n __claimToken(loanID, EnumerableSet.at(tokens, i));\\n }\\n\\n emit TokensClaimed(msg.sender);\\n }\\n\\n function __claimToken(uint256 loanID, address token) private {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n if (balance > 0) {\\n LibEscrow.e(loanID).claimToken(\\n token,\\n LibLoans.loan(loanID).borrower,\\n balance\\n );\\n }\\n }\\n}\\n\",\"keccak256\":\"0xae189ea2a13c10f013f255f98ec50f34466c375bd7503275587d6abe5d25696c\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../interfaces/IAToken.sol\\\";\\nimport { IAaveLendingPool } from \\\"../interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x8030b206c87d0073fb7dbebfa2ee8a3e93c479d976d6cdaa0c939f2fedaa1525\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n /**\\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\\n * @param dappAddress address of the target contract address\\n * @param dappData encoded abi of the function in our contract we want to call\\n * @return the called data in bytes\\n */\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n /**\\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\\n * @param token address of the respective ERC20 token to approve for the spender\\n * @param spender address of the respective spender who is approved by the token contract\\n */\\n function setTokenAllowance(address token, address spender) external;\\n\\n /**\\n * @notice it allows user to claim their escrow tokens\\n * @dev only the owner (TellerDiamond) can make this call on behalf of the users\\n * @param token address of the respective token contract to claim tokens from\\n * @param to address where the tokens should be transferred to\\n * @param amount uint256 amount of tokens to be claimed\\n */\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xaf67fc4454ffaa4d2f7e46fe7101876e8ebdb1a5426c30f87b8e18cc573ac019\",\"license\":\"MIT\"},\"contracts/escrow/libraries/LibEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibDapps } from \\\"../dapps/libraries/LibDapps.sol\\\";\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibEscrow {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\\n e_ = s().loanEscrows[loanID];\\n }\\n\\n /**\\n * @notice It returns a list of tokens owned by a loan escrow\\n * @param loanID uint256 index used to return our token list\\n * @return t_ which is a list of tokens \\n */\\n function getEscrowTokens(uint256 loanID)\\n internal\\n view\\n returns (EnumerableSet.AddressSet storage t_)\\n {\\n t_ = s().escrowTokens[loanID];\\n }\\n\\n /**\\n * @notice It returns the balance of a respective token in a loan escrow\\n * @param loanID uint256 index used to point to our loan escrow\\n * @param token address of respective token to give us the balance of in our loan escrow\\n * @return uint256 balance of respective token returned in an escrow loan\\n */\\n function balanceOf(uint256 loanID, address token)\\n internal\\n view\\n returns (uint256)\\n {\\n return IERC20(token).balanceOf(address(e(loanID)));\\n }\\n\\n /**\\n * @notice Adds or removes tokens held by the Escrow contract\\n * @param loanID The loan ID to update the token list for\\n * @param tokenAddress The token address to be added or removed\\n */\\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\\n // Skip if is lending token\\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\\n\\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\\n if (balanceOf(loanID, tokenAddress) > 0) {\\n if (!contains) {\\n EnumerableSet.add(tokens, tokenAddress);\\n }\\n } else if (contains) {\\n EnumerableSet.remove(tokens, tokenAddress);\\n }\\n }\\n\\n /**\\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\\n * @param loanID The loan ID to calculate value for\\n * @return value_ Escrow total value denoted in the lending token.\\n */\\n function calculateTotalValue(uint256 loanID)\\n internal\\n view\\n returns (uint256 value_)\\n {\\n address lendingToken = LibLoans.loan(loanID).lendingToken;\\n value_ += balanceOf(loanID, lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\\n if (EnumerableSet.length(tokens) > 0) {\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n uint256 tokenBal =\\n balanceOf(loanID, EnumerableSet.at(tokens, i));\\n value_ += PriceAggLib.valueFor(\\n EnumerableSet.at(tokens, i),\\n lendingToken,\\n tokenBal\\n );\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x17a7c6b11d6f280948e320525d1e131b89c23f80216918aa070df437a851d915\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when a user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when a user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n * @return ERC20 token\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n * @return balance_ the balance of the account\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice It calculates the total supply of the underlying asset.\\n * @return totalSupply_ the total supply denoted in the underlying asset.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given market.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n \\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfill the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n * @return mintAmount_ the amount minted of the specified token\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n * @return address of the strategy contract\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n * @param state boolean value that resembles the platform's state\\n */\\n function restrict(bool state) external virtual;\\n\\n /**\\n * @notice it initializes the Teller Token\\n * @param admin address of the admin to the respective Teller Token\\n * @param underlying address of the ERC20 token\\n */\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xf30ac4ef491851477ff9a3dd04974ebe74b529c37a3ef4e05798c3f734ceeb3d\",\"license\":\"MIT\"},\"contracts/market/LoanDataFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { Loan, LoanDebt, LoanTerms } from \\\"../storage/market.sol\\\";\\n\\ncontract LoanDataFacet {\\n /**\\n * @notice Returns the information about the given {loanID}.\\n * @param loanID The loan ID to get information for.\\n * @return loan_ The loan data.\\n */\\n function getLoan(uint256 loanID) external view returns (Loan memory loan_) {\\n loan_ = LibLoans.s().loans[loanID];\\n }\\n\\n /**\\n * @notice DEPRECATED\\n * @notice Returns the terms for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanTerms The terms that the loan weer created with.\\n */\\n function getLoanTerms(uint256 loanID)\\n external\\n view\\n returns (LoanTerms memory)\\n {\\n return LibLoans.terms(loanID);\\n }\\n\\n /**\\n * @notice Returns the loan IDs created by the {borrower} account.\\n * @param borrower The account to get loan IDs for.\\n * @return loanIDs The IDs for loans created by the {borrower}\\n */\\n function getBorrowerLoans(address borrower)\\n external\\n view\\n returns (uint128[] memory loanIDs)\\n {\\n return LibLoans.s().borrowerLoans[borrower];\\n }\\n\\n /**\\n * @notice Returns the debt owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanDebt The principal and interest owed amount.\\n */\\n function getDebtOwed(uint256 loanID)\\n external\\n view\\n returns (LoanDebt memory)\\n {\\n return LibLoans.debt(loanID);\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) external view returns (uint256) {\\n return LibLoans.getTotalOwed(loanID);\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n external\\n view\\n returns (uint256)\\n {\\n return LibLoans.getInterestOwedFor(loanID, amountBorrow);\\n }\\n\\n /**\\n * @notice it returns the collateral needed for a loan\\n * @param loanID the identifier of the loan ID to retrieve collateral from\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n external\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n return LibLoans.getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the typed address of a loan escrow\\n * @param loanID the identifier of the respective escrow's loan\\n * @return escrow_ the typed address of the returned ILoanEscrow\\n */\\n function getLoanEscrow(uint256 loanID)\\n external\\n view\\n returns (address escrow_)\\n {\\n escrow_ = address(LibLoans.s().loanEscrows[loanID]);\\n }\\n\\n /**\\n * @notice it returns the escrow's total value by calculating the value all the escrow tokens\\n * @param loanID the identifier of the respective escrow's loan\\n * @return the total value of the loan escrow\\n */\\n function getLoanEscrowValue(uint256 loanID)\\n external\\n view\\n returns (uint256)\\n {\\n return LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n /**\\n * @notice it returns the total escrow tokens held by an escrow\\n * @param loanID the identifier of the respective escrow's loan\\n * @return tokens_ the tokens held at the escrow loan \\n */\\n function getEscrowTokens(uint256 loanID)\\n external\\n view\\n returns (address[] memory tokens_)\\n {\\n EnumerableSet.AddressSet storage escrowTokens =\\n LibEscrow.getEscrowTokens(loanID);\\n tokens_ = new address[](EnumerableSet.length(escrowTokens));\\n for (uint256 i; i < tokens_.length; i++) {\\n tokens_[i] = EnumerableSet.at(escrowTokens, i);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x9a57f5de00ce073af4ffb2f74e7d8a15e56bc017826f2c5a393ef5b64554145f\",\"license\":\"MIT\"},\"contracts/market/RepayFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\nimport {\\n ReentryMods\\n} from \\\"../contexts2/access-control/reentry/ReentryMods.sol\\\";\\nimport { AUTHORIZED } from \\\"../shared/roles.sol\\\";\\nimport { LoanDataFacet } from \\\"./LoanDataFacet.sol\\\";\\nimport { EscrowClaimTokens } from \\\"../escrow/EscrowClaimTokens.sol\\\";\\n\\n// Libraries\\nimport {\\n IERC20,\\n SafeERC20\\n} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibCollateral } from \\\"./libraries/LibCollateral.sol\\\";\\nimport { LibDapps } from \\\"../escrow/dapps/libraries/LibDapps.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { NumbersLib } from \\\"../shared/libraries/NumbersLib.sol\\\";\\nimport { PriceAggLib } from \\\"../price-aggregator/PriceAggLib.sol\\\";\\nimport { NFTLib } from \\\"../nft/libraries/NFTLib.sol\\\";\\n\\n// Interfaces\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus\\n} from \\\"../storage/market.sol\\\";\\n\\ncontract RepayFacet is RolesMods, ReentryMods, PausableMods, EscrowClaimTokens {\\n /**\\n @notice This event is emitted when a loan has been successfully repaid\\n @param loanID ID of loan from which collateral was withdrawn\\n @param borrower Account address of the borrower\\n @param amountPaid Amount of the loan paid back\\n @param payer Account address of the payer\\n @param totalOwed Total amount of the loan to be repaid\\n */\\n event LoanRepaid(\\n uint256 indexed loanID,\\n address indexed borrower,\\n uint256 amountPaid,\\n address payer,\\n uint256 totalOwed\\n );\\n\\n /**\\n * @notice This event is emitted when a loan has been successfully liquidated\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param borrower Account address of the borrower\\n * @param liquidator Account address of the liquidator\\n * @param reward Value in lending token paid out to liquidator\\n * @param tokensIn Percentage of the collateral price paid by the liquidator to the lending pool\\n */\\n event LoanLiquidated(\\n uint256 indexed loanID,\\n address indexed borrower,\\n address liquidator,\\n uint256 reward,\\n uint256 tokensIn\\n );\\n\\n /**\\n * @notice Repay this Escrow's loan.\\n * @dev If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.\\n * @dev Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\\n * @param loanID The id of the loan being used.\\n * @param amount The amount being repaid.\\n */\\n function escrowRepay(uint256 loanID, uint256 amount)\\n external\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n nonReentry(\\\"\\\")\\n {\\n uint256 balance =\\n LibEscrow.balanceOf(loanID, LibLoans.loan(loanID).lendingToken);\\n uint256 totalOwed = LibLoans.getTotalOwed(loanID);\\n // if there isn't enough balance in the escrow, then transfer amount needed to the escrow\\n if (balance < totalOwed && amount > balance) {\\n uint256 amountNeeded =\\n amount > totalOwed ? totalOwed - (balance) : amount - (balance);\\n\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n msg.sender,\\n address(LibEscrow.e(loanID)),\\n amountNeeded\\n );\\n }\\n\\n __repayLoan(loanID, amount, address(LibEscrow.e(loanID)), false);\\n }\\n\\n /**\\n * @notice Make a payment to a loan\\n * @param loanID The ID of the loan the payment is for\\n * @param amount The amount of tokens to pay back to the loan\\n */\\n function repayLoan(uint256 loanID, uint256 amount)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n __repayLoan(loanID, amount, msg.sender, false);\\n }\\n\\n /**\\n * @notice it repays the loan, either from an escrow or from a regular address\\n * @param loanID the identifier of the loan to repay\\n * @param amount the amount to repay the loan\\n * @param sender the address of the sender that wants to pay, can also be a loan escrow\\n * @param isLiquidation is this loan being liquidated?\\n * @return leftToPay_ the amount left to pay for the loan\\n */\\n function __repayLoan(\\n uint256 loanID,\\n uint256 amount,\\n address sender,\\n bool isLiquidation\\n ) private returns (uint256 leftToPay_) {\\n require(amount > 0, \\\"Teller: zero repay\\\");\\n\\n // calculate the actual amount to repay\\n leftToPay_ =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n if (leftToPay_ < amount) {\\n amount = leftToPay_;\\n leftToPay_ = 0;\\n } else {\\n leftToPay_ -= amount;\\n }\\n\\n // Get the Teller token for the loan\\n ITToken tToken =\\n MarketStorageLib.store().tTokens[\\n LibLoans.loan(loanID).lendingToken\\n ];\\n // Transfer funds from an escrow if an escrow is calling it\\n // Otherwise, transfer funds from an account\\n if (address(LibEscrow.e(loanID)) == sender) {\\n LibEscrow.e(loanID).claimToken(\\n LibLoans.loan(loanID).lendingToken,\\n address(tToken),\\n amount\\n );\\n } else {\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n sender,\\n address(tToken),\\n amount\\n );\\n }\\n\\n // Deduct the interest and principal owed\\n uint256 principalPaid;\\n uint256 interestPaid;\\n if (amount < LibLoans.debt(loanID).interestOwed) {\\n interestPaid = amount;\\n LibLoans.debt(loanID).interestOwed -= amount;\\n } else {\\n if (LibLoans.debt(loanID).interestOwed > 0) {\\n interestPaid = LibLoans.debt(loanID).interestOwed;\\n amount -= interestPaid;\\n LibLoans.debt(loanID).interestOwed = 0;\\n }\\n\\n if (amount > 0) {\\n principalPaid = amount;\\n LibLoans.debt(loanID).principalOwed -= amount;\\n }\\n }\\n\\n // Tell the Teller Token value has been deposited back into the pool.\\n tToken.repayLoan(principalPaid, interestPaid);\\n\\n if (isLiquidation) {\\n // Make sure there is nothing left to repay on the loan\\n require(leftToPay_ == 0, \\\"Teller: liquidate partial repay\\\");\\n\\n // Set loan status\\n LibLoans.loan(loanID).status = LoanStatus.Liquidated;\\n\\n // Transfer NFT if linked\\n NFTLib.liquidateNFT(loanID);\\n } else {\\n // if the loan is now fully paid, close it and withdraw borrower collateral\\n if (leftToPay_ == 0) {\\n LibLoans.loan(loanID).status = LoanStatus.Closed;\\n\\n // Check if the loan has a collateral token\\n if (LibLoans.loan(loanID).collateralToken != address(0)) {\\n LibCollateral.withdrawAll(\\n loanID,\\n LibLoans.loan(loanID).borrower\\n );\\n }\\n\\n // Claim tokens in the escrow for the loan if any\\n __claimEscrowTokens(loanID);\\n\\n // Restake any NFTs linked to loan for borrower\\n NFTLib.restakeLinked(loanID, LibLoans.loan(loanID).borrower);\\n }\\n\\n emit LoanRepaid(\\n loanID,\\n LibLoans.loan(loanID).borrower,\\n amount,\\n msg.sender,\\n leftToPay_\\n );\\n }\\n }\\n\\n /**\\n * @notice Liquidate a loan if it is expired or under collateralized\\n * @param loanID The ID of the loan to be liquidated\\n */\\n function liquidateLoan(uint256 loanID)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n uint256 collateralAmount = LibCollateral.e(loanID).loanSupply(loanID);\\n require(\\n RepayLib.isLiquidable(loanID, collateralAmount),\\n \\\"Teller: does not need liquidation\\\"\\n );\\n\\n // Calculate the reward before repaying the loan\\n (uint256 rewardInLending, uint256 collateralInLending) =\\n RepayLib.getLiquidationReward(loanID, collateralAmount);\\n\\n // The liquidator pays the amount still owed on the loan\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n __repayLoan(loanID, amountToLiquidate, msg.sender, true);\\n\\n // Payout the liquidator reward owed\\n if (rewardInLending > 0) {\\n RepayLib.payOutLiquidator(\\n loanID,\\n rewardInLending,\\n collateralInLending,\\n collateralAmount,\\n payable(msg.sender)\\n );\\n }\\n\\n emit LoanLiquidated(\\n loanID,\\n loan.borrower,\\n msg.sender,\\n rewardInLending,\\n amountToLiquidate\\n );\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @return inLending_ The value the liquidator will receive denoted in lending tokens.\\n * @return inCollateral_ The value the liquidator will receive denoted in collateral tokens.\\n */\\n function getLiquidationReward(uint256 loanID)\\n external\\n view\\n returns (uint256 inLending_, uint256 inCollateral_)\\n {\\n (inLending_, ) = RepayLib.getLiquidationReward(\\n loanID,\\n LibCollateral.e(loanID).loanSupply(loanID)\\n );\\n inCollateral_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n inLending_\\n );\\n }\\n}\\n\\nlibrary RepayLib {\\n /**\\n * @notice It checks if a loan can be liquidated.\\n * @param loanID The loan ID to check.\\n * @return true if the loan is liquidable.\\n */\\n function isLiquidable(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (bool)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n // Check if loan can be liquidated\\n if (loan.status != LoanStatus.Active) {\\n return false;\\n }\\n\\n if (loan.collateralRatio > 0) {\\n // If loan has a collateral ratio, check how much is needed\\n (, uint256 neededInCollateral, ) =\\n LoanDataFacet(address(this)).getCollateralNeededInfo(loanID);\\n if (neededInCollateral > collateralAmount) {\\n return true;\\n }\\n }\\n\\n // Otherwise, check if the loan has expired\\n return block.timestamp >= loan.loanStartTime + loan.duration;\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @param collateralAmount The amount of collateral for the {loanID}. Passed in to save gas calling the collateral escrow multiple times.\\n * @return reward_ The value the liquidator will receive denoted in lending tokens.\\n */\\n function getLiquidationReward(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (uint256 reward_, uint256 collateralValue_)\\n {\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n // Max reward is amount repaid on loan plus extra percentage\\n uint256 maxReward =\\n amountToLiquidate +\\n NumbersLib.percent(\\n amountToLiquidate,\\n uint16(PlatformSettingsLib.getLiquidateRewardPercent())\\n );\\n\\n // Calculate available collateral for reward\\n if (collateralAmount > 0) {\\n collateralValue_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).collateralToken,\\n LibLoans.loan(loanID).lendingToken,\\n collateralAmount\\n );\\n reward_ += collateralValue_;\\n }\\n\\n // Calculate loan escrow value if collateral not enough to cover reward\\n if (reward_ < maxReward) {\\n reward_ += LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n // Cap the reward to max\\n if (reward_ > maxReward) {\\n reward_ = maxReward;\\n }\\n }\\n\\n /**\\n * @notice Checks if the loan has an Escrow and claims any tokens then pays out the loan collateral.\\n * @dev See Escrow.claimTokens for more info.\\n * @param loanID The loan ID which is being liquidated\\n * @param rewardInLending The total amount of reward based in the lending token to pay the liquidator\\n * @param collateralInLending The amount of collateral that is available for the loan denoted in lending tokens\\n * @param collateralAmount The amount of collateral that is available for the loan\\n * @param liquidator The address of the liquidator where the liquidation reward will be sent to\\n */\\n function payOutLiquidator(\\n uint256 loanID,\\n uint256 rewardInLending,\\n uint256 collateralInLending,\\n uint256 collateralAmount,\\n address payable liquidator\\n ) internal {\\n // check if loan is liquidated\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Liquidated,\\n \\\"Teller: loan not liquidated\\\"\\n );\\n\\n // if the lending reward is less than the collateral lending tokens, then aggregate\\n // the value for the lending token with the collateral token and send it to the liquidator\\n if (rewardInLending <= collateralInLending) {\\n uint256 rewardInCollateral =\\n PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n rewardInLending\\n );\\n\\n LibCollateral.withdraw(loanID, rewardInCollateral, liquidator);\\n } else {\\n // Payout whats available in the collateral token\\n LibCollateral.withdraw(loanID, collateralAmount, liquidator);\\n\\n // Claim remaining reward value from the loan escrow\\n claimEscrowTokensByValue(\\n loanID,\\n liquidator,\\n rewardInLending - collateralInLending\\n );\\n }\\n }\\n\\n /**\\n * @dev Send the equivalent of tokens owned by the loan escrow (in lending value) to the recipient,\\n * @param loanID The loan ID to clam tokens from\\n * @param recipient address to send the tokens to\\n * @param value The value of escrow held tokens to be claimed based in lending value\\n */\\n function claimEscrowTokensByValue(\\n uint256 loanID,\\n address recipient,\\n uint256 value\\n ) private {\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n uint256 valueLeftToTransfer = value;\\n\\n // Start with the lending token\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n LibLoans.loan(loanID).lendingToken,\\n recipient,\\n valueLeftToTransfer\\n );\\n\\n // Cycle through remaining tokens\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n if (valueLeftToTransfer == 0) {\\n return;\\n }\\n\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n EnumerableSet.at(tokens, i),\\n recipient,\\n valueLeftToTransfer\\n );\\n }\\n }\\n\\n /**\\n * @notice it claims the escrow tokens for the liquidator\\n * @notice it keeps claiming escrow tokens until there aren't anymore tokens or the valueLeftToTransfer is zero\\n * @param loanID the identifier of the escrow loan to claim tokens from\\n * @param token the address of the token asset to claim\\n * @param recipient the address of the recipient to transfer the tokens to\\n * @param valueLeftToTransfer the value left to transfer to the liquidator that is returned back\\n * @return the value left to transfer\\n */\\n function claimEscrowToken(\\n uint256 loanID,\\n address token,\\n address recipient,\\n uint256 valueLeftToTransfer\\n ) private returns (uint256) {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n // get value of token balance in lending value\\n if (balance > 0) {\\n // If token not the lending token, get value of token\\n uint256 balanceInLending;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n balanceInLending = balance;\\n } else {\\n balanceInLending = PriceAggLib.valueFor(\\n token,\\n LibLoans.loan(loanID).lendingToken,\\n balance\\n );\\n }\\n\\n if (balanceInLending <= valueLeftToTransfer) {\\n LibEscrow.e(loanID).claimToken(token, recipient, balance);\\n valueLeftToTransfer -= balanceInLending;\\n } else {\\n // Token balance is more than enough so calculate ratio of balance to transfer\\n uint256 valueToTransfer;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n valueToTransfer = valueLeftToTransfer;\\n } else {\\n valueToTransfer = NumbersLib.percent(\\n balance,\\n NumbersLib.ratioOf(\\n valueLeftToTransfer,\\n balanceInLending\\n )\\n );\\n }\\n\\n LibEscrow.e(loanID).claimToken(\\n token,\\n recipient,\\n valueToTransfer\\n );\\n valueLeftToTransfer = 0;\\n }\\n }\\n return valueLeftToTransfer;\\n }\\n}\\n\",\"keccak256\":\"0xc440b61519f74c4eba549f1f531726b1cd8b3da60ba7654cccd4eb9bd9fd7020\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n /**\\n * @notice it initializes an escrow\\n * @param tokenAddress the address of the collateral token to be stored\\n * @param isWETH check if it's wrapped Ethereum\\n */\\n function init(address tokenAddress, bool isWETH) external;\\n\\n /**\\n * @notice it deposits an amount of the respective collateral token into the escrow\\n * @param loanID the ID of the loan\\n * @param amount the amount of collateral tokens to be deposited\\n */\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n /**\\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\\n * @dev only the TellerDiamond can make this call on behalf of the borrower\\n * @param loanID identifier of the loan\\n * @param amount number of collateral tokens to send\\n * @param receiver payable address to transfer money to\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n /**\\n * @notice it returns the supply of the respective loan\\n * @param loanID the respective loan ID\\n * @return supply_ the amount in collateral of the respective loan\\n */\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n /**\\n * @notice it returns the total supply of the collateral token held by the contract\\n * @return supply_ the total amount of collateral\\n */\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x900fed2311f919ba1451a6583ddbf9f3bc8afa8f5189500fff51f0c049258ed3\",\"license\":\"MIT\"},\"contracts/market/libraries/LibCollateral.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport { ICollateralEscrow } from \\\"../collateral/ICollateralEscrow.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\nimport { MarketStorageLib } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibCollateral {\\n /**\\n * @notice This event is emitted when collateral has been deposited for the loan\\n * @param loanID ID of the loan for which collateral was deposited\\n * @param depositor Account that deposited funds\\n * @param amount Amount of collateral deposited\\n */\\n event CollateralDeposited(\\n uint256 indexed loanID,\\n address indexed depositor,\\n uint256 amount\\n );\\n\\n /**\\n * @notice This event is emitted when collateral has been withdrawn\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param receiver Account that received funds\\n * @param amount Value of collateral withdrawn\\n */\\n event CollateralWithdrawn(\\n uint256 indexed loanID,\\n address indexed receiver,\\n uint256 amount\\n );\\n\\n /**\\n * @notice it gets MarketStorage's collateral escrow using the loanID\\n * @param loanID the loanID to be used\\n * @return c_ which is the collateral escrow\\n */\\n function e(uint256 loanID) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[\\n MarketStorageLib.store().loans[loanID].collateralToken\\n ];\\n }\\n\\n function e(address token) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[token];\\n }\\n\\n /**\\n * @notice it deposits an amount of collateral into a collateral escrow's address of a respective loan\\n * @param loanID the respective loan ID\\n * @param amount the amount of collateral to deposit\\n */\\n function deposit(uint256 loanID, uint256 amount) internal {\\n e(loanID).deposit{ value: amount }(loanID, amount);\\n\\n emit CollateralDeposited(loanID, msg.sender, amount);\\n }\\n\\n /**\\n * @notice it withdraws an amount from the collateral escrow\\n * @param loanID the respective loanID to withdraw from\\n * @param amount the number of collateral tokens to withdraw\\n * @param receiver the address who receives the withdrawal\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) internal {\\n e(loanID).withdraw(loanID, amount, receiver);\\n\\n emit CollateralWithdrawn(loanID, receiver, amount);\\n }\\n\\n /**\\n * @notice it withdraws the entire supply in collateral of a respective loan to an address\\n * @param loanID the respective loan's ID\\n * @param receiver the address of the receiver to withdraw tokens from\\n */\\n function withdrawAll(uint256 loanID, address payable receiver) internal {\\n withdraw(loanID, e(loanID).loanSupply(loanID), receiver);\\n }\\n\\n /**\\n * @notice it initializes a new escrow collateral to hold collateral tokens\\n * @param token address of the collateral token it holds\\n */\\n function createEscrow(address token) internal {\\n // Check if collateral escrow exists\\n if (address(e(token)) == address(0)) {\\n // Create escrow\\n address escrow =\\n AppStorageLib.store().collateralEscrowBeacon.cloneProxy(\\\"\\\");\\n ICollateralEscrow(escrow).init(\\n token,\\n // Check if collateral token is WETH\\n token == AppStorageLib.store().assetAddresses[\\\"WETH\\\"]\\n );\\n\\n // Set max allowance\\n IERC20(token).approve(escrow, type(uint256).max);\\n // Save escrow address for loan\\n MarketStorageLib.store().collateralEscrows[\\n token\\n ] = ICollateralEscrow(escrow);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x84dbab8283357a1cc4210e34642fc8247841a58973778f4f6570398cc3046947\",\"license\":\"MIT\"},\"contracts/market/libraries/LibLoans.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibEscrow } from \\\"../../escrow/libraries/LibEscrow.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus,\\n LoanDebt,\\n LoanTerms\\n} from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibLoans {\\n using NumbersLib for int256;\\n using NumbersLib for uint256;\\n\\n bytes32 internal constant ID = keccak256(\\\"LOANS\\\");\\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n * @notice it returns the loan\\n * @param loanID the ID of the respective loan\\n * @return l_ the loan \\n */\\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\\n l_ = s().loans[loanID];\\n }\\n\\n /**\\n * @notice it returns the loan debt from a respective loan\\n * @param loanID the ID of the respective loan\\n * @return d_ the loan debt from a respective loan\\n */\\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\\n d_ = s().loanDebt[loanID];\\n }\\n\\n // DEPRECATED\\n function terms(uint256 loanID)\\n internal\\n view\\n returns (LoanTerms storage t_)\\n {\\n t_ = s()._loanTerms[loanID];\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return owed_ uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID)\\n internal\\n view\\n returns (uint256 owed_)\\n {\\n if (loan(loanID).status == LoanStatus.Active) {\\n owed_ = debt(loanID).principalOwed + (debt(loanID).interestOwed);\\n }\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n internal\\n view\\n returns (uint256)\\n {\\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\\n }\\n \\n function getCollateralNeeded(uint256 loanID)\\n internal\\n view\\n returns (uint256 _needed)\\n {\\n (, _needed, ) = getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the total collateral needed in lending tokens, in collateral tokens and in escrowed loan values\\n * @param loanID the loanID to get the total collateral needed\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n internal\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\\n loanID\\n );\\n\\n // check if needed lending tokens is zero. if true, then needed collateral tokens is zero. else,\\n if (neededInLendingTokens == 0) {\\n neededInCollateralTokens = 0;\\n } else {\\n neededInCollateralTokens = PriceAggLib.valueFor(\\n loan(loanID).lendingToken,\\n loan(loanID).collateralToken,\\n neededInLendingTokens\\n );\\n }\\n }\\n\\n /**\\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\\n * @param loanID The loan ID to get needed collateral info for.\\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\\n */\\n function getCollateralNeededInTokens(uint256 loanID)\\n internal\\n view\\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\\n {\\n if (loan(loanID).collateralRatio == 0) {\\n return (0, 0);\\n }\\n\\n /*\\n The collateral to principal owed ratio is the sum of:\\n * collateral buffer percent\\n * loan interest rate\\n * liquidation reward percent\\n * X factor of additional collateral\\n */\\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n neededInLendingTokens = loan(loanID).borrowedAmount.percent(\\n loan(loanID).collateralRatio\\n );\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n uint16 requiredRatio =\\n loan(loanID).collateralRatio -\\n getInterestRatio(loanID) -\\n uint16(PlatformSettingsLib.getCollateralBufferValue());\\n\\n neededInLendingTokens =\\n debt(loanID).principalOwed +\\n debt(loanID).interestOwed;\\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\\n if (\\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\\n ) {\\n neededInLendingTokens -= escrowLoanValue;\\n }\\n neededInLendingTokens = neededInLendingTokens.percent(\\n requiredRatio\\n );\\n }\\n }\\n\\n /**\\n * @notice check if a loan can go to end of auction with a collateral ratio\\n * @return bool checking if collateralRatio is >= the over collateralized buffer value\\n */\\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\\n internal\\n view\\n returns (bool)\\n {\\n return\\n collateralRatio >=\\n PlatformSettingsLib.getOverCollateralizedBufferValue();\\n }\\n\\n /**\\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\\n * @notice There is a minimum threshold of 1%.\\n * @dev The interest rate is APY (annual percentage yield).\\n * @param loanID The loan ID to get the interest rate for.\\n */\\n function getInterestRatio(uint256 loanID)\\n internal\\n view\\n returns (uint16 ratio_)\\n {\\n ratio_ = uint16(\\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\\n SECONDS_PER_YEAR\\n );\\n\\n if (ratio_ == 0) {\\n ratio_ = 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0xe48b287a583b40e534654e4023422f59a9e6d7dd265d68ae4af43f8da58c09d9\",\"license\":\"MIT\"},\"contracts/nft/IStakeableNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IStakeableNFT {\\n function tokenBaseLoanSize(uint256 tokenId) external view returns (uint256);\\n\\n function tokenURIHash(uint256 tokenId)\\n external\\n view\\n returns (string memory);\\n\\n function tokenContributionAsset(uint256 tokenId)\\n external\\n view\\n returns (address);\\n\\n function tokenContributionSize(uint256 tokenId)\\n external\\n view\\n returns (uint256);\\n\\n function tokenContributionMultiplier(uint256 tokenId)\\n external\\n view\\n returns (uint8);\\n}\\n\",\"keccak256\":\"0xfbf44350ad91a54de26f39195d714580d7dade556ea4c7991a51eef5aa839105\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x417b75f5d92be67993efc54db7d453be5b5058a9a54d8916380e0281d3299526\",\"license\":\"MIT\"},\"contracts/nft/TellerNFTDictionary.sol\":{\"content\":\"/**\\n * @notice TellerNFTDictionary Version 1.02\\n *\\n * @notice This contract is used to gather data for TellerV1 NFTs more efficiently.\\n * @notice This contract has data which must be continuously synchronized with the TellerV1 NFT data\\n *\\n * @author develop@teller.finance\\n */\\n\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Interfaces\\nimport \\\"./IStakeableNFT.sol\\\";\\n\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFTDictionary is IStakeableNFT, AccessControlUpgradeable {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n mapping(uint256 => uint256) public baseLoanSizes;\\n mapping(uint256 => string[]) public hashes;\\n mapping(uint256 => address) public contributionAssets;\\n mapping(uint256 => uint256) public contributionSizes;\\n mapping(uint256 => uint8) public contributionMultipliers;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n\\n /* State Variables */\\n\\n mapping(uint256 => uint256) public _tokenTierMappingCompressed;\\n bool public _tokenTierMappingCompressedSet;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFTDictionary: not admin\\\");\\n _;\\n }\\n\\n function initialize(address initialAdmin) public {\\n _setupRole(ADMIN, initialAdmin);\\n _setRoleAdmin(ADMIN, ADMIN);\\n\\n __AccessControl_init();\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTierIndex(uint256 tokenId)\\n public\\n view\\n returns (uint8 index_)\\n {\\n //32 * 8 = 256 - each uint256 holds the data of 32 tokens . 8 bits each.\\n\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 compressedRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n //use 31 instead of 32 to account for the '0x' in the start.\\n //the '31 -' reverses our bytes order which is necessary\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint8 tierIndex = uint8((compressedRegister >> offset));\\n\\n return tierIndex;\\n }\\n\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory)\\n {\\n return hashes[tierIndex];\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTier(uint256 index, Tier memory newTier)\\n external\\n onlyAdmin\\n returns (bool)\\n {\\n baseLoanSizes[index] = newTier.baseLoanSize;\\n hashes[index] = newTier.hashes;\\n contributionAssets[index] = newTier.contributionAsset;\\n contributionSizes[index] = newTier.contributionSize;\\n contributionMultipliers[index] = newTier.contributionMultiplier;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param tiersMapping Information about the new tiers to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setAllTokenTierMappings(uint256[] memory tiersMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n require(\\n !_tokenTierMappingCompressedSet,\\n \\\"TellerNFTDictionary: token tier mapping already set\\\"\\n );\\n for (uint256 i = 0; i < tiersMapping.length; i++) {\\n _tokenTierMappingCompressed[i] = tiersMapping[i];\\n }\\n\\n _tokenTierMappingCompressedSet = true;\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param index the mapping row, each holds data for 32 tokens\\n * @param tierMapping Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierMapping(uint256 index, uint256 tierMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n _tokenTierMappingCompressed[index] = tierMapping;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenIds the NFT token Ids for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenIds(\\n uint256[] calldata tokenIds,\\n uint256 tokenTier\\n ) public onlyAdmin returns (bool) {\\n for (uint256 i; i < tokenIds.length; i++) {\\n setTokenTierForTokenId(tokenIds[i], tokenTier);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenId the NFT token Id for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenId(uint256 tokenId, uint256 tokenTier)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 existingRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint256 updateMaskShifted =\\n 0x00000000000000000000000000000000000000000000000000000000000000FF <<\\n offset;\\n\\n uint256 updateMaskShiftedNegated = ~updateMaskShifted;\\n\\n uint256 tokenTierShifted =\\n ((0x0000000000000000000000000000000000000000000000000000000000000000 |\\n tokenTier) << offset);\\n\\n uint256 existingRegisterClearedWithMask =\\n existingRegister & updateMaskShiftedNegated;\\n\\n uint256 updatedRegister =\\n existingRegisterClearedWithMask | tokenTierShifted;\\n\\n _tokenTierMappingCompressed[mappingIndex] = updatedRegister;\\n\\n return true;\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(IStakeableNFT).interfaceId ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n New methods for the dictionary\\n */\\n\\n /**\\n * @notice It returns Base Loan Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenBaseLoanSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return baseLoanSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Token URI Hash for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenURIHash(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n string[] memory tierImageHashes = hashes[tokenTier];\\n return tierImageHashes[tokenId % (tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice It returns Contribution Asset for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionAsset(uint256 tokenId)\\n public\\n view\\n override\\n returns (address)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionAssets[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Multiplier for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionMultiplier(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint8)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionMultipliers[tokenTier];\\n }\\n}\\n\",\"keccak256\":\"0xf33e3fa1f609fdd2abb3b5fb9c232269d13363a3e4fa5697ea96269e361e74fa\"},\"contracts/nft/libraries/NFTLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../TellerNFT.sol\\\";\\n\\n// Libraries\\nimport {\\n MerkleProof\\n} from \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\nimport { NFTStorageLib, NFTStorage } from \\\"../../storage/nft.sol\\\";\\n\\nlibrary NFTLib {\\n function s() internal pure returns (NFTStorage storage s_) {\\n s_ = NFTStorageLib.store();\\n }\\n\\n function nft() internal view returns (TellerNFT nft_) {\\n nft_ = AppStorageLib.store().nft;\\n }\\n\\n /**s\\n * @notice it transfers the NFT from the sender to the diamond to stake then adds the NFTID to the list of the owner's stakedNFTs\\n * @param nftID the ID of the NFT to stake\\n * @param owner the owner of the NFT who will stake the NFT\\n */\\n function stake(uint256 nftID, address owner) internal {\\n // Transfer to diamond\\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\\n // Add NFT ID to user set\\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\\n }\\n\\n /**\\n * @notice it unstakes the NFT by removing the NFT ID from the list of the user's staked NFTs\\n * @param nftID the ID of the NFT to remove from the list of the user's staked NFTs\\n * @return success_ the boolean value telling us if the user has unsuccessfully unstaked the NFT\\n */\\n function unstake(uint256 nftID) internal returns (bool success_) {\\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\\n }\\n\\n /**\\n * @notice it gets the list of staked NFTs from the owner\\n * @param nftOwner the owner of the staked NFTs to pull from\\n * @return staked_ the array of the staked NFTs owned by the user\\n */\\n function stakedNFTs(address nftOwner)\\n internal\\n view\\n returns (uint256[] memory staked_)\\n {\\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\\n staked_ = new uint256[](EnumerableSet.length(nfts));\\n for (uint256 i; i < staked_.length; i++) {\\n staked_[i] = EnumerableSet.at(nfts, i);\\n }\\n }\\n\\n /**\\n * @notice if the user fails to pay his loan, then we liquidate the all the NFTs associated with the loan\\n * @param loanID the identifier of the loan to liquidate the NFTs from\\n */\\n function liquidateNFT(uint256 loanID) internal {\\n // Check if NFTs are linked\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n NFTLib.nft().transferFrom(\\n address(this),\\n AppStorageLib.store().nftLiquidationController,\\n EnumerableSet.at(nfts, i)\\n );\\n }\\n }\\n\\n /**\\n * @notice it unstakes an NFT and verifies the proof in order to apply the proof to a loan\\n * @param loanID the identifier of the loan\\n * @param nftID the NFT ID to apply to the loan\\n */\\n function applyToLoan(uint256 loanID, uint256 nftID) internal {\\n // NFT must be currently staked\\n // Remove NFT from being staked - returns bool\\n require(unstake(nftID), \\\"Teller: borrower nft not staked\\\");\\n\\n // Apply NFT to loan\\n EnumerableSet.add(s().loanNFTs[loanID], nftID);\\n }\\n\\n /**\\n * @notice it finds the loan's NFTs and adds them back to the owner's list of staked NFTs\\n * @param loanID the identifier of the respective loan to add the NFTs back to the user's staked NFTs\\n * @param owner the owner to add the unstaked NFTs back to the staked pile\\n */\\n function restakeLinked(uint256 loanID, address owner) internal {\\n // Get linked NFT\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n // Restake the NFT\\n EnumerableSet.add(s().stakedNFTs[owner], EnumerableSet.at(nfts, i));\\n }\\n }\\n}\\n\",\"keccak256\":\"0xccbd35c6e8d0130b38f5025ee81c47d55e4fa48c8fcb8bec6f70c21061e0ce61\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n /**\\n * @notice it returns 10^{numberOfDecimals} for a token\\n * @param token the address to calculate the decimals for\\n * @return 10^number of decimals used to calculate the price and value of different token pairs\\n */\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @notice It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @notice it tries to calculate a price from Compound and Chainlink.\\n * @dev if no price is found on compound, then calculate it on chainlink\\n * @param src the token address to calculate the price for in dst\\n * @param dst the token address to retrieve the price of src\\n * @return price_ the price of src in dst\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n * @param src the address of the src token\\n * @param dst the address of the dst token\\n * @return the price of the src token in dst token\\n\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n * @param src the source token to calculate price for with chainlink\\n * @param dst the destination token to calculate price for with chainlink\\n * @param cRate the compound rate to multiply with the price of the dst token\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @notice Scales the {value} by the difference in decimal values.\\n * @param value the the value of the src in dst\\n * @param srcDecimals src token decimals\\n * @param dstDecimals dst token decimals\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @notice it tries to calculate the price of {src} in {dst}\\n * @param src address of source token\\n * @param dst address of destination token\\n * @return the price of src token in dst\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address WETH = AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n if (dst != WETH) {\\n int256 price1 = _priceFor(src, WETH);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, WETH);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice it checks if a token is a cToken. If it is, then get the underlying address\\n * @param token address of the token\\n * @return isCToken boolean whether it's a cToken\\n * @return underlying the address of the cToken\\n */\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2efb3d71a1c0fb49f8c455c4fa30d04c69a1617d619035fc400dabdeb2ab0c9e\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { PriceAggFacet } from \\\"./PriceAggFacet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\n/**\\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\\n */\\nlibrary PriceAggLib {\\n /**\\n * @notice It calculates the value of one token amount into another\\n * @param src the source token\\n * @param dst the destination token\\n * @param srcAmount the amount of source token\\n * @return value_ the returned value of src in dst\\n */\\n function valueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) internal view returns (uint256 value_) {\\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\\n }\\n\\n /**\\n * @notice It returns the price of the token pair as given from Compound.\\n * @dev if no compound price is calculated, then it checks Chainlink price Aggregator\\n * @param src the address of the source token\\n * @param dst the address of the desitnation token\\n * @return price_ gets the price of src in dst\\n */\\n function priceFor(address src, address dst)\\n internal\\n view\\n returns (int256 price_)\\n {\\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\\n }\\n}\\n\",\"keccak256\":\"0xff59eee567fa4a7f5cac432e31d918be92834f04614f49572d3984a5b030ac79\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\nabstract contract PausableMods {\\n /**\\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\\n * @param id id of the facet to check if is paused.\\n * @param state Boolean that the protocol AND facet should be in.\\n */\\n modifier paused(bytes32 id, bool state) {\\n require(\\n __isPaused(\\\"\\\") == state && __isPaused(id) == state,\\n __pausedMessage(state)\\n );\\n _;\\n }\\n\\n /**\\n * @dev Checks if the given id is paused.\\n * @param id Encoded id of the facet to check if is paused.\\n * @return the bool to tell us if the facet is paused (true) or not (false)\\n */\\n function __isPaused(bytes32 id) private view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n\\n /**\\n * @dev Gets the message that should be reverted with given a state it should be in.\\n * @param state Boolean that an id should be in.\\n * @return a message stating whether the facet is paused or not\\n */\\n function __pausedMessage(bool state) private pure returns (string memory) {\\n return state ? \\\"Pausable: not paused\\\" : \\\"Pausable: paused\\\";\\n }\\n}\\n\",\"keccak256\":\"0x2d3f848ee56ae5fa365539c2509c03c167affc89c89f98bb98cb9b83fbe8ae4c\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"NFTInterestRate\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getNFTInterestRate() internal view returns (uint16 value_) {\\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0x44294be1af9f913b2ed391a40cd4b646537a4b463b8d5ff1fac8ead3988966c1\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for loans taken out with an NFT.\\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\\n */\\nbytes32 constant NFT_INTEREST_RATE = keccak256(\\\"NFTInterestRate\\\");\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xd68a7df42b2bbba6f935d5890b7b37997c1432e25ae113827b8bde87f94fd86f\",\"license\":\"MIT\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n /**\\n * @notice Checks if the account should be allowed to mint tokens in the given market\\n * @param cToken The market to verify the mint against\\n * @param minter The account which would get the minted tokens\\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates mint and reverts on rejection. May emit logs.\\n * @param cToken Asset being minted\\n * @param minter The address minting the tokens\\n * @param mintAmount The amount of the underlying asset being minted\\n * @param mintTokens The number of tokens being minted\\n */\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to redeem tokens in the given market\\n * @param cToken The market to verify the redeem against\\n * @param redeemer The account which would redeem the tokens\\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates redeem and reverts on rejection. May emit logs.\\n * @param cToken Asset being redeemed\\n * @param redeemer The address redeeming the tokens\\n * @param redeemAmount The amount of the underlying asset being redeemed\\n * @param redeemTokens The number of tokens being redeemed\\n */\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\\n * @param cToken The market to verify the borrow against\\n * @param borrower The account which would borrow the asset\\n * @param borrowAmount The amount of underlying the account would borrow\\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates borrow and reverts on rejection. May emit logs.\\n * @param cToken Asset whose underlying is being borrowed\\n * @param borrower The address borrowing the underlying\\n * @param borrowAmount The amount of the underlying asset requested to borrow\\n */\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to repay a borrow in the given market\\n * @param cToken The market to verify the repay against\\n * @param payer The account which would repay the asset\\n * @param borrower The account which would borrowed the asset\\n * @param repayAmount The amount of the underlying asset the account would repay\\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\\n * @param cToken Asset being repaid\\n * @param payer The address repaying the borrow\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param borrowerIndex the index of the borrower\\n */\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n /**\\n * @notice Checks if the liquidation should be allowed to occur\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n */\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the seizing of assets should be allowed to occur\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates seize and reverts on rejection. May emit logs.\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to transfer tokens in the given market\\n * @param cToken The market to verify the transfer against\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates transfer and reverts on rejection. May emit logs.\\n * @param cToken Asset being transferred\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n */\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in all markets\\n * @param holder The address to claim COMP for\\n */\\n function claimComp(address holder) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in the specified markets\\n * @param holder The address to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n */\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n /**\\n * @notice Claim all comp accrued by the holders\\n * @param holders The addresses to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n * @param borrowers Whether or not to claim COMP earned by borrowing\\n * @param suppliers Whether or not to claim COMP earned by supplying\\n */\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n /**\\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\\n * @param cTokenBorrowed The address of the borrowed cToken\\n * @param cTokenCollateral The address of the collateral cToken\\n * @param repayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\\n */\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n /**\\n * @notice Return the address of the COMP token\\n * @return The address of COMP\\n */\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x38a824a4a21ce9370fa581a616d1bb9d311f27d8982a6b96ebeba90bd5fd0adb\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n \\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x37849041e4bee2dfa825677f69078521fcc94804aa5120f67dd12cc4133efcec\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @dev CETH is the only Compound token that does not support the {underlying} function.\\n * @param cToken address of the compound token\\n * @return address of the underlying cToken\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x99206384c27b0e68b1ec7b82260f6a47965f611875c018bc076ff8a688a6c6d7\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n /**\\n * @notice it returns the absolute number of a specified parameter\\n * @param self the number to be returned in it's absolute \\n * @return the absolute number\\n */\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0xa852b8866a3d6d928c6575bf2bcf2ae784eed73717c78c0cadbdedf8b0ba3274\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0c52fdd76b33f74e233c3a27dd3b73b134e9643aab347b3aa649c504809c6559\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\n// DEPRECATED\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\nstruct LoanRequest {\\n LoanUserRequest request;\\n LoanConsensusResponse[] responses;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanUserRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanConsensusResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) _loanTerms; // DEPRECATED: DO NOT REMOVE\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb7e05aeec806b5621512def93f4a389b4ef88c50ef9fe7115a33f57db2f2304b\",\"license\":\"MIT\"},\"contracts/storage/nft.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"../nft/TellerNFTDictionary.sol\\\";\\n\\n// Utils\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct NFTStorage {\\n // Maps NFT owner to set of token IDs owned\\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\\n // Maps loanID to NFT IDs indicating NFT being used for the loan\\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\\n // Merkle root used for verifying nft IDs to base loan size\\n TellerNFTDictionary nftDictionary;\\n}\\n\\nbytes32 constant NFT_STORAGE_POS = keccak256(\\\"teller.staking.storage\\\");\\n\\nlibrary NFTStorageLib {\\n function store() internal pure returns (NFTStorage storage s) {\\n bytes32 pos = NFT_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd44f213be3125ea2e2de120c241832f1861be18b3ff2fd4c3baa52ea20b94812\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "history": [ + { + "address": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "RepayFacet", + "transactionHash": "0x44d6b974ec21f1c4420ecb2be53506c60d1abe4b5fac2a2b5352ae4a3fb3bb5d", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "transactionIndex": 0, + "gasUsed": "1838004", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xecd0c4fcd32a0e212c29bf1a50f9095c4551299b06f40b8cb32c08eeeb3ab526", + "transactionHash": "0x44d6b974ec21f1c4420ecb2be53506c60d1abe4b5fac2a2b5352ae4a3fb3bb5d", + "logs": [], + "blockNumber": 25103793, + "cumulativeGasUsed": "1838004", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "dc3b3c0336b59a4fae33a8cd036a81b5", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"liquidator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"reward\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokensIn\",\"type\":\"uint256\"}],\"name\":\"LoanLiquidated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountPaid\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"totalOwed\",\"type\":\"uint256\"}],\"name\":\"LoanRepaid\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"escrowRepay\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLiquidationReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"inLending_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"inCollateral_\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"liquidateLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"repayLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"params\":{\"borrower\":\"Account address of the borrower\",\"liquidator\":\"Account address of the liquidator\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"reward\":\"Value in lending token paid out to liquidator\",\"tokensIn\":\"Percentage of the collateral price paid by the liquidator to the lending pool\"}},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"params\":{\"amountPaid\":\"Amount of the loan paid back\",\"borrower\":\"Account address of the borrower\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"payer\":\"Account address of the payer\",\"totalOwed\":\"Total amount of the loan to be repaid\"}}},\"kind\":\"dev\",\"methods\":{\"escrowRepay(uint256,uint256)\":{\"details\":\"If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\",\"params\":{\"amount\":\"The amount being repaid.\",\"loanID\":\"The id of the loan being used.\"}},\"getLiquidationReward(uint256)\":{\"params\":{\"loanID\":\"The loan ID to get the info.\"},\"returns\":{\"inCollateral_\":\"The value the liquidator will receive denoted in collateral tokens.\",\"inLending_\":\"The value the liquidator will receive denoted in lending tokens.\"}},\"liquidateLoan(uint256)\":{\"params\":{\"loanID\":\"The ID of the loan to be liquidated\"}},\"repayLoan(uint256,uint256)\":{\"params\":{\"amount\":\"The amount of tokens to pay back to the loan\",\"loanID\":\"The ID of the loan the payment is for\"}}},\"version\":1},\"userdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully liquidated\"},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully repaid\"}},\"kind\":\"user\",\"methods\":{\"escrowRepay(uint256,uint256)\":{\"notice\":\"Repay this Escrow's loan.\"},\"getLiquidationReward(uint256)\":{\"notice\":\"It gets the current liquidation reward for a given loan.\"},\"liquidateLoan(uint256)\":{\"notice\":\"Liquidate a loan if it is expired or under collateralized\"},\"repayLoan(uint256,uint256)\":{\"notice\":\"Make a payment to a loan\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/market/RepayFacet.sol\":\"RepayFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Trees proofs.\\n *\\n * The proofs can be generated using the JavaScript library\\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\\n *\\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n bytes32 computedHash = leaf;\\n\\n for (uint256 i = 0; i < proof.length; i++) {\\n bytes32 proofElement = proof[i];\\n\\n if (computedHash <= proofElement) {\\n // Hash(current computed hash + current element of the proof)\\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\\n } else {\\n // Hash(current element of the proof + current computed hash)\\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\\n }\\n }\\n\\n // Check if the computed hash (root) is equal to the provided root\\n return computedHash == root;\\n }\\n}\\n\",\"keccak256\":\"0xeee34bfb413657b6cd6c8e1e15c2080ba5ebaac479578515922804346fb63f7c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/reentry/ReentryMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nabstract contract ReentryMods {\\n modifier nonReentry(bytes32 id) {\\n AccessControlStorage storage s = AccessControlStorageLib.store();\\n require(!s.entered[id], \\\"AccessControl: reentered\\\");\\n s.entered[id] = true;\\n _;\\n s.entered[id] = false;\\n }\\n}\\n\",\"keccak256\":\"0x033c1164af25ef7d35a38a60973bf379b1cc603596914ffd85dcbcf0acdb6970\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../interfaces/IAToken.sol\\\";\\nimport { IAaveLendingPool } from \\\"../interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x8030b206c87d0073fb7dbebfa2ee8a3e93c479d976d6cdaa0c939f2fedaa1525\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n function setTokenAllowance(address token, address spender) external;\\n\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xdaa338698014e6c00edf7a2aca49026a047e253cbe7fc392a73f5f63a063a7f9\",\"license\":\"MIT\"},\"contracts/escrow/libraries/LibEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibDapps } from \\\"../dapps/libraries/LibDapps.sol\\\";\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibEscrow {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\\n e_ = s().loanEscrows[loanID];\\n }\\n\\n function getEscrowTokens(uint256 loanID)\\n internal\\n view\\n returns (EnumerableSet.AddressSet storage t_)\\n {\\n t_ = s().escrowTokens[loanID];\\n }\\n\\n function balanceOf(uint256 loanID, address token)\\n internal\\n view\\n returns (uint256)\\n {\\n return IERC20(token).balanceOf(address(e(loanID)));\\n }\\n\\n /**\\n * @notice Adds or removes tokens held by the Escrow contract\\n * @param loanID The loan ID to update the token list for\\n * @param tokenAddress The token address to be added or removed\\n */\\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\\n // Skip if is lending token\\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\\n\\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\\n if (balanceOf(loanID, tokenAddress) > 0) {\\n if (!contains) {\\n EnumerableSet.add(tokens, tokenAddress);\\n }\\n } else if (contains) {\\n EnumerableSet.remove(tokens, tokenAddress);\\n }\\n }\\n\\n /**\\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\\n * @param loanID The loan ID to calculate value for\\n * @return value_ Escrow total value denoted in the lending token.\\n */\\n function calculateTotalValue(uint256 loanID)\\n internal\\n view\\n returns (uint256 value_)\\n {\\n address lendingToken = LibLoans.loan(loanID).lendingToken;\\n value_ += balanceOf(loanID, lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\\n if (EnumerableSet.length(tokens) > 0) {\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n uint256 tokenBal =\\n balanceOf(loanID, EnumerableSet.at(tokens, i));\\n value_ += PriceAggLib.valueFor(\\n EnumerableSet.at(tokens, i),\\n lendingToken,\\n tokenBal\\n );\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xcca97599fff1c1bd608e7f11c4674f325e43781794e91bf5322ac9e0ffd7b3df\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when an user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when an user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @return totalSupply_ The total value of the underlying token managed by the LP.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given markets.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider o the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfil the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n */\\n function restrict(bool state) external virtual;\\n\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xe6515c78e0277edbed82aa6926df727afd216379dd0bfbbb790222654c858499\",\"license\":\"MIT\"},\"contracts/market/LoanDataFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { Loan, LoanDebt, LoanTerms } from \\\"../storage/market.sol\\\";\\n\\ncontract LoanDataFacet {\\n /**\\n * @notice Returns the information about the given {loanID}.\\n * @param loanID The loan ID to get information for.\\n * @return loan_ The loan data.\\n */\\n function getLoan(uint256 loanID) external view returns (Loan memory loan_) {\\n loan_ = LibLoans.s().loans[loanID];\\n }\\n\\n /**\\n * @notice Returns the terms for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanTerms The terms that the loan weer created with.\\n */\\n function getLoanTerms(uint256 loanID)\\n external\\n view\\n returns (LoanTerms memory)\\n {\\n return LibLoans.terms(loanID);\\n }\\n\\n /**\\n * @notice Returns the loan IDs created by the {borrower} account.\\n * @param borrower The account to get loan IDs for.\\n * @return loanIDs The IDs for loans created by the {borrower}\\n */\\n function getBorrowerLoans(address borrower)\\n external\\n view\\n returns (uint128[] memory loanIDs)\\n {\\n return LibLoans.s().borrowerLoans[borrower];\\n }\\n\\n /**\\n * @notice Returns the debt owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanDebt The principal and interest owed amount.\\n */\\n function getDebtOwed(uint256 loanID)\\n external\\n view\\n returns (LoanDebt memory)\\n {\\n return LibLoans.debt(loanID);\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) external view returns (uint256) {\\n return LibLoans.getTotalOwed(loanID);\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n external\\n view\\n returns (uint256)\\n {\\n return LibLoans.getInterestOwedFor(loanID, amountBorrow);\\n }\\n\\n function getCollateralNeededInfo(uint256 loanID)\\n external\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n return LibLoans.getCollateralNeededInfo(loanID);\\n }\\n\\n function getLoanEscrow(uint256 loanID)\\n external\\n view\\n returns (address escrow_)\\n {\\n escrow_ = address(LibLoans.s().loanEscrows[loanID]);\\n }\\n\\n function getLoanEscrowValue(uint256 loanID)\\n external\\n view\\n returns (uint256)\\n {\\n return LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n function getEscrowTokens(uint256 loanID)\\n external\\n view\\n returns (address[] memory tokens_)\\n {\\n EnumerableSet.AddressSet storage escrowTokens =\\n LibEscrow.getEscrowTokens(loanID);\\n tokens_ = new address[](EnumerableSet.length(escrowTokens));\\n for (uint256 i; i < tokens_.length; i++) {\\n tokens_[i] = EnumerableSet.at(escrowTokens, i);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf589a2afff647e5288e15f3f6614135395562b4d12c743402a6504a3fb9b39d6\",\"license\":\"MIT\"},\"contracts/market/RepayFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\nimport {\\n ReentryMods\\n} from \\\"../contexts2/access-control/reentry/ReentryMods.sol\\\";\\nimport { AUTHORIZED } from \\\"../shared/roles.sol\\\";\\nimport { LoanDataFacet } from \\\"./LoanDataFacet.sol\\\";\\n\\n// Libraries\\nimport {\\n IERC20,\\n SafeERC20\\n} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibCollateral } from \\\"./libraries/LibCollateral.sol\\\";\\nimport { LibDapps } from \\\"../escrow/dapps/libraries/LibDapps.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { NumbersLib } from \\\"../shared/libraries/NumbersLib.sol\\\";\\nimport { PriceAggLib } from \\\"../price-aggregator/PriceAggLib.sol\\\";\\nimport { NFTLib } from \\\"../nft/libraries/NFTLib.sol\\\";\\n\\n// Interfaces\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus\\n} from \\\"../storage/market.sol\\\";\\n\\ncontract RepayFacet is RolesMods, ReentryMods, PausableMods {\\n /**\\n @notice This event is emitted when a loan has been successfully repaid\\n @param loanID ID of loan from which collateral was withdrawn\\n @param borrower Account address of the borrower\\n @param amountPaid Amount of the loan paid back\\n @param payer Account address of the payer\\n @param totalOwed Total amount of the loan to be repaid\\n */\\n event LoanRepaid(\\n uint256 indexed loanID,\\n address indexed borrower,\\n uint256 amountPaid,\\n address payer,\\n uint256 totalOwed\\n );\\n\\n /**\\n * @notice This event is emitted when a loan has been successfully liquidated\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param borrower Account address of the borrower\\n * @param liquidator Account address of the liquidator\\n * @param reward Value in lending token paid out to liquidator\\n * @param tokensIn Percentage of the collateral price paid by the liquidator to the lending pool\\n */\\n event LoanLiquidated(\\n uint256 indexed loanID,\\n address indexed borrower,\\n address liquidator,\\n uint256 reward,\\n uint256 tokensIn\\n );\\n\\n /**\\n * @notice Repay this Escrow's loan.\\n * @dev If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.\\n * @dev Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\\n * @param loanID The id of the loan being used.\\n * @param amount The amount being repaid.\\n */\\n function escrowRepay(uint256 loanID, uint256 amount)\\n external\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n nonReentry(\\\"\\\")\\n {\\n uint256 balance =\\n LibEscrow.balanceOf(loanID, LibLoans.loan(loanID).lendingToken);\\n uint256 totalOwed = LibLoans.getTotalOwed(loanID);\\n if (balance < totalOwed && amount > balance) {\\n uint256 amountNeeded =\\n amount > totalOwed ? totalOwed - (balance) : amount - (balance);\\n\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n msg.sender,\\n address(LibEscrow.e(loanID)),\\n amountNeeded\\n );\\n }\\n\\n __repayLoan(loanID, amount, address(LibEscrow.e(loanID)), false);\\n }\\n\\n /**\\n * @notice Make a payment to a loan\\n * @param loanID The ID of the loan the payment is for\\n * @param amount The amount of tokens to pay back to the loan\\n */\\n function repayLoan(uint256 loanID, uint256 amount)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n __repayLoan(loanID, amount, msg.sender, false);\\n }\\n\\n function __repayLoan(\\n uint256 loanID,\\n uint256 amount,\\n address sender,\\n bool isLiquidation\\n ) private returns (uint256 leftToPay_) {\\n require(amount > 0, \\\"Teller: zero repay\\\");\\n\\n // calculate the actual amount to repay\\n leftToPay_ =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n if (leftToPay_ < amount) {\\n amount = leftToPay_;\\n leftToPay_ = 0;\\n } else {\\n leftToPay_ -= amount;\\n }\\n\\n // Get the Teller token for the loan\\n ITToken tToken =\\n MarketStorageLib.store().tTokens[\\n LibLoans.loan(loanID).lendingToken\\n ];\\n // Transfer funds from account\\n if (address(LibEscrow.e(loanID)) == sender) {\\n LibEscrow.e(loanID).claimToken(\\n LibLoans.loan(loanID).lendingToken,\\n address(tToken),\\n amount\\n );\\n } else {\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n sender,\\n address(tToken),\\n amount\\n );\\n }\\n\\n // Deduct the interest and principal owed\\n uint256 principalPaid;\\n uint256 interestPaid;\\n if (amount < LibLoans.debt(loanID).interestOwed) {\\n interestPaid = amount;\\n LibLoans.debt(loanID).interestOwed -= amount;\\n } else {\\n if (LibLoans.debt(loanID).interestOwed > 0) {\\n interestPaid = LibLoans.debt(loanID).interestOwed;\\n amount -= interestPaid;\\n LibLoans.debt(loanID).interestOwed = 0;\\n }\\n\\n if (amount > 0) {\\n principalPaid = amount;\\n LibLoans.debt(loanID).principalOwed -= amount;\\n }\\n }\\n\\n // Tell the Teller Token value has been deposited back into the pool.\\n tToken.repayLoan(principalPaid, interestPaid);\\n\\n if (isLiquidation) {\\n // Make sure there is nothing left to repay on the loan\\n require(leftToPay_ == 0, \\\"Teller: liquidate partial repay\\\");\\n\\n // Set loan status\\n LibLoans.loan(loanID).status = LoanStatus.Liquidated;\\n\\n // Transfer NFT if linked\\n NFTLib.liquidateNFT(loanID);\\n } else {\\n // if the loan is now fully paid, close it and withdraw borrower collateral\\n if (leftToPay_ == 0) {\\n LibLoans.loan(loanID).status = LoanStatus.Closed;\\n LibCollateral.withdrawAll(\\n loanID,\\n LibLoans.loan(loanID).borrower\\n );\\n // Restake any NFTs linked to loan for borrower\\n NFTLib.restakeLinked(loanID, LibLoans.loan(loanID).borrower);\\n }\\n\\n emit LoanRepaid(\\n loanID,\\n LibLoans.loan(loanID).borrower,\\n amount,\\n msg.sender,\\n leftToPay_\\n );\\n }\\n }\\n\\n /**\\n * @notice Liquidate a loan if it is expired or under collateralized\\n * @param loanID The ID of the loan to be liquidated\\n */\\n function liquidateLoan(uint256 loanID)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n uint256 collateralAmount = LibCollateral.e(loanID).loanSupply(loanID);\\n require(\\n RepayLib.isLiquidable(loanID, collateralAmount),\\n \\\"Teller: does not need liquidation\\\"\\n );\\n\\n // Calculate the reward before repaying the loan\\n (uint256 rewardInLending, uint256 collateralInLending) =\\n RepayLib.getLiquidationReward(loanID, collateralAmount);\\n\\n // The liquidator pays the amount still owed on the loan\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n __repayLoan(loanID, amountToLiquidate, msg.sender, true);\\n\\n // Payout the liquidator reward owed\\n if (rewardInLending > 0) {\\n RepayLib.payOutLiquidator(\\n loanID,\\n rewardInLending,\\n collateralInLending,\\n collateralAmount,\\n payable(msg.sender)\\n );\\n }\\n\\n emit LoanLiquidated(\\n loanID,\\n loan.borrower,\\n msg.sender,\\n rewardInLending,\\n amountToLiquidate\\n );\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @return inLending_ The value the liquidator will receive denoted in lending tokens.\\n * @return inCollateral_ The value the liquidator will receive denoted in collateral tokens.\\n */\\n function getLiquidationReward(uint256 loanID)\\n external\\n view\\n returns (uint256 inLending_, uint256 inCollateral_)\\n {\\n (inLending_, ) = RepayLib.getLiquidationReward(\\n loanID,\\n LibCollateral.e(loanID).loanSupply(loanID)\\n );\\n inCollateral_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n inLending_\\n );\\n }\\n}\\n\\nlibrary RepayLib {\\n /**\\n * @notice It checks if a loan can be liquidated.\\n * @param loanID The loan ID to check.\\n * @return true if the loan is liquidable.\\n */\\n function isLiquidable(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (bool)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n // Check if loan can be liquidated\\n if (loan.status != LoanStatus.Active) {\\n return false;\\n }\\n\\n if (loan.collateralRatio > 0) {\\n // If loan has a collateral ratio, check how much is needed\\n (, uint256 neededInCollateral, ) =\\n LoanDataFacet(address(this)).getCollateralNeededInfo(loanID);\\n if (neededInCollateral > collateralAmount) {\\n return true;\\n }\\n }\\n\\n // Otherwise, check if the loan has expired\\n return block.timestamp >= loan.loanStartTime + loan.duration;\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @param collateralAmount The amount of collateral for the {loanID}. Passed in to save gas calling the collateral escrow multiple times.\\n * @return reward_ The value the liquidator will receive denoted in lending tokens.\\n */\\n function getLiquidationReward(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (uint256 reward_, uint256 collateralValue_)\\n {\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n // Max reward is amount repaid on loan plus extra percentage\\n uint256 maxReward =\\n amountToLiquidate +\\n NumbersLib.percent(\\n amountToLiquidate,\\n uint16(PlatformSettingsLib.getLiquidateRewardPercent())\\n );\\n\\n // Calculate available collateral for reward\\n if (collateralAmount > 0) {\\n collateralValue_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).collateralToken,\\n LibLoans.loan(loanID).lendingToken,\\n collateralAmount\\n );\\n reward_ += collateralValue_;\\n }\\n\\n // Calculate loan escrow value if collateral not enough to cover reward\\n if (reward_ < maxReward) {\\n reward_ += LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n // Cap the reward to max\\n if (reward_ > maxReward) {\\n reward_ = maxReward;\\n }\\n }\\n\\n /**\\n * @notice Checks if the loan has an Escrow and claims any tokens then pays out the loan collateral.\\n * @dev See Escrow.claimTokens for more info.\\n * @param loanID The loan ID which is being liquidated\\n * @param rewardInLending The total amount of reward based in the lending token to pay the liquidator\\n * @param collateralInLending The amount of collateral that is available for the loan denoted in lending tokens\\n * @param collateralAmount The amount of collateral that is available for the loan\\n * @param liquidator The address of the liquidator where the liquidation reward will be sent to\\n */\\n function payOutLiquidator(\\n uint256 loanID,\\n uint256 rewardInLending,\\n uint256 collateralInLending,\\n uint256 collateralAmount,\\n address payable liquidator\\n ) internal {\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Liquidated,\\n \\\"Teller: loan not liquidated\\\"\\n );\\n\\n if (rewardInLending <= collateralInLending) {\\n uint256 rewardInCollateral =\\n PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n rewardInLending\\n );\\n\\n LibCollateral.withdraw(loanID, rewardInCollateral, liquidator);\\n } else {\\n // Payout whats available in the collateral token\\n LibCollateral.withdraw(loanID, collateralAmount, liquidator);\\n\\n // Claim remaining reward value from the loan escrow\\n claimEscrowTokensByValue(\\n loanID,\\n liquidator,\\n rewardInLending - collateralInLending\\n );\\n }\\n }\\n\\n /**\\n * @dev Send the equivalent of tokens owned by the loan escrow (in lending value) to the recipient,\\n * @param loanID The loan ID to clam tokens from\\n * @param recipient address to send the tokens to\\n * @param value The value of escrow held tokens to be claimed based in lending value\\n */\\n function claimEscrowTokensByValue(\\n uint256 loanID,\\n address recipient,\\n uint256 value\\n ) private {\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n uint256 valueLeftToTransfer = value;\\n\\n // Start with the lending token\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n LibLoans.loan(loanID).lendingToken,\\n recipient,\\n valueLeftToTransfer\\n );\\n\\n // Cycle through remaining tokens\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n if (valueLeftToTransfer == 0) {\\n return;\\n }\\n\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n EnumerableSet.at(tokens, i),\\n recipient,\\n valueLeftToTransfer\\n );\\n }\\n }\\n\\n function claimEscrowToken(\\n uint256 loanID,\\n address token,\\n address recipient,\\n uint256 valueLeftToTransfer\\n ) private returns (uint256) {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n // get value of token balance in lending value\\n if (balance > 0) {\\n // If token not the lending token, get value of token\\n uint256 balanceInLending;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n balanceInLending = balance;\\n } else {\\n balanceInLending = PriceAggLib.valueFor(\\n token,\\n LibLoans.loan(loanID).lendingToken,\\n balance\\n );\\n }\\n\\n if (balanceInLending <= valueLeftToTransfer) {\\n LibEscrow.e(loanID).claimToken(token, recipient, balance);\\n valueLeftToTransfer -= balanceInLending;\\n } else {\\n // Token balance is more than enough so calculate ratio of balance to transfer\\n uint256 valueToTransfer;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n valueToTransfer = valueLeftToTransfer;\\n } else {\\n valueToTransfer = NumbersLib.percent(\\n balance,\\n NumbersLib.ratioOf(\\n valueLeftToTransfer,\\n balanceInLending\\n )\\n );\\n }\\n\\n LibEscrow.e(loanID).claimToken(\\n token,\\n recipient,\\n valueToTransfer\\n );\\n valueLeftToTransfer = 0;\\n }\\n }\\n\\n return valueLeftToTransfer;\\n }\\n}\\n\",\"keccak256\":\"0xdfcd62dbcda7ba0ce92718d72d6cab3f7c78178d9ac9de6b04640124d43bf4cc\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n function init(address tokenAddress, bool isWETH) external;\\n\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x3c83593b5521e85c7f62076b41869cd5a762b34523ac39fc23b4ea1b9042aa59\",\"license\":\"MIT\"},\"contracts/market/libraries/LibCollateral.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport { ICollateralEscrow } from \\\"../collateral/ICollateralEscrow.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\nimport { MarketStorageLib } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibCollateral {\\n /**\\n * @notice This event is emitted when collateral has been deposited for the loan\\n * @param loanID ID of the loan for which collateral was deposited\\n * @param depositor Account that deposited funds\\n * @param amount Amount of collateral deposited\\n */\\n event CollateralDeposited(\\n uint256 indexed loanID,\\n address indexed depositor,\\n uint256 amount\\n );\\n\\n /**\\n * @notice This event is emitted when collateral has been withdrawn\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param receiver Account that received funds\\n * @param amount Value of collateral withdrawn\\n */\\n event CollateralWithdrawn(\\n uint256 indexed loanID,\\n address indexed receiver,\\n uint256 amount\\n );\\n\\n function e(uint256 loanID) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[\\n MarketStorageLib.store().loans[loanID].collateralToken\\n ];\\n }\\n\\n function e(address token) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[token];\\n }\\n\\n function deposit(uint256 loanID, uint256 amount) internal {\\n e(loanID).deposit{ value: amount }(loanID, amount);\\n\\n emit CollateralDeposited(loanID, msg.sender, amount);\\n }\\n\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) internal {\\n e(loanID).withdraw(loanID, amount, receiver);\\n\\n emit CollateralWithdrawn(loanID, receiver, amount);\\n }\\n\\n function withdrawAll(uint256 loanID, address payable receiver) internal {\\n withdraw(loanID, e(loanID).loanSupply(loanID), receiver);\\n }\\n\\n function createEscrow(address token) internal {\\n // Check if collateral escrow exists\\n if (address(e(token)) == address(0)) {\\n // Create escrow\\n address escrow =\\n AppStorageLib.store().collateralEscrowBeacon.cloneProxy(\\\"\\\");\\n ICollateralEscrow(escrow).init(\\n token,\\n // Check if collateral token is WETH\\n token == AppStorageLib.store().assetAddresses[\\\"WETH\\\"]\\n );\\n\\n // Set max allowance\\n IERC20(token).approve(escrow, type(uint256).max);\\n // Save escrow address for loan\\n MarketStorageLib.store().collateralEscrows[\\n token\\n ] = ICollateralEscrow(escrow);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd52b3e577480481b62d6a6c37f4ef596b7ec0120afbd6bc1a08b17923b926445\",\"license\":\"MIT\"},\"contracts/market/libraries/LibLoans.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibEscrow } from \\\"../../escrow/libraries/LibEscrow.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus,\\n LoanDebt,\\n LoanTerms\\n} from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibLoans {\\n using NumbersLib for int256;\\n using NumbersLib for uint256;\\n\\n bytes32 internal constant ID = keccak256(\\\"LOANS\\\");\\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\\n l_ = s().loans[loanID];\\n }\\n\\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\\n d_ = s().loanDebt[loanID];\\n }\\n\\n function terms(uint256 loanID)\\n internal\\n view\\n returns (LoanTerms storage t_)\\n {\\n t_ = s().loanTerms[loanID];\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) internal view returns (uint256) {\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n uint256 interestOwed =\\n getInterestOwedFor(loanID, terms(loanID).maxLoanAmount);\\n return terms(loanID).maxLoanAmount + (interestOwed);\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n return debt(loanID).principalOwed + (debt(loanID).interestOwed);\\n }\\n return 0;\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n internal\\n view\\n returns (uint256)\\n {\\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\\n }\\n\\n function getCollateralNeededInfo(uint256 loanID)\\n internal\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\\n loanID\\n );\\n\\n if (neededInLendingTokens == 0) {\\n neededInCollateralTokens = 0;\\n } else {\\n neededInCollateralTokens = PriceAggLib.valueFor(\\n loan(loanID).lendingToken,\\n loan(loanID).collateralToken,\\n neededInLendingTokens\\n );\\n }\\n }\\n\\n /**\\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\\n * @param loanID The loan ID to get needed collateral info for.\\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\\n */\\n function getCollateralNeededInTokens(uint256 loanID)\\n internal\\n view\\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\\n {\\n if (!_isActiveOrSet(loanID) || loan(loanID).collateralRatio == 0) {\\n return (0, 0);\\n }\\n\\n /*\\n The collateral to principal owed ratio is the sum of:\\n * collateral buffer percent\\n * loan interest rate\\n * liquidation reward percent\\n * X factor of additional collateral\\n */\\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n neededInLendingTokens = _getLoanAmount(loanID).percent(\\n loan(loanID).collateralRatio\\n );\\n } else {\\n uint16 requiredRatio =\\n loan(loanID).collateralRatio -\\n getInterestRatio(loanID) -\\n uint16(PlatformSettingsLib.getCollateralBufferValue());\\n\\n neededInLendingTokens =\\n debt(loanID).principalOwed +\\n debt(loanID).interestOwed;\\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\\n if (\\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\\n ) {\\n neededInLendingTokens -= escrowLoanValue;\\n }\\n neededInLendingTokens = neededInLendingTokens.percent(\\n requiredRatio\\n );\\n }\\n }\\n\\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\\n internal\\n view\\n returns (bool)\\n {\\n return\\n collateralRatio >=\\n PlatformSettingsLib.getOverCollateralizedBufferValue();\\n }\\n\\n /**\\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\\n * @notice There is a minimum threshold of 1%.\\n * @dev The interest rate on the loan terms is APY.\\n * @param loanID The loan ID to get the interest rate for.\\n */\\n function getInterestRatio(uint256 loanID)\\n internal\\n view\\n returns (uint16 ratio_)\\n {\\n ratio_ = uint16(\\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\\n SECONDS_PER_YEAR\\n );\\n\\n if (ratio_ == 0) {\\n ratio_ = 1;\\n }\\n }\\n\\n function _getLoanAmount(uint256 loanID) private view returns (uint256) {\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n return terms(loanID).maxLoanAmount;\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n return loan(loanID).borrowedAmount;\\n }\\n return 0;\\n }\\n\\n function _isActiveOrSet(uint256 loanID) private view returns (bool) {\\n LoanStatus status = loan(loanID).status;\\n return status == LoanStatus.Active || status == LoanStatus.TermsSet;\\n }\\n}\\n\",\"keccak256\":\"0x9bf9fae5b01110da7c5a5d2517fdea6aa880d5c1647ba6125c68cafad278499b\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x7c788b94c175b70eec6b10bfe0655616fc0beb2ce3ef70a6fa750f291d35106c\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}.\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x39fd6d70fd1aa5ae45465d7eeb38f74e2bf90535c2510782fb0bb5f720250ac5\",\"license\":\"MIT\"},\"contracts/nft/libraries/NFTLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../TellerNFT.sol\\\";\\n\\n// Libraries\\nimport {\\n MerkleProof\\n} from \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\nimport { NFTStorageLib, NFTStorage } from \\\"../../storage/nft.sol\\\";\\n\\nstruct NftLoanSizeProof {\\n uint256 id;\\n uint256 baseLoanSize;\\n bytes32[] proof;\\n}\\n\\nlibrary NFTLib {\\n function s() internal pure returns (NFTStorage storage s_) {\\n s_ = NFTStorageLib.store();\\n }\\n\\n function nft() internal view returns (TellerNFT nft_) {\\n nft_ = AppStorageLib.store().nft;\\n }\\n\\n function stake(uint256 nftID, address owner) internal {\\n // Transfer to diamond\\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\\n // Add NFT ID to user set\\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\\n }\\n\\n function unstake(uint256 nftID) internal returns (bool success_) {\\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\\n }\\n\\n function stakedNFTs(address nftOwner)\\n internal\\n view\\n returns (uint256[] memory staked_)\\n {\\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\\n staked_ = new uint256[](EnumerableSet.length(nfts));\\n for (uint256 i; i < staked_.length; i++) {\\n staked_[i] = EnumerableSet.at(nfts, i);\\n }\\n }\\n\\n function liquidateNFT(uint256 loanID) internal {\\n // Check if NFTs are linked\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n NFTLib.nft().transferFrom(\\n address(this),\\n AppStorageLib.store().nftLiquidationController,\\n EnumerableSet.at(nfts, i)\\n );\\n }\\n }\\n\\n function applyToLoan(uint256 loanID, NftLoanSizeProof calldata proof)\\n internal\\n {\\n // NFT must be currently staked\\n // Remove NFT from being staked - returns bool\\n require(unstake(proof.id), \\\"Teller: borrower nft not staked\\\");\\n\\n require(verifyLoanSize(proof), \\\"Teller invalid nft proof\\\");\\n\\n // Apply NFT to loan\\n EnumerableSet.add(s().loanNFTs[loanID], proof.id);\\n }\\n\\n function restakeLinked(uint256 loanID, address owner) internal {\\n // Get linked NFT\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n // Restake the NFT\\n EnumerableSet.add(s().stakedNFTs[owner], EnumerableSet.at(nfts, i));\\n }\\n }\\n\\n function verifyLoanSize(NftLoanSizeProof calldata proof)\\n internal\\n view\\n returns (bool verified_)\\n {\\n verified_ = MerkleProof.verify(\\n proof.proof,\\n s().nftMerkleRoot,\\n keccak256(abi.encodePacked(proof.id, proof.baseLoanSize))\\n );\\n }\\n}\\n\",\"keccak256\":\"0x99ba27095901d86a4d1e1b9ec3a603fbbf7c67ada2ccd11cd5ed0435e5c3c66d\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @dev It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @dev Tries to calculate a price from Compound and Chainlink.\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @dev Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @dev Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @dev Scales the {value} by the difference in decimal values.\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @dev Tries to calculate the price of {src} in {dst}\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address WETH = AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n if (dst != WETH) {\\n int256 price1 = _priceFor(src, WETH);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, WETH);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf84fd8d9a179ca7a70e75677870bdd7a5be7da097cf5f1bccf1c9f93253bda90\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { PriceAggFacet } from \\\"./PriceAggFacet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\n/**\\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\\n */\\nlibrary PriceAggLib {\\n /**\\n * @notice See {PriceAggFacet.getValueFor}\\n */\\n function valueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) internal view returns (uint256 value_) {\\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\\n }\\n\\n /**\\n * @notice See {PriceAggFacet.getPriceFor}\\n */\\n function priceFor(address src, address dst)\\n internal\\n view\\n returns (int256 price_)\\n {\\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\\n }\\n}\\n\",\"keccak256\":\"0x510633e39e7a30533d703eb7ec314c037772721fdb7cea96046cd6837bcb76c3\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\nabstract contract PausableMods {\\n /**\\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\\n * @param id id of the facet to check if is paused.\\n * @param state Boolean that the protocol AND facet should be in.\\n */\\n modifier paused(bytes32 id, bool state) {\\n require(\\n __isPaused(\\\"\\\") == state && __isPaused(id) == state,\\n __pausedMessage(state)\\n );\\n _;\\n }\\n\\n /**\\n * @dev Checks if the given id is paused.\\n * @param id Encoded id of the facet to check if is paused.\\n */\\n function __isPaused(bytes32 id) private view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n\\n /**\\n * @dev Gets the message that should be reverted with given a state it should be in.\\n * @param state Boolean that an id should be in.\\n */\\n function __pausedMessage(bool state) private pure returns (string memory) {\\n return state ? \\\"Pausable: not paused\\\" : \\\"Pausable: paused\\\";\\n }\\n}\\n\",\"keccak256\":\"0x772d8b9b63e9b8e78f243a70988f1a1e1100272cf317259ea173829f7b9bdf0e\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0xbeef1937dc1ed1f6f78b80f0737f018565ab264184cf05ef54c3c28ecd55a09b\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xacf6bcb8c4afd2f337a0161e8be64b016c1b350d336cd862245dd922fcd10f33\",\"license\":\"MIT\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n function claimComp(address holder) external;\\n\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x495d8bb746a524fea6ddc4286c955d7a0160718bf662456330a9d6d14b8a5da9\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n\\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x208769886b3db8f03ef1fa26f1caee189038dfc744b9a499402fc4e4c0090c38\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4d9045666e86d675f7bd48202f9a77d0675fa20b2184131ad369710ac5eb3203\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @notice CETH is the only Compound token that does not support the {underlying} function.\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x14e96659912e9d03ae30732faca8e3d617f3e756a215d948cabedab6642c1465\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0x998aefaf4edbe7b0cb41032750b65b3822b4bec0fec3ee5b396f8fb73b5e9e03\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0x8919fcdfb49018474c872c462c11b21a50faa7ab80f0162abd6b657cbbc5d04c\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x0888cf40ea019be9f0ee94cb8af1e030454c28f8c6512db9d89ed027fe21f18f\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n bool initialized;\\n bool platformRestricted;\\n mapping(bytes32 => bool) paused;\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0xade1dda8163fc39658e5f6929b662187584b29cce47e9cb0915fc0d1832fb4f7\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) loanTerms;\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5f3fdba19ae8040e2007affe422527b7dca58ba424df33ba4dd9cb08d83d00de\",\"license\":\"MIT\"},\"contracts/storage/nft.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Utils\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct NFTStorage {\\n // Maps NFT owner to set of token IDs owned\\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\\n // Maps loanID to NFT IDs indicating NFT being used for the loan\\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\\n // Merkle root used for verifying nft IDs to base loan size\\n bytes32 nftMerkleRoot;\\n}\\n\\nbytes32 constant NFT_STORAGE_POS = keccak256(\\\"teller.staking.storage\\\");\\n\\nlibrary NFTStorageLib {\\n function store() internal pure returns (NFTStorage storage s) {\\n bytes32 pos = NFT_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x8d58bb6ba00310d8c3d89b95c62e5c997430a1124d73224897f7d9b2a43ab50a\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "params": { + "borrower": "Account address of the borrower", + "liquidator": "Account address of the liquidator", + "loanID": "ID of loan from which collateral was withdrawn", + "reward": "Value in lending token paid out to liquidator", + "tokensIn": "Percentage of the collateral price paid by the liquidator to the lending pool" + } + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "params": { + "amountPaid": "Amount of the loan paid back", + "borrower": "Account address of the borrower", + "loanID": "ID of loan from which collateral was withdrawn", + "payer": "Account address of the payer", + "totalOwed": "Total amount of the loan to be repaid" + } + } + }, + "kind": "dev", + "methods": { + "escrowRepay(uint256,uint256)": { + "details": "If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.", + "params": { + "amount": "The amount being repaid.", + "loanID": "The id of the loan being used." + } + }, + "getLiquidationReward(uint256)": { + "params": { + "loanID": "The loan ID to get the info." + }, + "returns": { + "inCollateral_": "The value the liquidator will receive denoted in collateral tokens.", + "inLending_": "The value the liquidator will receive denoted in lending tokens." + } + }, + "liquidateLoan(uint256)": { + "params": { + "loanID": "The ID of the loan to be liquidated" + } + }, + "repayLoan(uint256,uint256)": { + "params": { + "amount": "The amount of tokens to pay back to the loan", + "loanID": "The ID of the loan the payment is for" + } + } + }, + "version": 1 + }, + "userdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "notice": "This event is emitted when a loan has been successfully liquidated" + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "notice": "This event is emitted when a loan has been successfully repaid" + } + }, + "kind": "user", + "methods": { + "escrowRepay(uint256,uint256)": { + "notice": "Repay this Escrow's loan." + }, + "getLiquidationReward(uint256)": { + "notice": "It gets the current liquidation reward for a given loan." + }, + "liquidateLoan(uint256)": { + "notice": "Liquidate a loan if it is expired or under collateralized" + }, + "repayLoan(uint256,uint256)": { + "notice": "Make a payment to a loan" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0x28E2Ce61Ec8dEd7f7bC9CBa02a33573f7dd9f5F5", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "RepayFacet", + "transactionHash": "0x9bb6ed95cafb2cabe8e6ba16a7a301d849e43215e14b90241632191de6f23df4", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x28E2Ce61Ec8dEd7f7bC9CBa02a33573f7dd9f5F5", + "transactionIndex": 0, + "gasUsed": "1757520", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xf56922a6944840f350477d7431a8f2148417641af4a62f6bc382ec1cdf4130d1", + "transactionHash": "0x9bb6ed95cafb2cabe8e6ba16a7a301d849e43215e14b90241632191de6f23df4", + "logs": [], + "blockNumber": 25347871, + "cumulativeGasUsed": "1757520", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "7646e63ef89d3687a032672685314b8f", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"liquidator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"reward\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokensIn\",\"type\":\"uint256\"}],\"name\":\"LoanLiquidated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountPaid\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"totalOwed\",\"type\":\"uint256\"}],\"name\":\"LoanRepaid\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"escrowRepay\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLiquidationReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"inLending_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"inCollateral_\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"liquidateLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"repayLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"params\":{\"borrower\":\"Account address of the borrower\",\"liquidator\":\"Account address of the liquidator\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"reward\":\"Value in lending token paid out to liquidator\",\"tokensIn\":\"Percentage of the collateral price paid by the liquidator to the lending pool\"}},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"params\":{\"amountPaid\":\"Amount of the loan paid back\",\"borrower\":\"Account address of the borrower\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"payer\":\"Account address of the payer\",\"totalOwed\":\"Total amount of the loan to be repaid\"}}},\"kind\":\"dev\",\"methods\":{\"escrowRepay(uint256,uint256)\":{\"details\":\"If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\",\"params\":{\"amount\":\"The amount being repaid.\",\"loanID\":\"The id of the loan being used.\"}},\"getLiquidationReward(uint256)\":{\"params\":{\"loanID\":\"The loan ID to get the info.\"},\"returns\":{\"inCollateral_\":\"The value the liquidator will receive denoted in collateral tokens.\",\"inLending_\":\"The value the liquidator will receive denoted in lending tokens.\"}},\"liquidateLoan(uint256)\":{\"params\":{\"loanID\":\"The ID of the loan to be liquidated\"}},\"repayLoan(uint256,uint256)\":{\"params\":{\"amount\":\"The amount of tokens to pay back to the loan\",\"loanID\":\"The ID of the loan the payment is for\"}}},\"version\":1},\"userdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully liquidated\"},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully repaid\"}},\"kind\":\"user\",\"methods\":{\"escrowRepay(uint256,uint256)\":{\"notice\":\"Repay this Escrow's loan.\"},\"getLiquidationReward(uint256)\":{\"notice\":\"It gets the current liquidation reward for a given loan.\"},\"liquidateLoan(uint256)\":{\"notice\":\"Liquidate a loan if it is expired or under collateralized\"},\"repayLoan(uint256,uint256)\":{\"notice\":\"Make a payment to a loan\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/market/RepayFacet.sol\":\"RepayFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Trees proofs.\\n *\\n * The proofs can be generated using the JavaScript library\\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\\n *\\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n bytes32 computedHash = leaf;\\n\\n for (uint256 i = 0; i < proof.length; i++) {\\n bytes32 proofElement = proof[i];\\n\\n if (computedHash <= proofElement) {\\n // Hash(current computed hash + current element of the proof)\\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\\n } else {\\n // Hash(current element of the proof + current computed hash)\\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\\n }\\n }\\n\\n // Check if the computed hash (root) is equal to the provided root\\n return computedHash == root;\\n }\\n}\\n\",\"keccak256\":\"0xeee34bfb413657b6cd6c8e1e15c2080ba5ebaac479578515922804346fb63f7c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/reentry/ReentryMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nabstract contract ReentryMods {\\n modifier nonReentry(bytes32 id) {\\n AccessControlStorage storage s = AccessControlStorageLib.store();\\n require(!s.entered[id], \\\"AccessControl: reentered\\\");\\n s.entered[id] = true;\\n _;\\n s.entered[id] = false;\\n }\\n}\\n\",\"keccak256\":\"0x033c1164af25ef7d35a38a60973bf379b1cc603596914ffd85dcbcf0acdb6970\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../interfaces/IAToken.sol\\\";\\nimport { IAaveLendingPool } from \\\"../interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x8030b206c87d0073fb7dbebfa2ee8a3e93c479d976d6cdaa0c939f2fedaa1525\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n /**\\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\\n * @param dappAddress address of the target contract address\\n * @param dappData encoded abi of the function in our contract we want to call\\n * @return the called data in bytes\\n */\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n /**\\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\\n * @param token address of the respective ERC20 token to approve for the spender\\n * @param spender address of the respective spender who is approved by the token contract\\n */\\n function setTokenAllowance(address token, address spender) external;\\n\\n /**\\n * @notice it allows user to claim their escrow tokens\\n * @dev only the owner (TellerDiamond) can make this call on behalf of the users\\n * @param token address of the respective token contract to claim tokens from\\n * @param to address where the tokens should be transferred to\\n * @param amount uint256 amount of tokens to be claimed\\n */\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xaf67fc4454ffaa4d2f7e46fe7101876e8ebdb1a5426c30f87b8e18cc573ac019\",\"license\":\"MIT\"},\"contracts/escrow/libraries/LibEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibDapps } from \\\"../dapps/libraries/LibDapps.sol\\\";\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibEscrow {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\\n e_ = s().loanEscrows[loanID];\\n }\\n\\n /**\\n * @notice It returns a list of tokens owned by a loan escrow\\n * @param loanID uint256 index used to return our token list\\n * @return t_ which is a list of tokens \\n */\\n function getEscrowTokens(uint256 loanID)\\n internal\\n view\\n returns (EnumerableSet.AddressSet storage t_)\\n {\\n t_ = s().escrowTokens[loanID];\\n }\\n\\n /**\\n * @notice It returns the balance of a respective token in a loan escrow\\n * @param loanID uint256 index used to point to our loan escrow\\n * @param token address of respective token to give us the balance of in our loan escrow\\n * @return uint256 balance of respective token returned in an escrow loan\\n */\\n function balanceOf(uint256 loanID, address token)\\n internal\\n view\\n returns (uint256)\\n {\\n return IERC20(token).balanceOf(address(e(loanID)));\\n }\\n\\n /**\\n * @notice Adds or removes tokens held by the Escrow contract\\n * @param loanID The loan ID to update the token list for\\n * @param tokenAddress The token address to be added or removed\\n */\\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\\n // Skip if is lending token\\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\\n\\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\\n if (balanceOf(loanID, tokenAddress) > 0) {\\n if (!contains) {\\n EnumerableSet.add(tokens, tokenAddress);\\n }\\n } else if (contains) {\\n EnumerableSet.remove(tokens, tokenAddress);\\n }\\n }\\n\\n /**\\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\\n * @param loanID The loan ID to calculate value for\\n * @return value_ Escrow total value denoted in the lending token.\\n */\\n function calculateTotalValue(uint256 loanID)\\n internal\\n view\\n returns (uint256 value_)\\n {\\n address lendingToken = LibLoans.loan(loanID).lendingToken;\\n value_ += balanceOf(loanID, lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\\n if (EnumerableSet.length(tokens) > 0) {\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n uint256 tokenBal =\\n balanceOf(loanID, EnumerableSet.at(tokens, i));\\n value_ += PriceAggLib.valueFor(\\n EnumerableSet.at(tokens, i),\\n lendingToken,\\n tokenBal\\n );\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x17a7c6b11d6f280948e320525d1e131b89c23f80216918aa070df437a851d915\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when a user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when a user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n * @return ERC20 token\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n * @return balance_ the balance of the account\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice It calculates the total supply of the underlying asset.\\n * @return totalSupply_ the total supply denoted in the underlying asset.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given market.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n \\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfill the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n * @return mintAmount_ the amount minted of the specified token\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n * @return address of the strategy contract\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n * @param state boolean value that resembles the platform's state\\n */\\n function restrict(bool state) external virtual;\\n\\n /**\\n * @notice it initializes the Teller Token\\n * @param admin address of the admin to the respective Teller Token\\n * @param underlying address of the ERC20 token\\n */\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xf30ac4ef491851477ff9a3dd04974ebe74b529c37a3ef4e05798c3f734ceeb3d\",\"license\":\"MIT\"},\"contracts/market/LoanDataFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { Loan, LoanDebt, LoanTerms } from \\\"../storage/market.sol\\\";\\n\\ncontract LoanDataFacet {\\n /**\\n * @notice Returns the information about the given {loanID}.\\n * @param loanID The loan ID to get information for.\\n * @return loan_ The loan data.\\n */\\n function getLoan(uint256 loanID) external view returns (Loan memory loan_) {\\n loan_ = LibLoans.s().loans[loanID];\\n }\\n\\n /**\\n * @notice DEPRECATED\\n * @notice Returns the terms for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanTerms The terms that the loan weer created with.\\n */\\n function getLoanTerms(uint256 loanID)\\n external\\n view\\n returns (LoanTerms memory)\\n {\\n return LibLoans.terms(loanID);\\n }\\n\\n /**\\n * @notice Returns the loan IDs created by the {borrower} account.\\n * @param borrower The account to get loan IDs for.\\n * @return loanIDs The IDs for loans created by the {borrower}\\n */\\n function getBorrowerLoans(address borrower)\\n external\\n view\\n returns (uint128[] memory loanIDs)\\n {\\n return LibLoans.s().borrowerLoans[borrower];\\n }\\n\\n /**\\n * @notice Returns the debt owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanDebt The principal and interest owed amount.\\n */\\n function getDebtOwed(uint256 loanID)\\n external\\n view\\n returns (LoanDebt memory)\\n {\\n return LibLoans.debt(loanID);\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) external view returns (uint256) {\\n return LibLoans.getTotalOwed(loanID);\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n external\\n view\\n returns (uint256)\\n {\\n return LibLoans.getInterestOwedFor(loanID, amountBorrow);\\n }\\n\\n /**\\n * @notice it returns the collateral needed for a loan\\n * @param loanID the identifier of the loan ID to retrieve collateral from\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n external\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n return LibLoans.getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the typed address of a loan escrow\\n * @param loanID the identifier of the respective escrow's loan\\n * @return escrow_ the typed address of the returned ILoanEscrow\\n */\\n function getLoanEscrow(uint256 loanID)\\n external\\n view\\n returns (address escrow_)\\n {\\n escrow_ = address(LibLoans.s().loanEscrows[loanID]);\\n }\\n\\n /**\\n * @notice it returns the escrow's total value by calculating the value all the escrow tokens\\n * @param loanID the identifier of the respective escrow's loan\\n * @return the total value of the loan escrow\\n */\\n function getLoanEscrowValue(uint256 loanID)\\n external\\n view\\n returns (uint256)\\n {\\n return LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n /**\\n * @notice it returns the total escrow tokens held by an escrow\\n * @param loanID the identifier of the respective escrow's loan\\n * @return tokens_ the tokens held at the escrow loan \\n */\\n function getEscrowTokens(uint256 loanID)\\n external\\n view\\n returns (address[] memory tokens_)\\n {\\n EnumerableSet.AddressSet storage escrowTokens =\\n LibEscrow.getEscrowTokens(loanID);\\n tokens_ = new address[](EnumerableSet.length(escrowTokens));\\n for (uint256 i; i < tokens_.length; i++) {\\n tokens_[i] = EnumerableSet.at(escrowTokens, i);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x9a57f5de00ce073af4ffb2f74e7d8a15e56bc017826f2c5a393ef5b64554145f\",\"license\":\"MIT\"},\"contracts/market/RepayFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\nimport {\\n ReentryMods\\n} from \\\"../contexts2/access-control/reentry/ReentryMods.sol\\\";\\nimport { AUTHORIZED } from \\\"../shared/roles.sol\\\";\\nimport { LoanDataFacet } from \\\"./LoanDataFacet.sol\\\";\\n\\n// Libraries\\nimport {\\n IERC20,\\n SafeERC20\\n} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibCollateral } from \\\"./libraries/LibCollateral.sol\\\";\\nimport { LibDapps } from \\\"../escrow/dapps/libraries/LibDapps.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { NumbersLib } from \\\"../shared/libraries/NumbersLib.sol\\\";\\nimport { PriceAggLib } from \\\"../price-aggregator/PriceAggLib.sol\\\";\\nimport { NFTLib } from \\\"../nft/libraries/NFTLib.sol\\\";\\n\\n// Interfaces\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus\\n} from \\\"../storage/market.sol\\\";\\n\\ncontract RepayFacet is RolesMods, ReentryMods, PausableMods {\\n /**\\n @notice This event is emitted when a loan has been successfully repaid\\n @param loanID ID of loan from which collateral was withdrawn\\n @param borrower Account address of the borrower\\n @param amountPaid Amount of the loan paid back\\n @param payer Account address of the payer\\n @param totalOwed Total amount of the loan to be repaid\\n */\\n event LoanRepaid(\\n uint256 indexed loanID,\\n address indexed borrower,\\n uint256 amountPaid,\\n address payer,\\n uint256 totalOwed\\n );\\n\\n /**\\n * @notice This event is emitted when a loan has been successfully liquidated\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param borrower Account address of the borrower\\n * @param liquidator Account address of the liquidator\\n * @param reward Value in lending token paid out to liquidator\\n * @param tokensIn Percentage of the collateral price paid by the liquidator to the lending pool\\n */\\n event LoanLiquidated(\\n uint256 indexed loanID,\\n address indexed borrower,\\n address liquidator,\\n uint256 reward,\\n uint256 tokensIn\\n );\\n\\n /**\\n * @notice Repay this Escrow's loan.\\n * @dev If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.\\n * @dev Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\\n * @param loanID The id of the loan being used.\\n * @param amount The amount being repaid.\\n */\\n function escrowRepay(uint256 loanID, uint256 amount)\\n external\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n nonReentry(\\\"\\\")\\n {\\n uint256 balance =\\n LibEscrow.balanceOf(loanID, LibLoans.loan(loanID).lendingToken);\\n uint256 totalOwed = LibLoans.getTotalOwed(loanID);\\n // if there isn't enough balance in the escrow, then transfer amount needed to the escrow\\n if (balance < totalOwed && amount > balance) {\\n uint256 amountNeeded =\\n amount > totalOwed ? totalOwed - (balance) : amount - (balance);\\n\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n msg.sender,\\n address(LibEscrow.e(loanID)),\\n amountNeeded\\n );\\n }\\n\\n __repayLoan(loanID, amount, address(LibEscrow.e(loanID)), false);\\n }\\n\\n /**\\n * @notice Make a payment to a loan\\n * @param loanID The ID of the loan the payment is for\\n * @param amount The amount of tokens to pay back to the loan\\n */\\n function repayLoan(uint256 loanID, uint256 amount)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n __repayLoan(loanID, amount, msg.sender, false);\\n }\\n\\n /**\\n * @notice it repays the loan, either from an escrow or from a regular address\\n * @param loanID the identifier of the loan to repay\\n * @param amount the amount to repay the loan\\n * @param sender the address of the sender that wants to pay, can also be a loan escrow\\n * @param isLiquidation is this loan being liquidated?\\n * @return leftToPay_ the amount left to pay for the loan\\n */\\n function __repayLoan(\\n uint256 loanID,\\n uint256 amount,\\n address sender,\\n bool isLiquidation\\n ) private returns (uint256 leftToPay_) {\\n require(amount > 0, \\\"Teller: zero repay\\\");\\n\\n // calculate the actual amount to repay\\n leftToPay_ =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n if (leftToPay_ < amount) {\\n amount = leftToPay_;\\n leftToPay_ = 0;\\n } else {\\n leftToPay_ -= amount;\\n }\\n\\n // Get the Teller token for the loan\\n ITToken tToken =\\n MarketStorageLib.store().tTokens[\\n LibLoans.loan(loanID).lendingToken\\n ];\\n // Transfer funds from an escrow if an escrow is calling it\\n // Otherwise, transfer funds from an account\\n if (address(LibEscrow.e(loanID)) == sender) {\\n LibEscrow.e(loanID).claimToken(\\n LibLoans.loan(loanID).lendingToken,\\n address(tToken),\\n amount\\n );\\n } else {\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n sender,\\n address(tToken),\\n amount\\n );\\n }\\n\\n // Deduct the interest and principal owed\\n uint256 principalPaid;\\n uint256 interestPaid;\\n if (amount < LibLoans.debt(loanID).interestOwed) {\\n interestPaid = amount;\\n LibLoans.debt(loanID).interestOwed -= amount;\\n } else {\\n if (LibLoans.debt(loanID).interestOwed > 0) {\\n interestPaid = LibLoans.debt(loanID).interestOwed;\\n amount -= interestPaid;\\n LibLoans.debt(loanID).interestOwed = 0;\\n }\\n\\n if (amount > 0) {\\n principalPaid = amount;\\n LibLoans.debt(loanID).principalOwed -= amount;\\n }\\n }\\n\\n // Tell the Teller Token value has been deposited back into the pool.\\n tToken.repayLoan(principalPaid, interestPaid);\\n\\n if (isLiquidation) {\\n // Make sure there is nothing left to repay on the loan\\n require(leftToPay_ == 0, \\\"Teller: liquidate partial repay\\\");\\n\\n // Set loan status\\n LibLoans.loan(loanID).status = LoanStatus.Liquidated;\\n\\n // Transfer NFT if linked\\n NFTLib.liquidateNFT(loanID);\\n } else {\\n // if the loan is now fully paid, close it and withdraw borrower collateral\\n if (leftToPay_ == 0) {\\n LibLoans.loan(loanID).status = LoanStatus.Closed;\\n LibCollateral.withdrawAll(\\n loanID,\\n LibLoans.loan(loanID).borrower\\n );\\n // Restake any NFTs linked to loan for borrower\\n NFTLib.restakeLinked(loanID, LibLoans.loan(loanID).borrower);\\n }\\n\\n emit LoanRepaid(\\n loanID,\\n LibLoans.loan(loanID).borrower,\\n amount,\\n msg.sender,\\n leftToPay_\\n );\\n }\\n }\\n\\n /**\\n * @notice Liquidate a loan if it is expired or under collateralized\\n * @param loanID The ID of the loan to be liquidated\\n */\\n function liquidateLoan(uint256 loanID)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n uint256 collateralAmount = LibCollateral.e(loanID).loanSupply(loanID);\\n require(\\n RepayLib.isLiquidable(loanID, collateralAmount),\\n \\\"Teller: does not need liquidation\\\"\\n );\\n\\n // Calculate the reward before repaying the loan\\n (uint256 rewardInLending, uint256 collateralInLending) =\\n RepayLib.getLiquidationReward(loanID, collateralAmount);\\n\\n // The liquidator pays the amount still owed on the loan\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n __repayLoan(loanID, amountToLiquidate, msg.sender, true);\\n\\n // Payout the liquidator reward owed\\n if (rewardInLending > 0) {\\n RepayLib.payOutLiquidator(\\n loanID,\\n rewardInLending,\\n collateralInLending,\\n collateralAmount,\\n payable(msg.sender)\\n );\\n }\\n\\n emit LoanLiquidated(\\n loanID,\\n loan.borrower,\\n msg.sender,\\n rewardInLending,\\n amountToLiquidate\\n );\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @return inLending_ The value the liquidator will receive denoted in lending tokens.\\n * @return inCollateral_ The value the liquidator will receive denoted in collateral tokens.\\n */\\n function getLiquidationReward(uint256 loanID)\\n external\\n view\\n returns (uint256 inLending_, uint256 inCollateral_)\\n {\\n (inLending_, ) = RepayLib.getLiquidationReward(\\n loanID,\\n LibCollateral.e(loanID).loanSupply(loanID)\\n );\\n inCollateral_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n inLending_\\n );\\n }\\n}\\n\\nlibrary RepayLib {\\n /**\\n * @notice It checks if a loan can be liquidated.\\n * @param loanID The loan ID to check.\\n * @return true if the loan is liquidable.\\n */\\n function isLiquidable(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (bool)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n // Check if loan can be liquidated\\n if (loan.status != LoanStatus.Active) {\\n return false;\\n }\\n\\n if (loan.collateralRatio > 0) {\\n // If loan has a collateral ratio, check how much is needed\\n (, uint256 neededInCollateral, ) =\\n LoanDataFacet(address(this)).getCollateralNeededInfo(loanID);\\n if (neededInCollateral > collateralAmount) {\\n return true;\\n }\\n }\\n\\n // Otherwise, check if the loan has expired\\n return block.timestamp >= loan.loanStartTime + loan.duration;\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @param collateralAmount The amount of collateral for the {loanID}. Passed in to save gas calling the collateral escrow multiple times.\\n * @return reward_ The value the liquidator will receive denoted in lending tokens.\\n */\\n function getLiquidationReward(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (uint256 reward_, uint256 collateralValue_)\\n {\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n // Max reward is amount repaid on loan plus extra percentage\\n uint256 maxReward =\\n amountToLiquidate +\\n NumbersLib.percent(\\n amountToLiquidate,\\n uint16(PlatformSettingsLib.getLiquidateRewardPercent())\\n );\\n\\n // Calculate available collateral for reward\\n if (collateralAmount > 0) {\\n collateralValue_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).collateralToken,\\n LibLoans.loan(loanID).lendingToken,\\n collateralAmount\\n );\\n reward_ += collateralValue_;\\n }\\n\\n // Calculate loan escrow value if collateral not enough to cover reward\\n if (reward_ < maxReward) {\\n reward_ += LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n // Cap the reward to max\\n if (reward_ > maxReward) {\\n reward_ = maxReward;\\n }\\n }\\n\\n /**\\n * @notice Checks if the loan has an Escrow and claims any tokens then pays out the loan collateral.\\n * @dev See Escrow.claimTokens for more info.\\n * @param loanID The loan ID which is being liquidated\\n * @param rewardInLending The total amount of reward based in the lending token to pay the liquidator\\n * @param collateralInLending The amount of collateral that is available for the loan denoted in lending tokens\\n * @param collateralAmount The amount of collateral that is available for the loan\\n * @param liquidator The address of the liquidator where the liquidation reward will be sent to\\n */\\n function payOutLiquidator(\\n uint256 loanID,\\n uint256 rewardInLending,\\n uint256 collateralInLending,\\n uint256 collateralAmount,\\n address payable liquidator\\n ) internal {\\n // check if loan is liquidated\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Liquidated,\\n \\\"Teller: loan not liquidated\\\"\\n );\\n\\n // if the lending reward is less than the collateral lending tokens, then aggregate\\n // the value for the lending token with the collateral token and send it to the liquidator\\n if (rewardInLending <= collateralInLending) {\\n uint256 rewardInCollateral =\\n PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n rewardInLending\\n );\\n\\n LibCollateral.withdraw(loanID, rewardInCollateral, liquidator);\\n } else {\\n // Payout whats available in the collateral token\\n LibCollateral.withdraw(loanID, collateralAmount, liquidator);\\n\\n // Claim remaining reward value from the loan escrow\\n claimEscrowTokensByValue(\\n loanID,\\n liquidator,\\n rewardInLending - collateralInLending\\n );\\n }\\n }\\n\\n /**\\n * @dev Send the equivalent of tokens owned by the loan escrow (in lending value) to the recipient,\\n * @param loanID The loan ID to clam tokens from\\n * @param recipient address to send the tokens to\\n * @param value The value of escrow held tokens to be claimed based in lending value\\n */\\n function claimEscrowTokensByValue(\\n uint256 loanID,\\n address recipient,\\n uint256 value\\n ) private {\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n uint256 valueLeftToTransfer = value;\\n\\n // Start with the lending token\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n LibLoans.loan(loanID).lendingToken,\\n recipient,\\n valueLeftToTransfer\\n );\\n\\n // Cycle through remaining tokens\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n if (valueLeftToTransfer == 0) {\\n return;\\n }\\n\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n EnumerableSet.at(tokens, i),\\n recipient,\\n valueLeftToTransfer\\n );\\n }\\n }\\n\\n /**\\n * @notice it claims the escrow tokens for the liquidator\\n * @notice it keeps claiming escrow tokens until there aren't anymore tokens or the valueLeftToTransfer is zero\\n * @param loanID the identifier of the escrow loan to claim tokens from\\n * @param token the address of the token asset to claim\\n * @param recipient the address of the recipient to transfer the tokens to\\n * @param valueLeftToTransfer the value left to transfer to the liquidator that is returned back\\n * @return the value left to transfer\\n */\\n function claimEscrowToken(\\n uint256 loanID,\\n address token,\\n address recipient,\\n uint256 valueLeftToTransfer\\n ) private returns (uint256) {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n // get value of token balance in lending value\\n if (balance > 0) {\\n // If token not the lending token, get value of token\\n uint256 balanceInLending;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n balanceInLending = balance;\\n } else {\\n balanceInLending = PriceAggLib.valueFor(\\n token,\\n LibLoans.loan(loanID).lendingToken,\\n balance\\n );\\n }\\n\\n if (balanceInLending <= valueLeftToTransfer) {\\n LibEscrow.e(loanID).claimToken(token, recipient, balance);\\n valueLeftToTransfer -= balanceInLending;\\n } else {\\n // Token balance is more than enough so calculate ratio of balance to transfer\\n uint256 valueToTransfer;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n valueToTransfer = valueLeftToTransfer;\\n } else {\\n valueToTransfer = NumbersLib.percent(\\n balance,\\n NumbersLib.ratioOf(\\n valueLeftToTransfer,\\n balanceInLending\\n )\\n );\\n }\\n\\n LibEscrow.e(loanID).claimToken(\\n token,\\n recipient,\\n valueToTransfer\\n );\\n valueLeftToTransfer = 0;\\n }\\n }\\n return valueLeftToTransfer;\\n }\\n}\\n\",\"keccak256\":\"0x4cc90a273ddbcfc983b98bd42c18990526a79488c972926952d38f26ff69cabb\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n /**\\n * @notice it initializes an escrow\\n * @param tokenAddress the address of the collateral token to be stored\\n * @param isWETH check if it's wrapped Ethereum\\n */\\n function init(address tokenAddress, bool isWETH) external;\\n\\n /**\\n * @notice it deposits an amount of the respective collateral token into the escrow\\n * @param loanID the ID of the loan\\n * @param amount the amount of collateral tokens to be deposited\\n */\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n /**\\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\\n * @dev only the TellerDiamond can make this call on behalf of the borrower\\n * @param loanID identifier of the loan\\n * @param amount number of collateral tokens to send\\n * @param receiver payable address to transfer money to\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n /**\\n * @notice it returns the supply of the respective loan\\n * @param loanID the respective loan ID\\n * @return supply_ the amount in collateral of the respective loan\\n */\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n /**\\n * @notice it returns the total supply of the collateral token held by the contract\\n * @return supply_ the total amount of collateral\\n */\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x900fed2311f919ba1451a6583ddbf9f3bc8afa8f5189500fff51f0c049258ed3\",\"license\":\"MIT\"},\"contracts/market/libraries/LibCollateral.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport { ICollateralEscrow } from \\\"../collateral/ICollateralEscrow.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\nimport { MarketStorageLib } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibCollateral {\\n /**\\n * @notice This event is emitted when collateral has been deposited for the loan\\n * @param loanID ID of the loan for which collateral was deposited\\n * @param depositor Account that deposited funds\\n * @param amount Amount of collateral deposited\\n */\\n event CollateralDeposited(\\n uint256 indexed loanID,\\n address indexed depositor,\\n uint256 amount\\n );\\n\\n /**\\n * @notice This event is emitted when collateral has been withdrawn\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param receiver Account that received funds\\n * @param amount Value of collateral withdrawn\\n */\\n event CollateralWithdrawn(\\n uint256 indexed loanID,\\n address indexed receiver,\\n uint256 amount\\n );\\n\\n /**\\n * @notice it gets MarketStorage's collateral escrow using the loanID\\n * @param loanID the loanID to be used\\n * @return c_ which is the collateral escrow\\n */\\n function e(uint256 loanID) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[\\n MarketStorageLib.store().loans[loanID].collateralToken\\n ];\\n }\\n\\n function e(address token) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[token];\\n }\\n\\n /**\\n * @notice it deposits an amount of collateral into a collateral escrow's address of a respective loan\\n * @param loanID the respective loan ID\\n * @param amount the amount of collateral to deposit\\n */\\n function deposit(uint256 loanID, uint256 amount) internal {\\n e(loanID).deposit{ value: amount }(loanID, amount);\\n\\n emit CollateralDeposited(loanID, msg.sender, amount);\\n }\\n\\n /**\\n * @notice it withdraws an amount from the collateral escrow\\n * @param loanID the respective loanID to withdraw from\\n * @param amount the number of collateral tokens to withdraw\\n * @param receiver the address who receives the withdrawal\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) internal {\\n e(loanID).withdraw(loanID, amount, receiver);\\n\\n emit CollateralWithdrawn(loanID, receiver, amount);\\n }\\n\\n /**\\n * @notice it withdraws the entire supply in collateral of a respective loan to an address\\n * @param loanID the respective loan's ID\\n * @param receiver the address of the receiver to withdraw tokens from\\n */\\n function withdrawAll(uint256 loanID, address payable receiver) internal {\\n withdraw(loanID, e(loanID).loanSupply(loanID), receiver);\\n }\\n\\n /**\\n * @notice it initializes a new escrow collateral to hold collateral tokens\\n * @param token address of the collateral token it holds\\n */\\n function createEscrow(address token) internal {\\n // Check if collateral escrow exists\\n if (address(e(token)) == address(0)) {\\n // Create escrow\\n address escrow =\\n AppStorageLib.store().collateralEscrowBeacon.cloneProxy(\\\"\\\");\\n ICollateralEscrow(escrow).init(\\n token,\\n // Check if collateral token is WETH\\n token == AppStorageLib.store().assetAddresses[\\\"WETH\\\"]\\n );\\n\\n // Set max allowance\\n IERC20(token).approve(escrow, type(uint256).max);\\n // Save escrow address for loan\\n MarketStorageLib.store().collateralEscrows[\\n token\\n ] = ICollateralEscrow(escrow);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x84dbab8283357a1cc4210e34642fc8247841a58973778f4f6570398cc3046947\",\"license\":\"MIT\"},\"contracts/market/libraries/LibLoans.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibEscrow } from \\\"../../escrow/libraries/LibEscrow.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus,\\n LoanDebt,\\n LoanTerms\\n} from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibLoans {\\n using NumbersLib for int256;\\n using NumbersLib for uint256;\\n\\n bytes32 internal constant ID = keccak256(\\\"LOANS\\\");\\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n * @notice it returns the loan\\n * @param loanID the ID of the respective loan\\n * @return l_ the loan \\n */\\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\\n l_ = s().loans[loanID];\\n }\\n\\n /**\\n * @notice it returns the loan debt from a respective loan\\n * @param loanID the ID of the respective loan\\n * @return d_ the loan debt from a respective loan\\n */\\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\\n d_ = s().loanDebt[loanID];\\n }\\n\\n // DEPRECATED\\n function terms(uint256 loanID)\\n internal\\n view\\n returns (LoanTerms storage t_)\\n {\\n t_ = s()._loanTerms[loanID];\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return owed_ uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID)\\n internal\\n view\\n returns (uint256 owed_)\\n {\\n if (loan(loanID).status == LoanStatus.Active) {\\n owed_ = debt(loanID).principalOwed + (debt(loanID).interestOwed);\\n }\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n internal\\n view\\n returns (uint256)\\n {\\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\\n }\\n \\n function getCollateralNeeded(uint256 loanID)\\n internal\\n view\\n returns (uint256 _needed)\\n {\\n (, _needed, ) = getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the total collateral needed in lending tokens, in collateral tokens and in escrowed loan values\\n * @param loanID the loanID to get the total collateral needed\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n internal\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\\n loanID\\n );\\n\\n // check if needed lending tokens is zero. if true, then needed collateral tokens is zero. else,\\n if (neededInLendingTokens == 0) {\\n neededInCollateralTokens = 0;\\n } else {\\n neededInCollateralTokens = PriceAggLib.valueFor(\\n loan(loanID).lendingToken,\\n loan(loanID).collateralToken,\\n neededInLendingTokens\\n );\\n }\\n }\\n\\n /**\\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\\n * @param loanID The loan ID to get needed collateral info for.\\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\\n */\\n function getCollateralNeededInTokens(uint256 loanID)\\n internal\\n view\\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\\n {\\n if (loan(loanID).collateralRatio == 0) {\\n return (0, 0);\\n }\\n\\n /*\\n The collateral to principal owed ratio is the sum of:\\n * collateral buffer percent\\n * loan interest rate\\n * liquidation reward percent\\n * X factor of additional collateral\\n */\\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n neededInLendingTokens = loan(loanID).borrowedAmount.percent(\\n loan(loanID).collateralRatio\\n );\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n uint16 requiredRatio =\\n loan(loanID).collateralRatio -\\n getInterestRatio(loanID) -\\n uint16(PlatformSettingsLib.getCollateralBufferValue());\\n\\n neededInLendingTokens =\\n debt(loanID).principalOwed +\\n debt(loanID).interestOwed;\\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\\n if (\\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\\n ) {\\n neededInLendingTokens -= escrowLoanValue;\\n }\\n neededInLendingTokens = neededInLendingTokens.percent(\\n requiredRatio\\n );\\n }\\n }\\n\\n /**\\n * @notice check if a loan can go to end of auction with a collateral ratio\\n * @return bool checking if collateralRatio is >= the over collateralized buffer value\\n */\\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\\n internal\\n view\\n returns (bool)\\n {\\n return\\n collateralRatio >=\\n PlatformSettingsLib.getOverCollateralizedBufferValue();\\n }\\n\\n /**\\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\\n * @notice There is a minimum threshold of 1%.\\n * @dev The interest rate is APY (annual percentage yield).\\n * @param loanID The loan ID to get the interest rate for.\\n */\\n function getInterestRatio(uint256 loanID)\\n internal\\n view\\n returns (uint16 ratio_)\\n {\\n ratio_ = uint16(\\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\\n SECONDS_PER_YEAR\\n );\\n\\n if (ratio_ == 0) {\\n ratio_ = 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0xe48b287a583b40e534654e4023422f59a9e6d7dd265d68ae4af43f8da58c09d9\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice it returns the current token index to use as a counter\\n * @return counter_ the current token index\\n */\\n function getCurrentTokenIndex() external view returns (uint256 counter_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x8a6979965f9d275eff9e034f207d605d7eb3506245de3604d2e02acc8196c2a6\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice it returns the current token index to use as a counter\\n * @return counter_ the current token index\\n */\\n function getCurrentTokenIndex()\\n external\\n view\\n override\\n returns (uint256 counter_)\\n {\\n counter_ = _tokenCounter.current();\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf42808068c07aa015fcf4a2922fb91cfb456a2f6c8fcfa6daa08b2dfbedf8817\",\"license\":\"MIT\"},\"contracts/nft/libraries/NFTLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../TellerNFT.sol\\\";\\n\\n// Libraries\\nimport {\\n MerkleProof\\n} from \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\nimport { NFTStorageLib, NFTStorage } from \\\"../../storage/nft.sol\\\";\\n\\nstruct NftLoanSizeProof {\\n uint256 id;\\n uint256 baseLoanSize;\\n bytes32[] proof;\\n}\\n\\nlibrary NFTLib {\\n function s() internal pure returns (NFTStorage storage s_) {\\n s_ = NFTStorageLib.store();\\n }\\n\\n function nft() internal view returns (TellerNFT nft_) {\\n nft_ = AppStorageLib.store().nft;\\n }\\n\\n /**s\\n * @notice it transfers the NFT from the sender to the diamond to stake then adds the NFTID to the list of the owner's stakedNFTs\\n * @param nftID the ID of the NFT to stake\\n * @param owner the owner of the NFT who will stake the NFT\\n */\\n function stake(uint256 nftID, address owner) internal {\\n // Transfer to diamond\\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\\n // Add NFT ID to user set\\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\\n }\\n\\n /**\\n * @notice it unstakes the NFT by removing the NFT ID from the list of the user's staked NFTs\\n * @param nftID the ID of the NFT to remove from the list of the user's staked NFTs\\n * @return success_ the boolean value telling us if the user has unsuccessfully unstaked the NFT\\n */\\n function unstake(uint256 nftID) internal returns (bool success_) {\\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\\n }\\n\\n /**\\n * @notice it gets the list of staked NFTs from the owner\\n * @param nftOwner the owner of the staked NFTs to pull from\\n * @return staked_ the array of the staked NFTs owned by the user\\n */\\n function stakedNFTs(address nftOwner)\\n internal\\n view\\n returns (uint256[] memory staked_)\\n {\\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\\n staked_ = new uint256[](EnumerableSet.length(nfts));\\n for (uint256 i; i < staked_.length; i++) {\\n staked_[i] = EnumerableSet.at(nfts, i);\\n }\\n }\\n\\n /**\\n * @notice if the user fails to pay his loan, then we liquidate the all the NFTs associated with the loan\\n * @param loanID the identifier of the loan to liquidate the NFTs from\\n */\\n function liquidateNFT(uint256 loanID) internal {\\n // Check if NFTs are linked\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n NFTLib.nft().transferFrom(\\n address(this),\\n AppStorageLib.store().nftLiquidationController,\\n EnumerableSet.at(nfts, i)\\n );\\n }\\n }\\n\\n /**\\n * @notice it unstakes an NFT and verifies the proof in order to apply the proof to a loan\\n * @param loanID the identifier of the loan\\n * @param proof the proof to be attached to a loan after verifying the loan size\\n */\\n function applyToLoan(uint256 loanID, NftLoanSizeProof calldata proof)\\n internal\\n {\\n // NFT must be currently staked\\n // Remove NFT from being staked - returns bool\\n require(unstake(proof.id), \\\"Teller: borrower nft not staked\\\");\\n\\n require(verifyLoanSize(proof), \\\"Teller invalid nft proof\\\");\\n\\n // Apply NFT to loan\\n EnumerableSet.add(s().loanNFTs[loanID], proof.id);\\n }\\n\\n /**\\n * @notice it finds the loan's NFTs and adds them back to the owner's list of staked NFTs\\n * @param loanID the identifier of the respective loan to add the NFTs back to the user's staked NFTs\\n * @param owner the owner to add the unstaked NFTs back to the staked pile\\n */\\n function restakeLinked(uint256 loanID, address owner) internal {\\n // Get linked NFT\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n // Restake the NFT\\n EnumerableSet.add(s().stakedNFTs[owner], EnumerableSet.at(nfts, i));\\n }\\n }\\n\\n /**\\n * @notice it verifies the NFT id to base loan size using the merkle proof\\n * @param proof the NFTLoanSizeProof to verify with the nft;s merkle root\\n * @return verified_ tells us if the loan is verified or not\\n */\\n function verifyLoanSize(NftLoanSizeProof calldata proof)\\n internal\\n view\\n returns (bool verified_)\\n {\\n verified_ = MerkleProof.verify(\\n proof.proof,\\n s().nftMerkleRoot,\\n keccak256(abi.encodePacked(proof.id, proof.baseLoanSize))\\n );\\n }\\n}\\n\",\"keccak256\":\"0x05effea10b3d191192b3b8f5515c2b083d2a8a80c1fae19c6a1abce53d8635fa\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n /**\\n * @notice it returns 10^{numberOfDecimals} for a token\\n * @param token the address to calculate the decimals for\\n * @return 10^number of decimals used to calculate the price and value of different token pairs\\n */\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @notice It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @notice it tries to calculate a price from Compound and Chainlink.\\n * @dev if no price is found on compound, then calculate it on chainlink\\n * @param src the token address to calculate the price for in dst\\n * @param dst the token address to retrieve the price of src\\n * @return price_ the price of src in dst\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n * @param src the address of the src token\\n * @param dst the address of the dst token\\n * @return the price of the src token in dst token\\n\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n * @param src the source token to calculate price for with chainlink\\n * @param dst the destination token to calculate price for with chainlink\\n * @param cRate the compound rate to multiply with the price of the dst token\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @notice Scales the {value} by the difference in decimal values.\\n * @param value the the value of the src in dst\\n * @param srcDecimals src token decimals\\n * @param dstDecimals dst token decimals\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @notice it tries to calculate the price of {src} in {dst}\\n * @param src address of source token\\n * @param dst address of destination token\\n * @return the price of src token in dst\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address WETH = AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n if (dst != WETH) {\\n int256 price1 = _priceFor(src, WETH);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, WETH);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice it checks if a token is a cToken. If it is, then get the underlying address\\n * @param token address of the token\\n * @return isCToken boolean whether it's a cToken\\n * @return underlying the address of the cToken\\n */\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2efb3d71a1c0fb49f8c455c4fa30d04c69a1617d619035fc400dabdeb2ab0c9e\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { PriceAggFacet } from \\\"./PriceAggFacet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\n/**\\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\\n */\\nlibrary PriceAggLib {\\n /**\\n * @notice It calculates the value of one token amount into another\\n * @param src the source token\\n * @param dst the destination token\\n * @param srcAmount the amount of source token\\n * @return value_ the returned value of src in dst\\n */\\n function valueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) internal view returns (uint256 value_) {\\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\\n }\\n\\n /**\\n * @notice It returns the price of the token pair as given from Compound.\\n * @dev if no compound price is calculated, then it checks Chainlink price Aggregator\\n * @param src the address of the source token\\n * @param dst the address of the desitnation token\\n * @return price_ gets the price of src in dst\\n */\\n function priceFor(address src, address dst)\\n internal\\n view\\n returns (int256 price_)\\n {\\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\\n }\\n}\\n\",\"keccak256\":\"0xff59eee567fa4a7f5cac432e31d918be92834f04614f49572d3984a5b030ac79\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\nabstract contract PausableMods {\\n /**\\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\\n * @param id id of the facet to check if is paused.\\n * @param state Boolean that the protocol AND facet should be in.\\n */\\n modifier paused(bytes32 id, bool state) {\\n require(\\n __isPaused(\\\"\\\") == state && __isPaused(id) == state,\\n __pausedMessage(state)\\n );\\n _;\\n }\\n\\n /**\\n * @dev Checks if the given id is paused.\\n * @param id Encoded id of the facet to check if is paused.\\n * @return the bool to tell us if the facet is paused (true) or not (false)\\n */\\n function __isPaused(bytes32 id) private view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n\\n /**\\n * @dev Gets the message that should be reverted with given a state it should be in.\\n * @param state Boolean that an id should be in.\\n * @return a message stating whether the facet is paused or not\\n */\\n function __pausedMessage(bool state) private pure returns (string memory) {\\n return state ? \\\"Pausable: not paused\\\" : \\\"Pausable: paused\\\";\\n }\\n}\\n\",\"keccak256\":\"0x2d3f848ee56ae5fa365539c2509c03c167affc89c89f98bb98cb9b83fbe8ae4c\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0xbeef1937dc1ed1f6f78b80f0737f018565ab264184cf05ef54c3c28ecd55a09b\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xacf6bcb8c4afd2f337a0161e8be64b016c1b350d336cd862245dd922fcd10f33\",\"license\":\"MIT\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n /**\\n * @notice Checks if the account should be allowed to mint tokens in the given market\\n * @param cToken The market to verify the mint against\\n * @param minter The account which would get the minted tokens\\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates mint and reverts on rejection. May emit logs.\\n * @param cToken Asset being minted\\n * @param minter The address minting the tokens\\n * @param mintAmount The amount of the underlying asset being minted\\n * @param mintTokens The number of tokens being minted\\n */\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to redeem tokens in the given market\\n * @param cToken The market to verify the redeem against\\n * @param redeemer The account which would redeem the tokens\\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates redeem and reverts on rejection. May emit logs.\\n * @param cToken Asset being redeemed\\n * @param redeemer The address redeeming the tokens\\n * @param redeemAmount The amount of the underlying asset being redeemed\\n * @param redeemTokens The number of tokens being redeemed\\n */\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\\n * @param cToken The market to verify the borrow against\\n * @param borrower The account which would borrow the asset\\n * @param borrowAmount The amount of underlying the account would borrow\\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates borrow and reverts on rejection. May emit logs.\\n * @param cToken Asset whose underlying is being borrowed\\n * @param borrower The address borrowing the underlying\\n * @param borrowAmount The amount of the underlying asset requested to borrow\\n */\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to repay a borrow in the given market\\n * @param cToken The market to verify the repay against\\n * @param payer The account which would repay the asset\\n * @param borrower The account which would borrowed the asset\\n * @param repayAmount The amount of the underlying asset the account would repay\\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\\n * @param cToken Asset being repaid\\n * @param payer The address repaying the borrow\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param borrowerIndex the index of the borrower\\n */\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n /**\\n * @notice Checks if the liquidation should be allowed to occur\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n */\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the seizing of assets should be allowed to occur\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates seize and reverts on rejection. May emit logs.\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to transfer tokens in the given market\\n * @param cToken The market to verify the transfer against\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates transfer and reverts on rejection. May emit logs.\\n * @param cToken Asset being transferred\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n */\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in all markets\\n * @param holder The address to claim COMP for\\n */\\n function claimComp(address holder) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in the specified markets\\n * @param holder The address to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n */\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n /**\\n * @notice Claim all comp accrued by the holders\\n * @param holders The addresses to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n * @param borrowers Whether or not to claim COMP earned by borrowing\\n * @param suppliers Whether or not to claim COMP earned by supplying\\n */\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n /**\\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\\n * @param cTokenBorrowed The address of the borrowed cToken\\n * @param cTokenCollateral The address of the collateral cToken\\n * @param repayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\\n */\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n /**\\n * @notice Return the address of the COMP token\\n * @return The address of COMP\\n */\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x38a824a4a21ce9370fa581a616d1bb9d311f27d8982a6b96ebeba90bd5fd0adb\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n \\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x37849041e4bee2dfa825677f69078521fcc94804aa5120f67dd12cc4133efcec\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @dev CETH is the only Compound token that does not support the {underlying} function.\\n * @param cToken address of the compound token\\n * @return address of the underlying cToken\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x99206384c27b0e68b1ec7b82260f6a47965f611875c018bc076ff8a688a6c6d7\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n /**\\n * @notice it returns the absolute number of a specified parameter\\n * @param self the number to be returned in it's absolute \\n * @return the absolute number\\n */\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0xa852b8866a3d6d928c6575bf2bcf2ae784eed73717c78c0cadbdedf8b0ba3274\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0c52fdd76b33f74e233c3a27dd3b73b134e9643aab347b3aa649c504809c6559\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\n// DEPRECATED\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\nstruct LoanRequest {\\n LoanUserRequest request;\\n LoanConsensusResponse[] responses;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanUserRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanConsensusResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) _loanTerms; // DEPRECATED: DO NOT REMOVE\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb7e05aeec806b5621512def93f4a389b4ef88c50ef9fe7115a33f57db2f2304b\",\"license\":\"MIT\"},\"contracts/storage/nft.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Utils\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct NFTStorage {\\n // Maps NFT owner to set of token IDs owned\\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\\n // Maps loanID to NFT IDs indicating NFT being used for the loan\\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\\n // Merkle root used for verifying nft IDs to base loan size\\n bytes32 nftMerkleRoot;\\n}\\n\\nbytes32 constant NFT_STORAGE_POS = keccak256(\\\"teller.staking.storage\\\");\\n\\nlibrary NFTStorageLib {\\n function store() internal pure returns (NFTStorage storage s) {\\n bytes32 pos = NFT_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\",\"keccak256\":\"0x09f8baabf2668e42e0554da99fda42f661e959f94645c2875e15585826a3a6e4\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "history": [ + { + "address": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "RepayFacet", + "transactionHash": "0x44d6b974ec21f1c4420ecb2be53506c60d1abe4b5fac2a2b5352ae4a3fb3bb5d", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "transactionIndex": 0, + "gasUsed": "1838004", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xecd0c4fcd32a0e212c29bf1a50f9095c4551299b06f40b8cb32c08eeeb3ab526", + "transactionHash": "0x44d6b974ec21f1c4420ecb2be53506c60d1abe4b5fac2a2b5352ae4a3fb3bb5d", + "logs": [], + "blockNumber": 25103793, + "cumulativeGasUsed": "1838004", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "dc3b3c0336b59a4fae33a8cd036a81b5", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"liquidator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"reward\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokensIn\",\"type\":\"uint256\"}],\"name\":\"LoanLiquidated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountPaid\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"totalOwed\",\"type\":\"uint256\"}],\"name\":\"LoanRepaid\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"escrowRepay\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLiquidationReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"inLending_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"inCollateral_\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"liquidateLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"repayLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"params\":{\"borrower\":\"Account address of the borrower\",\"liquidator\":\"Account address of the liquidator\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"reward\":\"Value in lending token paid out to liquidator\",\"tokensIn\":\"Percentage of the collateral price paid by the liquidator to the lending pool\"}},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"params\":{\"amountPaid\":\"Amount of the loan paid back\",\"borrower\":\"Account address of the borrower\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"payer\":\"Account address of the payer\",\"totalOwed\":\"Total amount of the loan to be repaid\"}}},\"kind\":\"dev\",\"methods\":{\"escrowRepay(uint256,uint256)\":{\"details\":\"If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\",\"params\":{\"amount\":\"The amount being repaid.\",\"loanID\":\"The id of the loan being used.\"}},\"getLiquidationReward(uint256)\":{\"params\":{\"loanID\":\"The loan ID to get the info.\"},\"returns\":{\"inCollateral_\":\"The value the liquidator will receive denoted in collateral tokens.\",\"inLending_\":\"The value the liquidator will receive denoted in lending tokens.\"}},\"liquidateLoan(uint256)\":{\"params\":{\"loanID\":\"The ID of the loan to be liquidated\"}},\"repayLoan(uint256,uint256)\":{\"params\":{\"amount\":\"The amount of tokens to pay back to the loan\",\"loanID\":\"The ID of the loan the payment is for\"}}},\"version\":1},\"userdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully liquidated\"},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully repaid\"}},\"kind\":\"user\",\"methods\":{\"escrowRepay(uint256,uint256)\":{\"notice\":\"Repay this Escrow's loan.\"},\"getLiquidationReward(uint256)\":{\"notice\":\"It gets the current liquidation reward for a given loan.\"},\"liquidateLoan(uint256)\":{\"notice\":\"Liquidate a loan if it is expired or under collateralized\"},\"repayLoan(uint256,uint256)\":{\"notice\":\"Make a payment to a loan\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/market/RepayFacet.sol\":\"RepayFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Trees proofs.\\n *\\n * The proofs can be generated using the JavaScript library\\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\\n *\\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n bytes32 computedHash = leaf;\\n\\n for (uint256 i = 0; i < proof.length; i++) {\\n bytes32 proofElement = proof[i];\\n\\n if (computedHash <= proofElement) {\\n // Hash(current computed hash + current element of the proof)\\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\\n } else {\\n // Hash(current element of the proof + current computed hash)\\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\\n }\\n }\\n\\n // Check if the computed hash (root) is equal to the provided root\\n return computedHash == root;\\n }\\n}\\n\",\"keccak256\":\"0xeee34bfb413657b6cd6c8e1e15c2080ba5ebaac479578515922804346fb63f7c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/reentry/ReentryMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nabstract contract ReentryMods {\\n modifier nonReentry(bytes32 id) {\\n AccessControlStorage storage s = AccessControlStorageLib.store();\\n require(!s.entered[id], \\\"AccessControl: reentered\\\");\\n s.entered[id] = true;\\n _;\\n s.entered[id] = false;\\n }\\n}\\n\",\"keccak256\":\"0x033c1164af25ef7d35a38a60973bf379b1cc603596914ffd85dcbcf0acdb6970\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../interfaces/IAToken.sol\\\";\\nimport { IAaveLendingPool } from \\\"../interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x8030b206c87d0073fb7dbebfa2ee8a3e93c479d976d6cdaa0c939f2fedaa1525\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n function setTokenAllowance(address token, address spender) external;\\n\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xdaa338698014e6c00edf7a2aca49026a047e253cbe7fc392a73f5f63a063a7f9\",\"license\":\"MIT\"},\"contracts/escrow/libraries/LibEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibDapps } from \\\"../dapps/libraries/LibDapps.sol\\\";\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibEscrow {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\\n e_ = s().loanEscrows[loanID];\\n }\\n\\n function getEscrowTokens(uint256 loanID)\\n internal\\n view\\n returns (EnumerableSet.AddressSet storage t_)\\n {\\n t_ = s().escrowTokens[loanID];\\n }\\n\\n function balanceOf(uint256 loanID, address token)\\n internal\\n view\\n returns (uint256)\\n {\\n return IERC20(token).balanceOf(address(e(loanID)));\\n }\\n\\n /**\\n * @notice Adds or removes tokens held by the Escrow contract\\n * @param loanID The loan ID to update the token list for\\n * @param tokenAddress The token address to be added or removed\\n */\\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\\n // Skip if is lending token\\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\\n\\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\\n if (balanceOf(loanID, tokenAddress) > 0) {\\n if (!contains) {\\n EnumerableSet.add(tokens, tokenAddress);\\n }\\n } else if (contains) {\\n EnumerableSet.remove(tokens, tokenAddress);\\n }\\n }\\n\\n /**\\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\\n * @param loanID The loan ID to calculate value for\\n * @return value_ Escrow total value denoted in the lending token.\\n */\\n function calculateTotalValue(uint256 loanID)\\n internal\\n view\\n returns (uint256 value_)\\n {\\n address lendingToken = LibLoans.loan(loanID).lendingToken;\\n value_ += balanceOf(loanID, lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\\n if (EnumerableSet.length(tokens) > 0) {\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n uint256 tokenBal =\\n balanceOf(loanID, EnumerableSet.at(tokens, i));\\n value_ += PriceAggLib.valueFor(\\n EnumerableSet.at(tokens, i),\\n lendingToken,\\n tokenBal\\n );\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xcca97599fff1c1bd608e7f11c4674f325e43781794e91bf5322ac9e0ffd7b3df\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when an user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when an user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @return totalSupply_ The total value of the underlying token managed by the LP.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given markets.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider o the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfil the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n */\\n function restrict(bool state) external virtual;\\n\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xe6515c78e0277edbed82aa6926df727afd216379dd0bfbbb790222654c858499\",\"license\":\"MIT\"},\"contracts/market/LoanDataFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { Loan, LoanDebt, LoanTerms } from \\\"../storage/market.sol\\\";\\n\\ncontract LoanDataFacet {\\n /**\\n * @notice Returns the information about the given {loanID}.\\n * @param loanID The loan ID to get information for.\\n * @return loan_ The loan data.\\n */\\n function getLoan(uint256 loanID) external view returns (Loan memory loan_) {\\n loan_ = LibLoans.s().loans[loanID];\\n }\\n\\n /**\\n * @notice Returns the terms for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanTerms The terms that the loan weer created with.\\n */\\n function getLoanTerms(uint256 loanID)\\n external\\n view\\n returns (LoanTerms memory)\\n {\\n return LibLoans.terms(loanID);\\n }\\n\\n /**\\n * @notice Returns the loan IDs created by the {borrower} account.\\n * @param borrower The account to get loan IDs for.\\n * @return loanIDs The IDs for loans created by the {borrower}\\n */\\n function getBorrowerLoans(address borrower)\\n external\\n view\\n returns (uint128[] memory loanIDs)\\n {\\n return LibLoans.s().borrowerLoans[borrower];\\n }\\n\\n /**\\n * @notice Returns the debt owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanDebt The principal and interest owed amount.\\n */\\n function getDebtOwed(uint256 loanID)\\n external\\n view\\n returns (LoanDebt memory)\\n {\\n return LibLoans.debt(loanID);\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) external view returns (uint256) {\\n return LibLoans.getTotalOwed(loanID);\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n external\\n view\\n returns (uint256)\\n {\\n return LibLoans.getInterestOwedFor(loanID, amountBorrow);\\n }\\n\\n function getCollateralNeededInfo(uint256 loanID)\\n external\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n return LibLoans.getCollateralNeededInfo(loanID);\\n }\\n\\n function getLoanEscrow(uint256 loanID)\\n external\\n view\\n returns (address escrow_)\\n {\\n escrow_ = address(LibLoans.s().loanEscrows[loanID]);\\n }\\n\\n function getLoanEscrowValue(uint256 loanID)\\n external\\n view\\n returns (uint256)\\n {\\n return LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n function getEscrowTokens(uint256 loanID)\\n external\\n view\\n returns (address[] memory tokens_)\\n {\\n EnumerableSet.AddressSet storage escrowTokens =\\n LibEscrow.getEscrowTokens(loanID);\\n tokens_ = new address[](EnumerableSet.length(escrowTokens));\\n for (uint256 i; i < tokens_.length; i++) {\\n tokens_[i] = EnumerableSet.at(escrowTokens, i);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf589a2afff647e5288e15f3f6614135395562b4d12c743402a6504a3fb9b39d6\",\"license\":\"MIT\"},\"contracts/market/RepayFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\nimport {\\n ReentryMods\\n} from \\\"../contexts2/access-control/reentry/ReentryMods.sol\\\";\\nimport { AUTHORIZED } from \\\"../shared/roles.sol\\\";\\nimport { LoanDataFacet } from \\\"./LoanDataFacet.sol\\\";\\n\\n// Libraries\\nimport {\\n IERC20,\\n SafeERC20\\n} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibCollateral } from \\\"./libraries/LibCollateral.sol\\\";\\nimport { LibDapps } from \\\"../escrow/dapps/libraries/LibDapps.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { NumbersLib } from \\\"../shared/libraries/NumbersLib.sol\\\";\\nimport { PriceAggLib } from \\\"../price-aggregator/PriceAggLib.sol\\\";\\nimport { NFTLib } from \\\"../nft/libraries/NFTLib.sol\\\";\\n\\n// Interfaces\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus\\n} from \\\"../storage/market.sol\\\";\\n\\ncontract RepayFacet is RolesMods, ReentryMods, PausableMods {\\n /**\\n @notice This event is emitted when a loan has been successfully repaid\\n @param loanID ID of loan from which collateral was withdrawn\\n @param borrower Account address of the borrower\\n @param amountPaid Amount of the loan paid back\\n @param payer Account address of the payer\\n @param totalOwed Total amount of the loan to be repaid\\n */\\n event LoanRepaid(\\n uint256 indexed loanID,\\n address indexed borrower,\\n uint256 amountPaid,\\n address payer,\\n uint256 totalOwed\\n );\\n\\n /**\\n * @notice This event is emitted when a loan has been successfully liquidated\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param borrower Account address of the borrower\\n * @param liquidator Account address of the liquidator\\n * @param reward Value in lending token paid out to liquidator\\n * @param tokensIn Percentage of the collateral price paid by the liquidator to the lending pool\\n */\\n event LoanLiquidated(\\n uint256 indexed loanID,\\n address indexed borrower,\\n address liquidator,\\n uint256 reward,\\n uint256 tokensIn\\n );\\n\\n /**\\n * @notice Repay this Escrow's loan.\\n * @dev If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.\\n * @dev Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\\n * @param loanID The id of the loan being used.\\n * @param amount The amount being repaid.\\n */\\n function escrowRepay(uint256 loanID, uint256 amount)\\n external\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n nonReentry(\\\"\\\")\\n {\\n uint256 balance =\\n LibEscrow.balanceOf(loanID, LibLoans.loan(loanID).lendingToken);\\n uint256 totalOwed = LibLoans.getTotalOwed(loanID);\\n if (balance < totalOwed && amount > balance) {\\n uint256 amountNeeded =\\n amount > totalOwed ? totalOwed - (balance) : amount - (balance);\\n\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n msg.sender,\\n address(LibEscrow.e(loanID)),\\n amountNeeded\\n );\\n }\\n\\n __repayLoan(loanID, amount, address(LibEscrow.e(loanID)), false);\\n }\\n\\n /**\\n * @notice Make a payment to a loan\\n * @param loanID The ID of the loan the payment is for\\n * @param amount The amount of tokens to pay back to the loan\\n */\\n function repayLoan(uint256 loanID, uint256 amount)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n __repayLoan(loanID, amount, msg.sender, false);\\n }\\n\\n function __repayLoan(\\n uint256 loanID,\\n uint256 amount,\\n address sender,\\n bool isLiquidation\\n ) private returns (uint256 leftToPay_) {\\n require(amount > 0, \\\"Teller: zero repay\\\");\\n\\n // calculate the actual amount to repay\\n leftToPay_ =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n if (leftToPay_ < amount) {\\n amount = leftToPay_;\\n leftToPay_ = 0;\\n } else {\\n leftToPay_ -= amount;\\n }\\n\\n // Get the Teller token for the loan\\n ITToken tToken =\\n MarketStorageLib.store().tTokens[\\n LibLoans.loan(loanID).lendingToken\\n ];\\n // Transfer funds from account\\n if (address(LibEscrow.e(loanID)) == sender) {\\n LibEscrow.e(loanID).claimToken(\\n LibLoans.loan(loanID).lendingToken,\\n address(tToken),\\n amount\\n );\\n } else {\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n sender,\\n address(tToken),\\n amount\\n );\\n }\\n\\n // Deduct the interest and principal owed\\n uint256 principalPaid;\\n uint256 interestPaid;\\n if (amount < LibLoans.debt(loanID).interestOwed) {\\n interestPaid = amount;\\n LibLoans.debt(loanID).interestOwed -= amount;\\n } else {\\n if (LibLoans.debt(loanID).interestOwed > 0) {\\n interestPaid = LibLoans.debt(loanID).interestOwed;\\n amount -= interestPaid;\\n LibLoans.debt(loanID).interestOwed = 0;\\n }\\n\\n if (amount > 0) {\\n principalPaid = amount;\\n LibLoans.debt(loanID).principalOwed -= amount;\\n }\\n }\\n\\n // Tell the Teller Token value has been deposited back into the pool.\\n tToken.repayLoan(principalPaid, interestPaid);\\n\\n if (isLiquidation) {\\n // Make sure there is nothing left to repay on the loan\\n require(leftToPay_ == 0, \\\"Teller: liquidate partial repay\\\");\\n\\n // Set loan status\\n LibLoans.loan(loanID).status = LoanStatus.Liquidated;\\n\\n // Transfer NFT if linked\\n NFTLib.liquidateNFT(loanID);\\n } else {\\n // if the loan is now fully paid, close it and withdraw borrower collateral\\n if (leftToPay_ == 0) {\\n LibLoans.loan(loanID).status = LoanStatus.Closed;\\n LibCollateral.withdrawAll(\\n loanID,\\n LibLoans.loan(loanID).borrower\\n );\\n // Restake any NFTs linked to loan for borrower\\n NFTLib.restakeLinked(loanID, LibLoans.loan(loanID).borrower);\\n }\\n\\n emit LoanRepaid(\\n loanID,\\n LibLoans.loan(loanID).borrower,\\n amount,\\n msg.sender,\\n leftToPay_\\n );\\n }\\n }\\n\\n /**\\n * @notice Liquidate a loan if it is expired or under collateralized\\n * @param loanID The ID of the loan to be liquidated\\n */\\n function liquidateLoan(uint256 loanID)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n uint256 collateralAmount = LibCollateral.e(loanID).loanSupply(loanID);\\n require(\\n RepayLib.isLiquidable(loanID, collateralAmount),\\n \\\"Teller: does not need liquidation\\\"\\n );\\n\\n // Calculate the reward before repaying the loan\\n (uint256 rewardInLending, uint256 collateralInLending) =\\n RepayLib.getLiquidationReward(loanID, collateralAmount);\\n\\n // The liquidator pays the amount still owed on the loan\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n __repayLoan(loanID, amountToLiquidate, msg.sender, true);\\n\\n // Payout the liquidator reward owed\\n if (rewardInLending > 0) {\\n RepayLib.payOutLiquidator(\\n loanID,\\n rewardInLending,\\n collateralInLending,\\n collateralAmount,\\n payable(msg.sender)\\n );\\n }\\n\\n emit LoanLiquidated(\\n loanID,\\n loan.borrower,\\n msg.sender,\\n rewardInLending,\\n amountToLiquidate\\n );\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @return inLending_ The value the liquidator will receive denoted in lending tokens.\\n * @return inCollateral_ The value the liquidator will receive denoted in collateral tokens.\\n */\\n function getLiquidationReward(uint256 loanID)\\n external\\n view\\n returns (uint256 inLending_, uint256 inCollateral_)\\n {\\n (inLending_, ) = RepayLib.getLiquidationReward(\\n loanID,\\n LibCollateral.e(loanID).loanSupply(loanID)\\n );\\n inCollateral_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n inLending_\\n );\\n }\\n}\\n\\nlibrary RepayLib {\\n /**\\n * @notice It checks if a loan can be liquidated.\\n * @param loanID The loan ID to check.\\n * @return true if the loan is liquidable.\\n */\\n function isLiquidable(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (bool)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n // Check if loan can be liquidated\\n if (loan.status != LoanStatus.Active) {\\n return false;\\n }\\n\\n if (loan.collateralRatio > 0) {\\n // If loan has a collateral ratio, check how much is needed\\n (, uint256 neededInCollateral, ) =\\n LoanDataFacet(address(this)).getCollateralNeededInfo(loanID);\\n if (neededInCollateral > collateralAmount) {\\n return true;\\n }\\n }\\n\\n // Otherwise, check if the loan has expired\\n return block.timestamp >= loan.loanStartTime + loan.duration;\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @param collateralAmount The amount of collateral for the {loanID}. Passed in to save gas calling the collateral escrow multiple times.\\n * @return reward_ The value the liquidator will receive denoted in lending tokens.\\n */\\n function getLiquidationReward(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (uint256 reward_, uint256 collateralValue_)\\n {\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n // Max reward is amount repaid on loan plus extra percentage\\n uint256 maxReward =\\n amountToLiquidate +\\n NumbersLib.percent(\\n amountToLiquidate,\\n uint16(PlatformSettingsLib.getLiquidateRewardPercent())\\n );\\n\\n // Calculate available collateral for reward\\n if (collateralAmount > 0) {\\n collateralValue_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).collateralToken,\\n LibLoans.loan(loanID).lendingToken,\\n collateralAmount\\n );\\n reward_ += collateralValue_;\\n }\\n\\n // Calculate loan escrow value if collateral not enough to cover reward\\n if (reward_ < maxReward) {\\n reward_ += LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n // Cap the reward to max\\n if (reward_ > maxReward) {\\n reward_ = maxReward;\\n }\\n }\\n\\n /**\\n * @notice Checks if the loan has an Escrow and claims any tokens then pays out the loan collateral.\\n * @dev See Escrow.claimTokens for more info.\\n * @param loanID The loan ID which is being liquidated\\n * @param rewardInLending The total amount of reward based in the lending token to pay the liquidator\\n * @param collateralInLending The amount of collateral that is available for the loan denoted in lending tokens\\n * @param collateralAmount The amount of collateral that is available for the loan\\n * @param liquidator The address of the liquidator where the liquidation reward will be sent to\\n */\\n function payOutLiquidator(\\n uint256 loanID,\\n uint256 rewardInLending,\\n uint256 collateralInLending,\\n uint256 collateralAmount,\\n address payable liquidator\\n ) internal {\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Liquidated,\\n \\\"Teller: loan not liquidated\\\"\\n );\\n\\n if (rewardInLending <= collateralInLending) {\\n uint256 rewardInCollateral =\\n PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n rewardInLending\\n );\\n\\n LibCollateral.withdraw(loanID, rewardInCollateral, liquidator);\\n } else {\\n // Payout whats available in the collateral token\\n LibCollateral.withdraw(loanID, collateralAmount, liquidator);\\n\\n // Claim remaining reward value from the loan escrow\\n claimEscrowTokensByValue(\\n loanID,\\n liquidator,\\n rewardInLending - collateralInLending\\n );\\n }\\n }\\n\\n /**\\n * @dev Send the equivalent of tokens owned by the loan escrow (in lending value) to the recipient,\\n * @param loanID The loan ID to clam tokens from\\n * @param recipient address to send the tokens to\\n * @param value The value of escrow held tokens to be claimed based in lending value\\n */\\n function claimEscrowTokensByValue(\\n uint256 loanID,\\n address recipient,\\n uint256 value\\n ) private {\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n uint256 valueLeftToTransfer = value;\\n\\n // Start with the lending token\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n LibLoans.loan(loanID).lendingToken,\\n recipient,\\n valueLeftToTransfer\\n );\\n\\n // Cycle through remaining tokens\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n if (valueLeftToTransfer == 0) {\\n return;\\n }\\n\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n EnumerableSet.at(tokens, i),\\n recipient,\\n valueLeftToTransfer\\n );\\n }\\n }\\n\\n function claimEscrowToken(\\n uint256 loanID,\\n address token,\\n address recipient,\\n uint256 valueLeftToTransfer\\n ) private returns (uint256) {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n // get value of token balance in lending value\\n if (balance > 0) {\\n // If token not the lending token, get value of token\\n uint256 balanceInLending;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n balanceInLending = balance;\\n } else {\\n balanceInLending = PriceAggLib.valueFor(\\n token,\\n LibLoans.loan(loanID).lendingToken,\\n balance\\n );\\n }\\n\\n if (balanceInLending <= valueLeftToTransfer) {\\n LibEscrow.e(loanID).claimToken(token, recipient, balance);\\n valueLeftToTransfer -= balanceInLending;\\n } else {\\n // Token balance is more than enough so calculate ratio of balance to transfer\\n uint256 valueToTransfer;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n valueToTransfer = valueLeftToTransfer;\\n } else {\\n valueToTransfer = NumbersLib.percent(\\n balance,\\n NumbersLib.ratioOf(\\n valueLeftToTransfer,\\n balanceInLending\\n )\\n );\\n }\\n\\n LibEscrow.e(loanID).claimToken(\\n token,\\n recipient,\\n valueToTransfer\\n );\\n valueLeftToTransfer = 0;\\n }\\n }\\n\\n return valueLeftToTransfer;\\n }\\n}\\n\",\"keccak256\":\"0xdfcd62dbcda7ba0ce92718d72d6cab3f7c78178d9ac9de6b04640124d43bf4cc\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n function init(address tokenAddress, bool isWETH) external;\\n\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x3c83593b5521e85c7f62076b41869cd5a762b34523ac39fc23b4ea1b9042aa59\",\"license\":\"MIT\"},\"contracts/market/libraries/LibCollateral.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport { ICollateralEscrow } from \\\"../collateral/ICollateralEscrow.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\nimport { MarketStorageLib } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibCollateral {\\n /**\\n * @notice This event is emitted when collateral has been deposited for the loan\\n * @param loanID ID of the loan for which collateral was deposited\\n * @param depositor Account that deposited funds\\n * @param amount Amount of collateral deposited\\n */\\n event CollateralDeposited(\\n uint256 indexed loanID,\\n address indexed depositor,\\n uint256 amount\\n );\\n\\n /**\\n * @notice This event is emitted when collateral has been withdrawn\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param receiver Account that received funds\\n * @param amount Value of collateral withdrawn\\n */\\n event CollateralWithdrawn(\\n uint256 indexed loanID,\\n address indexed receiver,\\n uint256 amount\\n );\\n\\n function e(uint256 loanID) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[\\n MarketStorageLib.store().loans[loanID].collateralToken\\n ];\\n }\\n\\n function e(address token) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[token];\\n }\\n\\n function deposit(uint256 loanID, uint256 amount) internal {\\n e(loanID).deposit{ value: amount }(loanID, amount);\\n\\n emit CollateralDeposited(loanID, msg.sender, amount);\\n }\\n\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) internal {\\n e(loanID).withdraw(loanID, amount, receiver);\\n\\n emit CollateralWithdrawn(loanID, receiver, amount);\\n }\\n\\n function withdrawAll(uint256 loanID, address payable receiver) internal {\\n withdraw(loanID, e(loanID).loanSupply(loanID), receiver);\\n }\\n\\n function createEscrow(address token) internal {\\n // Check if collateral escrow exists\\n if (address(e(token)) == address(0)) {\\n // Create escrow\\n address escrow =\\n AppStorageLib.store().collateralEscrowBeacon.cloneProxy(\\\"\\\");\\n ICollateralEscrow(escrow).init(\\n token,\\n // Check if collateral token is WETH\\n token == AppStorageLib.store().assetAddresses[\\\"WETH\\\"]\\n );\\n\\n // Set max allowance\\n IERC20(token).approve(escrow, type(uint256).max);\\n // Save escrow address for loan\\n MarketStorageLib.store().collateralEscrows[\\n token\\n ] = ICollateralEscrow(escrow);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd52b3e577480481b62d6a6c37f4ef596b7ec0120afbd6bc1a08b17923b926445\",\"license\":\"MIT\"},\"contracts/market/libraries/LibLoans.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibEscrow } from \\\"../../escrow/libraries/LibEscrow.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus,\\n LoanDebt,\\n LoanTerms\\n} from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibLoans {\\n using NumbersLib for int256;\\n using NumbersLib for uint256;\\n\\n bytes32 internal constant ID = keccak256(\\\"LOANS\\\");\\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\\n l_ = s().loans[loanID];\\n }\\n\\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\\n d_ = s().loanDebt[loanID];\\n }\\n\\n function terms(uint256 loanID)\\n internal\\n view\\n returns (LoanTerms storage t_)\\n {\\n t_ = s().loanTerms[loanID];\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) internal view returns (uint256) {\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n uint256 interestOwed =\\n getInterestOwedFor(loanID, terms(loanID).maxLoanAmount);\\n return terms(loanID).maxLoanAmount + (interestOwed);\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n return debt(loanID).principalOwed + (debt(loanID).interestOwed);\\n }\\n return 0;\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n internal\\n view\\n returns (uint256)\\n {\\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\\n }\\n\\n function getCollateralNeededInfo(uint256 loanID)\\n internal\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\\n loanID\\n );\\n\\n if (neededInLendingTokens == 0) {\\n neededInCollateralTokens = 0;\\n } else {\\n neededInCollateralTokens = PriceAggLib.valueFor(\\n loan(loanID).lendingToken,\\n loan(loanID).collateralToken,\\n neededInLendingTokens\\n );\\n }\\n }\\n\\n /**\\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\\n * @param loanID The loan ID to get needed collateral info for.\\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\\n */\\n function getCollateralNeededInTokens(uint256 loanID)\\n internal\\n view\\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\\n {\\n if (!_isActiveOrSet(loanID) || loan(loanID).collateralRatio == 0) {\\n return (0, 0);\\n }\\n\\n /*\\n The collateral to principal owed ratio is the sum of:\\n * collateral buffer percent\\n * loan interest rate\\n * liquidation reward percent\\n * X factor of additional collateral\\n */\\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n neededInLendingTokens = _getLoanAmount(loanID).percent(\\n loan(loanID).collateralRatio\\n );\\n } else {\\n uint16 requiredRatio =\\n loan(loanID).collateralRatio -\\n getInterestRatio(loanID) -\\n uint16(PlatformSettingsLib.getCollateralBufferValue());\\n\\n neededInLendingTokens =\\n debt(loanID).principalOwed +\\n debt(loanID).interestOwed;\\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\\n if (\\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\\n ) {\\n neededInLendingTokens -= escrowLoanValue;\\n }\\n neededInLendingTokens = neededInLendingTokens.percent(\\n requiredRatio\\n );\\n }\\n }\\n\\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\\n internal\\n view\\n returns (bool)\\n {\\n return\\n collateralRatio >=\\n PlatformSettingsLib.getOverCollateralizedBufferValue();\\n }\\n\\n /**\\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\\n * @notice There is a minimum threshold of 1%.\\n * @dev The interest rate on the loan terms is APY.\\n * @param loanID The loan ID to get the interest rate for.\\n */\\n function getInterestRatio(uint256 loanID)\\n internal\\n view\\n returns (uint16 ratio_)\\n {\\n ratio_ = uint16(\\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\\n SECONDS_PER_YEAR\\n );\\n\\n if (ratio_ == 0) {\\n ratio_ = 1;\\n }\\n }\\n\\n function _getLoanAmount(uint256 loanID) private view returns (uint256) {\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n return terms(loanID).maxLoanAmount;\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n return loan(loanID).borrowedAmount;\\n }\\n return 0;\\n }\\n\\n function _isActiveOrSet(uint256 loanID) private view returns (bool) {\\n LoanStatus status = loan(loanID).status;\\n return status == LoanStatus.Active || status == LoanStatus.TermsSet;\\n }\\n}\\n\",\"keccak256\":\"0x9bf9fae5b01110da7c5a5d2517fdea6aa880d5c1647ba6125c68cafad278499b\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x7c788b94c175b70eec6b10bfe0655616fc0beb2ce3ef70a6fa750f291d35106c\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}.\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x39fd6d70fd1aa5ae45465d7eeb38f74e2bf90535c2510782fb0bb5f720250ac5\",\"license\":\"MIT\"},\"contracts/nft/libraries/NFTLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../TellerNFT.sol\\\";\\n\\n// Libraries\\nimport {\\n MerkleProof\\n} from \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\nimport { NFTStorageLib, NFTStorage } from \\\"../../storage/nft.sol\\\";\\n\\nstruct NftLoanSizeProof {\\n uint256 id;\\n uint256 baseLoanSize;\\n bytes32[] proof;\\n}\\n\\nlibrary NFTLib {\\n function s() internal pure returns (NFTStorage storage s_) {\\n s_ = NFTStorageLib.store();\\n }\\n\\n function nft() internal view returns (TellerNFT nft_) {\\n nft_ = AppStorageLib.store().nft;\\n }\\n\\n function stake(uint256 nftID, address owner) internal {\\n // Transfer to diamond\\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\\n // Add NFT ID to user set\\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\\n }\\n\\n function unstake(uint256 nftID) internal returns (bool success_) {\\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\\n }\\n\\n function stakedNFTs(address nftOwner)\\n internal\\n view\\n returns (uint256[] memory staked_)\\n {\\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\\n staked_ = new uint256[](EnumerableSet.length(nfts));\\n for (uint256 i; i < staked_.length; i++) {\\n staked_[i] = EnumerableSet.at(nfts, i);\\n }\\n }\\n\\n function liquidateNFT(uint256 loanID) internal {\\n // Check if NFTs are linked\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n NFTLib.nft().transferFrom(\\n address(this),\\n AppStorageLib.store().nftLiquidationController,\\n EnumerableSet.at(nfts, i)\\n );\\n }\\n }\\n\\n function applyToLoan(uint256 loanID, NftLoanSizeProof calldata proof)\\n internal\\n {\\n // NFT must be currently staked\\n // Remove NFT from being staked - returns bool\\n require(unstake(proof.id), \\\"Teller: borrower nft not staked\\\");\\n\\n require(verifyLoanSize(proof), \\\"Teller invalid nft proof\\\");\\n\\n // Apply NFT to loan\\n EnumerableSet.add(s().loanNFTs[loanID], proof.id);\\n }\\n\\n function restakeLinked(uint256 loanID, address owner) internal {\\n // Get linked NFT\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n // Restake the NFT\\n EnumerableSet.add(s().stakedNFTs[owner], EnumerableSet.at(nfts, i));\\n }\\n }\\n\\n function verifyLoanSize(NftLoanSizeProof calldata proof)\\n internal\\n view\\n returns (bool verified_)\\n {\\n verified_ = MerkleProof.verify(\\n proof.proof,\\n s().nftMerkleRoot,\\n keccak256(abi.encodePacked(proof.id, proof.baseLoanSize))\\n );\\n }\\n}\\n\",\"keccak256\":\"0x99ba27095901d86a4d1e1b9ec3a603fbbf7c67ada2ccd11cd5ed0435e5c3c66d\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @dev It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @dev Tries to calculate a price from Compound and Chainlink.\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @dev Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @dev Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @dev Scales the {value} by the difference in decimal values.\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @dev Tries to calculate the price of {src} in {dst}\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address WETH = AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n if (dst != WETH) {\\n int256 price1 = _priceFor(src, WETH);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, WETH);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf84fd8d9a179ca7a70e75677870bdd7a5be7da097cf5f1bccf1c9f93253bda90\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { PriceAggFacet } from \\\"./PriceAggFacet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\n/**\\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\\n */\\nlibrary PriceAggLib {\\n /**\\n * @notice See {PriceAggFacet.getValueFor}\\n */\\n function valueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) internal view returns (uint256 value_) {\\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\\n }\\n\\n /**\\n * @notice See {PriceAggFacet.getPriceFor}\\n */\\n function priceFor(address src, address dst)\\n internal\\n view\\n returns (int256 price_)\\n {\\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\\n }\\n}\\n\",\"keccak256\":\"0x510633e39e7a30533d703eb7ec314c037772721fdb7cea96046cd6837bcb76c3\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\nabstract contract PausableMods {\\n /**\\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\\n * @param id id of the facet to check if is paused.\\n * @param state Boolean that the protocol AND facet should be in.\\n */\\n modifier paused(bytes32 id, bool state) {\\n require(\\n __isPaused(\\\"\\\") == state && __isPaused(id) == state,\\n __pausedMessage(state)\\n );\\n _;\\n }\\n\\n /**\\n * @dev Checks if the given id is paused.\\n * @param id Encoded id of the facet to check if is paused.\\n */\\n function __isPaused(bytes32 id) private view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n\\n /**\\n * @dev Gets the message that should be reverted with given a state it should be in.\\n * @param state Boolean that an id should be in.\\n */\\n function __pausedMessage(bool state) private pure returns (string memory) {\\n return state ? \\\"Pausable: not paused\\\" : \\\"Pausable: paused\\\";\\n }\\n}\\n\",\"keccak256\":\"0x772d8b9b63e9b8e78f243a70988f1a1e1100272cf317259ea173829f7b9bdf0e\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0xbeef1937dc1ed1f6f78b80f0737f018565ab264184cf05ef54c3c28ecd55a09b\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xacf6bcb8c4afd2f337a0161e8be64b016c1b350d336cd862245dd922fcd10f33\",\"license\":\"MIT\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n function claimComp(address holder) external;\\n\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x495d8bb746a524fea6ddc4286c955d7a0160718bf662456330a9d6d14b8a5da9\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n\\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x208769886b3db8f03ef1fa26f1caee189038dfc744b9a499402fc4e4c0090c38\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4d9045666e86d675f7bd48202f9a77d0675fa20b2184131ad369710ac5eb3203\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @notice CETH is the only Compound token that does not support the {underlying} function.\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x14e96659912e9d03ae30732faca8e3d617f3e756a215d948cabedab6642c1465\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0x998aefaf4edbe7b0cb41032750b65b3822b4bec0fec3ee5b396f8fb73b5e9e03\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0x8919fcdfb49018474c872c462c11b21a50faa7ab80f0162abd6b657cbbc5d04c\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x0888cf40ea019be9f0ee94cb8af1e030454c28f8c6512db9d89ed027fe21f18f\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n bool initialized;\\n bool platformRestricted;\\n mapping(bytes32 => bool) paused;\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0xade1dda8163fc39658e5f6929b662187584b29cce47e9cb0915fc0d1832fb4f7\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) loanTerms;\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5f3fdba19ae8040e2007affe422527b7dca58ba424df33ba4dd9cb08d83d00de\",\"license\":\"MIT\"},\"contracts/storage/nft.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Utils\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct NFTStorage {\\n // Maps NFT owner to set of token IDs owned\\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\\n // Maps loanID to NFT IDs indicating NFT being used for the loan\\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\\n // Merkle root used for verifying nft IDs to base loan size\\n bytes32 nftMerkleRoot;\\n}\\n\\nbytes32 constant NFT_STORAGE_POS = keccak256(\\\"teller.staking.storage\\\");\\n\\nlibrary NFTStorageLib {\\n function store() internal pure returns (NFTStorage storage s) {\\n bytes32 pos = NFT_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x8d58bb6ba00310d8c3d89b95c62e5c997430a1124d73224897f7d9b2a43ab50a\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "params": { + "borrower": "Account address of the borrower", + "liquidator": "Account address of the liquidator", + "loanID": "ID of loan from which collateral was withdrawn", + "reward": "Value in lending token paid out to liquidator", + "tokensIn": "Percentage of the collateral price paid by the liquidator to the lending pool" + } + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "params": { + "amountPaid": "Amount of the loan paid back", + "borrower": "Account address of the borrower", + "loanID": "ID of loan from which collateral was withdrawn", + "payer": "Account address of the payer", + "totalOwed": "Total amount of the loan to be repaid" + } + } + }, + "kind": "dev", + "methods": { + "escrowRepay(uint256,uint256)": { + "details": "If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.", + "params": { + "amount": "The amount being repaid.", + "loanID": "The id of the loan being used." + } + }, + "getLiquidationReward(uint256)": { + "params": { + "loanID": "The loan ID to get the info." + }, + "returns": { + "inCollateral_": "The value the liquidator will receive denoted in collateral tokens.", + "inLending_": "The value the liquidator will receive denoted in lending tokens." + } + }, + "liquidateLoan(uint256)": { + "params": { + "loanID": "The ID of the loan to be liquidated" + } + }, + "repayLoan(uint256,uint256)": { + "params": { + "amount": "The amount of tokens to pay back to the loan", + "loanID": "The ID of the loan the payment is for" + } + } + }, + "version": 1 + }, + "userdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "notice": "This event is emitted when a loan has been successfully liquidated" + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "notice": "This event is emitted when a loan has been successfully repaid" + } + }, + "kind": "user", + "methods": { + "escrowRepay(uint256,uint256)": { + "notice": "Repay this Escrow's loan." + }, + "getLiquidationReward(uint256)": { + "notice": "It gets the current liquidation reward for a given loan." + }, + "liquidateLoan(uint256)": { + "notice": "Liquidate a loan if it is expired or under collateralized" + }, + "repayLoan(uint256,uint256)": { + "notice": "Make a payment to a loan" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "params": { + "borrower": "Account address of the borrower", + "liquidator": "Account address of the liquidator", + "loanID": "ID of loan from which collateral was withdrawn", + "reward": "Value in lending token paid out to liquidator", + "tokensIn": "Percentage of the collateral price paid by the liquidator to the lending pool" + } + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "params": { + "amountPaid": "Amount of the loan paid back", + "borrower": "Account address of the borrower", + "loanID": "ID of loan from which collateral was withdrawn", + "payer": "Account address of the payer", + "totalOwed": "Total amount of the loan to be repaid" + } + } + }, + "kind": "dev", + "methods": { + "escrowRepay(uint256,uint256)": { + "details": "If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.", + "params": { + "amount": "The amount being repaid.", + "loanID": "The id of the loan being used." + } + }, + "getLiquidationReward(uint256)": { + "params": { + "loanID": "The loan ID to get the info." + }, + "returns": { + "inCollateral_": "The value the liquidator will receive denoted in collateral tokens.", + "inLending_": "The value the liquidator will receive denoted in lending tokens." + } + }, + "liquidateLoan(uint256)": { + "params": { + "loanID": "The ID of the loan to be liquidated" + } + }, + "repayLoan(uint256,uint256)": { + "params": { + "amount": "The amount of tokens to pay back to the loan", + "loanID": "The ID of the loan the payment is for" + } + } + }, + "version": 1 + }, + "userdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "notice": "This event is emitted when a loan has been successfully liquidated" + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "notice": "This event is emitted when a loan has been successfully repaid" + } + }, + "kind": "user", + "methods": { + "escrowRepay(uint256,uint256)": { + "notice": "Repay this Escrow's loan." + }, + "getLiquidationReward(uint256)": { + "notice": "It gets the current liquidation reward for a given loan." + }, + "liquidateLoan(uint256)": { + "notice": "Liquidate a loan if it is expired or under collateralized" + }, + "repayLoan(uint256,uint256)": { + "notice": "Make a payment to a loan" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0xE1C9D9f11fc759b4c60e13b5D11502c0B27AF2b7", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "RepayFacet", + "transactionHash": "0x1935806b4b4c40659e42bf0df36f2a1f4a7372e1a5c9af48978bae9a995a869f", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0xE1C9D9f11fc759b4c60e13b5D11502c0B27AF2b7", + "transactionIndex": 0, + "gasUsed": "1757520", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0x1504224d4aaec4de1e099a878f24e951d6e7e695e8fcb62e10cce5f4739607f4", + "transactionHash": "0x1935806b4b4c40659e42bf0df36f2a1f4a7372e1a5c9af48978bae9a995a869f", + "logs": [], + "blockNumber": 25370072, + "cumulativeGasUsed": "1757520", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "30b10b47777600ec7ec3ced16ef7024b", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"liquidator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"reward\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokensIn\",\"type\":\"uint256\"}],\"name\":\"LoanLiquidated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountPaid\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"totalOwed\",\"type\":\"uint256\"}],\"name\":\"LoanRepaid\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"escrowRepay\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLiquidationReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"inLending_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"inCollateral_\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"liquidateLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"repayLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"params\":{\"borrower\":\"Account address of the borrower\",\"liquidator\":\"Account address of the liquidator\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"reward\":\"Value in lending token paid out to liquidator\",\"tokensIn\":\"Percentage of the collateral price paid by the liquidator to the lending pool\"}},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"params\":{\"amountPaid\":\"Amount of the loan paid back\",\"borrower\":\"Account address of the borrower\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"payer\":\"Account address of the payer\",\"totalOwed\":\"Total amount of the loan to be repaid\"}}},\"kind\":\"dev\",\"methods\":{\"escrowRepay(uint256,uint256)\":{\"details\":\"If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\",\"params\":{\"amount\":\"The amount being repaid.\",\"loanID\":\"The id of the loan being used.\"}},\"getLiquidationReward(uint256)\":{\"params\":{\"loanID\":\"The loan ID to get the info.\"},\"returns\":{\"inCollateral_\":\"The value the liquidator will receive denoted in collateral tokens.\",\"inLending_\":\"The value the liquidator will receive denoted in lending tokens.\"}},\"liquidateLoan(uint256)\":{\"params\":{\"loanID\":\"The ID of the loan to be liquidated\"}},\"repayLoan(uint256,uint256)\":{\"params\":{\"amount\":\"The amount of tokens to pay back to the loan\",\"loanID\":\"The ID of the loan the payment is for\"}}},\"version\":1},\"userdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully liquidated\"},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully repaid\"}},\"kind\":\"user\",\"methods\":{\"escrowRepay(uint256,uint256)\":{\"notice\":\"Repay this Escrow's loan.\"},\"getLiquidationReward(uint256)\":{\"notice\":\"It gets the current liquidation reward for a given loan.\"},\"liquidateLoan(uint256)\":{\"notice\":\"Liquidate a loan if it is expired or under collateralized\"},\"repayLoan(uint256,uint256)\":{\"notice\":\"Make a payment to a loan\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/market/RepayFacet.sol\":\"RepayFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Trees proofs.\\n *\\n * The proofs can be generated using the JavaScript library\\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\\n *\\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n bytes32 computedHash = leaf;\\n\\n for (uint256 i = 0; i < proof.length; i++) {\\n bytes32 proofElement = proof[i];\\n\\n if (computedHash <= proofElement) {\\n // Hash(current computed hash + current element of the proof)\\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\\n } else {\\n // Hash(current element of the proof + current computed hash)\\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\\n }\\n }\\n\\n // Check if the computed hash (root) is equal to the provided root\\n return computedHash == root;\\n }\\n}\\n\",\"keccak256\":\"0xeee34bfb413657b6cd6c8e1e15c2080ba5ebaac479578515922804346fb63f7c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/reentry/ReentryMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nabstract contract ReentryMods {\\n modifier nonReentry(bytes32 id) {\\n AccessControlStorage storage s = AccessControlStorageLib.store();\\n require(!s.entered[id], \\\"AccessControl: reentered\\\");\\n s.entered[id] = true;\\n _;\\n s.entered[id] = false;\\n }\\n}\\n\",\"keccak256\":\"0x033c1164af25ef7d35a38a60973bf379b1cc603596914ffd85dcbcf0acdb6970\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../interfaces/IAToken.sol\\\";\\nimport { IAaveLendingPool } from \\\"../interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x8030b206c87d0073fb7dbebfa2ee8a3e93c479d976d6cdaa0c939f2fedaa1525\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n /**\\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\\n * @param dappAddress address of the target contract address\\n * @param dappData encoded abi of the function in our contract we want to call\\n * @return the called data in bytes\\n */\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n /**\\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\\n * @param token address of the respective ERC20 token to approve for the spender\\n * @param spender address of the respective spender who is approved by the token contract\\n */\\n function setTokenAllowance(address token, address spender) external;\\n\\n /**\\n * @notice it allows user to claim their escrow tokens\\n * @dev only the owner (TellerDiamond) can make this call on behalf of the users\\n * @param token address of the respective token contract to claim tokens from\\n * @param to address where the tokens should be transferred to\\n * @param amount uint256 amount of tokens to be claimed\\n */\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xaf67fc4454ffaa4d2f7e46fe7101876e8ebdb1a5426c30f87b8e18cc573ac019\",\"license\":\"MIT\"},\"contracts/escrow/libraries/LibEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibDapps } from \\\"../dapps/libraries/LibDapps.sol\\\";\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibEscrow {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\\n e_ = s().loanEscrows[loanID];\\n }\\n\\n /**\\n * @notice It returns a list of tokens owned by a loan escrow\\n * @param loanID uint256 index used to return our token list\\n * @return t_ which is a list of tokens \\n */\\n function getEscrowTokens(uint256 loanID)\\n internal\\n view\\n returns (EnumerableSet.AddressSet storage t_)\\n {\\n t_ = s().escrowTokens[loanID];\\n }\\n\\n /**\\n * @notice It returns the balance of a respective token in a loan escrow\\n * @param loanID uint256 index used to point to our loan escrow\\n * @param token address of respective token to give us the balance of in our loan escrow\\n * @return uint256 balance of respective token returned in an escrow loan\\n */\\n function balanceOf(uint256 loanID, address token)\\n internal\\n view\\n returns (uint256)\\n {\\n return IERC20(token).balanceOf(address(e(loanID)));\\n }\\n\\n /**\\n * @notice Adds or removes tokens held by the Escrow contract\\n * @param loanID The loan ID to update the token list for\\n * @param tokenAddress The token address to be added or removed\\n */\\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\\n // Skip if is lending token\\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\\n\\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\\n if (balanceOf(loanID, tokenAddress) > 0) {\\n if (!contains) {\\n EnumerableSet.add(tokens, tokenAddress);\\n }\\n } else if (contains) {\\n EnumerableSet.remove(tokens, tokenAddress);\\n }\\n }\\n\\n /**\\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\\n * @param loanID The loan ID to calculate value for\\n * @return value_ Escrow total value denoted in the lending token.\\n */\\n function calculateTotalValue(uint256 loanID)\\n internal\\n view\\n returns (uint256 value_)\\n {\\n address lendingToken = LibLoans.loan(loanID).lendingToken;\\n value_ += balanceOf(loanID, lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\\n if (EnumerableSet.length(tokens) > 0) {\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n uint256 tokenBal =\\n balanceOf(loanID, EnumerableSet.at(tokens, i));\\n value_ += PriceAggLib.valueFor(\\n EnumerableSet.at(tokens, i),\\n lendingToken,\\n tokenBal\\n );\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x17a7c6b11d6f280948e320525d1e131b89c23f80216918aa070df437a851d915\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when a user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when a user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n * @return ERC20 token\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n * @return balance_ the balance of the account\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice It calculates the total supply of the underlying asset.\\n * @return totalSupply_ the total supply denoted in the underlying asset.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given market.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n \\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfill the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n * @return mintAmount_ the amount minted of the specified token\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n * @return address of the strategy contract\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n * @param state boolean value that resembles the platform's state\\n */\\n function restrict(bool state) external virtual;\\n\\n /**\\n * @notice it initializes the Teller Token\\n * @param admin address of the admin to the respective Teller Token\\n * @param underlying address of the ERC20 token\\n */\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xf30ac4ef491851477ff9a3dd04974ebe74b529c37a3ef4e05798c3f734ceeb3d\",\"license\":\"MIT\"},\"contracts/market/LoanDataFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { Loan, LoanDebt, LoanTerms } from \\\"../storage/market.sol\\\";\\n\\ncontract LoanDataFacet {\\n /**\\n * @notice Returns the information about the given {loanID}.\\n * @param loanID The loan ID to get information for.\\n * @return loan_ The loan data.\\n */\\n function getLoan(uint256 loanID) external view returns (Loan memory loan_) {\\n loan_ = LibLoans.s().loans[loanID];\\n }\\n\\n /**\\n * @notice DEPRECATED\\n * @notice Returns the terms for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanTerms The terms that the loan weer created with.\\n */\\n function getLoanTerms(uint256 loanID)\\n external\\n view\\n returns (LoanTerms memory)\\n {\\n return LibLoans.terms(loanID);\\n }\\n\\n /**\\n * @notice Returns the loan IDs created by the {borrower} account.\\n * @param borrower The account to get loan IDs for.\\n * @return loanIDs The IDs for loans created by the {borrower}\\n */\\n function getBorrowerLoans(address borrower)\\n external\\n view\\n returns (uint128[] memory loanIDs)\\n {\\n return LibLoans.s().borrowerLoans[borrower];\\n }\\n\\n /**\\n * @notice Returns the debt owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanDebt The principal and interest owed amount.\\n */\\n function getDebtOwed(uint256 loanID)\\n external\\n view\\n returns (LoanDebt memory)\\n {\\n return LibLoans.debt(loanID);\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) external view returns (uint256) {\\n return LibLoans.getTotalOwed(loanID);\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n external\\n view\\n returns (uint256)\\n {\\n return LibLoans.getInterestOwedFor(loanID, amountBorrow);\\n }\\n\\n /**\\n * @notice it returns the collateral needed for a loan\\n * @param loanID the identifier of the loan ID to retrieve collateral from\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n external\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n return LibLoans.getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the typed address of a loan escrow\\n * @param loanID the identifier of the respective escrow's loan\\n * @return escrow_ the typed address of the returned ILoanEscrow\\n */\\n function getLoanEscrow(uint256 loanID)\\n external\\n view\\n returns (address escrow_)\\n {\\n escrow_ = address(LibLoans.s().loanEscrows[loanID]);\\n }\\n\\n /**\\n * @notice it returns the escrow's total value by calculating the value all the escrow tokens\\n * @param loanID the identifier of the respective escrow's loan\\n * @return the total value of the loan escrow\\n */\\n function getLoanEscrowValue(uint256 loanID)\\n external\\n view\\n returns (uint256)\\n {\\n return LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n /**\\n * @notice it returns the total escrow tokens held by an escrow\\n * @param loanID the identifier of the respective escrow's loan\\n * @return tokens_ the tokens held at the escrow loan \\n */\\n function getEscrowTokens(uint256 loanID)\\n external\\n view\\n returns (address[] memory tokens_)\\n {\\n EnumerableSet.AddressSet storage escrowTokens =\\n LibEscrow.getEscrowTokens(loanID);\\n tokens_ = new address[](EnumerableSet.length(escrowTokens));\\n for (uint256 i; i < tokens_.length; i++) {\\n tokens_[i] = EnumerableSet.at(escrowTokens, i);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x9a57f5de00ce073af4ffb2f74e7d8a15e56bc017826f2c5a393ef5b64554145f\",\"license\":\"MIT\"},\"contracts/market/RepayFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\nimport {\\n ReentryMods\\n} from \\\"../contexts2/access-control/reentry/ReentryMods.sol\\\";\\nimport { AUTHORIZED } from \\\"../shared/roles.sol\\\";\\nimport { LoanDataFacet } from \\\"./LoanDataFacet.sol\\\";\\n\\n// Libraries\\nimport {\\n IERC20,\\n SafeERC20\\n} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibCollateral } from \\\"./libraries/LibCollateral.sol\\\";\\nimport { LibDapps } from \\\"../escrow/dapps/libraries/LibDapps.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { NumbersLib } from \\\"../shared/libraries/NumbersLib.sol\\\";\\nimport { PriceAggLib } from \\\"../price-aggregator/PriceAggLib.sol\\\";\\nimport { NFTLib } from \\\"../nft/libraries/NFTLib.sol\\\";\\n\\n// Interfaces\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus\\n} from \\\"../storage/market.sol\\\";\\n\\ncontract RepayFacet is RolesMods, ReentryMods, PausableMods {\\n /**\\n @notice This event is emitted when a loan has been successfully repaid\\n @param loanID ID of loan from which collateral was withdrawn\\n @param borrower Account address of the borrower\\n @param amountPaid Amount of the loan paid back\\n @param payer Account address of the payer\\n @param totalOwed Total amount of the loan to be repaid\\n */\\n event LoanRepaid(\\n uint256 indexed loanID,\\n address indexed borrower,\\n uint256 amountPaid,\\n address payer,\\n uint256 totalOwed\\n );\\n\\n /**\\n * @notice This event is emitted when a loan has been successfully liquidated\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param borrower Account address of the borrower\\n * @param liquidator Account address of the liquidator\\n * @param reward Value in lending token paid out to liquidator\\n * @param tokensIn Percentage of the collateral price paid by the liquidator to the lending pool\\n */\\n event LoanLiquidated(\\n uint256 indexed loanID,\\n address indexed borrower,\\n address liquidator,\\n uint256 reward,\\n uint256 tokensIn\\n );\\n\\n /**\\n * @notice Repay this Escrow's loan.\\n * @dev If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.\\n * @dev Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\\n * @param loanID The id of the loan being used.\\n * @param amount The amount being repaid.\\n */\\n function escrowRepay(uint256 loanID, uint256 amount)\\n external\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n nonReentry(\\\"\\\")\\n {\\n uint256 balance =\\n LibEscrow.balanceOf(loanID, LibLoans.loan(loanID).lendingToken);\\n uint256 totalOwed = LibLoans.getTotalOwed(loanID);\\n // if there isn't enough balance in the escrow, then transfer amount needed to the escrow\\n if (balance < totalOwed && amount > balance) {\\n uint256 amountNeeded =\\n amount > totalOwed ? totalOwed - (balance) : amount - (balance);\\n\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n msg.sender,\\n address(LibEscrow.e(loanID)),\\n amountNeeded\\n );\\n }\\n\\n __repayLoan(loanID, amount, address(LibEscrow.e(loanID)), false);\\n }\\n\\n /**\\n * @notice Make a payment to a loan\\n * @param loanID The ID of the loan the payment is for\\n * @param amount The amount of tokens to pay back to the loan\\n */\\n function repayLoan(uint256 loanID, uint256 amount)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n __repayLoan(loanID, amount, msg.sender, false);\\n }\\n\\n /**\\n * @notice it repays the loan, either from an escrow or from a regular address\\n * @param loanID the identifier of the loan to repay\\n * @param amount the amount to repay the loan\\n * @param sender the address of the sender that wants to pay, can also be a loan escrow\\n * @param isLiquidation is this loan being liquidated?\\n * @return leftToPay_ the amount left to pay for the loan\\n */\\n function __repayLoan(\\n uint256 loanID,\\n uint256 amount,\\n address sender,\\n bool isLiquidation\\n ) private returns (uint256 leftToPay_) {\\n require(amount > 0, \\\"Teller: zero repay\\\");\\n\\n // calculate the actual amount to repay\\n leftToPay_ =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n if (leftToPay_ < amount) {\\n amount = leftToPay_;\\n leftToPay_ = 0;\\n } else {\\n leftToPay_ -= amount;\\n }\\n\\n // Get the Teller token for the loan\\n ITToken tToken =\\n MarketStorageLib.store().tTokens[\\n LibLoans.loan(loanID).lendingToken\\n ];\\n // Transfer funds from an escrow if an escrow is calling it\\n // Otherwise, transfer funds from an account\\n if (address(LibEscrow.e(loanID)) == sender) {\\n LibEscrow.e(loanID).claimToken(\\n LibLoans.loan(loanID).lendingToken,\\n address(tToken),\\n amount\\n );\\n } else {\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n sender,\\n address(tToken),\\n amount\\n );\\n }\\n\\n // Deduct the interest and principal owed\\n uint256 principalPaid;\\n uint256 interestPaid;\\n if (amount < LibLoans.debt(loanID).interestOwed) {\\n interestPaid = amount;\\n LibLoans.debt(loanID).interestOwed -= amount;\\n } else {\\n if (LibLoans.debt(loanID).interestOwed > 0) {\\n interestPaid = LibLoans.debt(loanID).interestOwed;\\n amount -= interestPaid;\\n LibLoans.debt(loanID).interestOwed = 0;\\n }\\n\\n if (amount > 0) {\\n principalPaid = amount;\\n LibLoans.debt(loanID).principalOwed -= amount;\\n }\\n }\\n\\n // Tell the Teller Token value has been deposited back into the pool.\\n tToken.repayLoan(principalPaid, interestPaid);\\n\\n if (isLiquidation) {\\n // Make sure there is nothing left to repay on the loan\\n require(leftToPay_ == 0, \\\"Teller: liquidate partial repay\\\");\\n\\n // Set loan status\\n LibLoans.loan(loanID).status = LoanStatus.Liquidated;\\n\\n // Transfer NFT if linked\\n NFTLib.liquidateNFT(loanID);\\n } else {\\n // if the loan is now fully paid, close it and withdraw borrower collateral\\n if (leftToPay_ == 0) {\\n LibLoans.loan(loanID).status = LoanStatus.Closed;\\n LibCollateral.withdrawAll(\\n loanID,\\n LibLoans.loan(loanID).borrower\\n );\\n // Restake any NFTs linked to loan for borrower\\n NFTLib.restakeLinked(loanID, LibLoans.loan(loanID).borrower);\\n }\\n\\n emit LoanRepaid(\\n loanID,\\n LibLoans.loan(loanID).borrower,\\n amount,\\n msg.sender,\\n leftToPay_\\n );\\n }\\n }\\n\\n /**\\n * @notice Liquidate a loan if it is expired or under collateralized\\n * @param loanID The ID of the loan to be liquidated\\n */\\n function liquidateLoan(uint256 loanID)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n uint256 collateralAmount = LibCollateral.e(loanID).loanSupply(loanID);\\n require(\\n RepayLib.isLiquidable(loanID, collateralAmount),\\n \\\"Teller: does not need liquidation\\\"\\n );\\n\\n // Calculate the reward before repaying the loan\\n (uint256 rewardInLending, uint256 collateralInLending) =\\n RepayLib.getLiquidationReward(loanID, collateralAmount);\\n\\n // The liquidator pays the amount still owed on the loan\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n __repayLoan(loanID, amountToLiquidate, msg.sender, true);\\n\\n // Payout the liquidator reward owed\\n if (rewardInLending > 0) {\\n RepayLib.payOutLiquidator(\\n loanID,\\n rewardInLending,\\n collateralInLending,\\n collateralAmount,\\n payable(msg.sender)\\n );\\n }\\n\\n emit LoanLiquidated(\\n loanID,\\n loan.borrower,\\n msg.sender,\\n rewardInLending,\\n amountToLiquidate\\n );\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @return inLending_ The value the liquidator will receive denoted in lending tokens.\\n * @return inCollateral_ The value the liquidator will receive denoted in collateral tokens.\\n */\\n function getLiquidationReward(uint256 loanID)\\n external\\n view\\n returns (uint256 inLending_, uint256 inCollateral_)\\n {\\n (inLending_, ) = RepayLib.getLiquidationReward(\\n loanID,\\n LibCollateral.e(loanID).loanSupply(loanID)\\n );\\n inCollateral_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n inLending_\\n );\\n }\\n}\\n\\nlibrary RepayLib {\\n /**\\n * @notice It checks if a loan can be liquidated.\\n * @param loanID The loan ID to check.\\n * @return true if the loan is liquidable.\\n */\\n function isLiquidable(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (bool)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n // Check if loan can be liquidated\\n if (loan.status != LoanStatus.Active) {\\n return false;\\n }\\n\\n if (loan.collateralRatio > 0) {\\n // If loan has a collateral ratio, check how much is needed\\n (, uint256 neededInCollateral, ) =\\n LoanDataFacet(address(this)).getCollateralNeededInfo(loanID);\\n if (neededInCollateral > collateralAmount) {\\n return true;\\n }\\n }\\n\\n // Otherwise, check if the loan has expired\\n return block.timestamp >= loan.loanStartTime + loan.duration;\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @param collateralAmount The amount of collateral for the {loanID}. Passed in to save gas calling the collateral escrow multiple times.\\n * @return reward_ The value the liquidator will receive denoted in lending tokens.\\n */\\n function getLiquidationReward(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (uint256 reward_, uint256 collateralValue_)\\n {\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n // Max reward is amount repaid on loan plus extra percentage\\n uint256 maxReward =\\n amountToLiquidate +\\n NumbersLib.percent(\\n amountToLiquidate,\\n uint16(PlatformSettingsLib.getLiquidateRewardPercent())\\n );\\n\\n // Calculate available collateral for reward\\n if (collateralAmount > 0) {\\n collateralValue_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).collateralToken,\\n LibLoans.loan(loanID).lendingToken,\\n collateralAmount\\n );\\n reward_ += collateralValue_;\\n }\\n\\n // Calculate loan escrow value if collateral not enough to cover reward\\n if (reward_ < maxReward) {\\n reward_ += LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n // Cap the reward to max\\n if (reward_ > maxReward) {\\n reward_ = maxReward;\\n }\\n }\\n\\n /**\\n * @notice Checks if the loan has an Escrow and claims any tokens then pays out the loan collateral.\\n * @dev See Escrow.claimTokens for more info.\\n * @param loanID The loan ID which is being liquidated\\n * @param rewardInLending The total amount of reward based in the lending token to pay the liquidator\\n * @param collateralInLending The amount of collateral that is available for the loan denoted in lending tokens\\n * @param collateralAmount The amount of collateral that is available for the loan\\n * @param liquidator The address of the liquidator where the liquidation reward will be sent to\\n */\\n function payOutLiquidator(\\n uint256 loanID,\\n uint256 rewardInLending,\\n uint256 collateralInLending,\\n uint256 collateralAmount,\\n address payable liquidator\\n ) internal {\\n // check if loan is liquidated\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Liquidated,\\n \\\"Teller: loan not liquidated\\\"\\n );\\n\\n // if the lending reward is less than the collateral lending tokens, then aggregate\\n // the value for the lending token with the collateral token and send it to the liquidator\\n if (rewardInLending <= collateralInLending) {\\n uint256 rewardInCollateral =\\n PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n rewardInLending\\n );\\n\\n LibCollateral.withdraw(loanID, rewardInCollateral, liquidator);\\n } else {\\n // Payout whats available in the collateral token\\n LibCollateral.withdraw(loanID, collateralAmount, liquidator);\\n\\n // Claim remaining reward value from the loan escrow\\n claimEscrowTokensByValue(\\n loanID,\\n liquidator,\\n rewardInLending - collateralInLending\\n );\\n }\\n }\\n\\n /**\\n * @dev Send the equivalent of tokens owned by the loan escrow (in lending value) to the recipient,\\n * @param loanID The loan ID to clam tokens from\\n * @param recipient address to send the tokens to\\n * @param value The value of escrow held tokens to be claimed based in lending value\\n */\\n function claimEscrowTokensByValue(\\n uint256 loanID,\\n address recipient,\\n uint256 value\\n ) private {\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n uint256 valueLeftToTransfer = value;\\n\\n // Start with the lending token\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n LibLoans.loan(loanID).lendingToken,\\n recipient,\\n valueLeftToTransfer\\n );\\n\\n // Cycle through remaining tokens\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n if (valueLeftToTransfer == 0) {\\n return;\\n }\\n\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n EnumerableSet.at(tokens, i),\\n recipient,\\n valueLeftToTransfer\\n );\\n }\\n }\\n\\n /**\\n * @notice it claims the escrow tokens for the liquidator\\n * @notice it keeps claiming escrow tokens until there aren't anymore tokens or the valueLeftToTransfer is zero\\n * @param loanID the identifier of the escrow loan to claim tokens from\\n * @param token the address of the token asset to claim\\n * @param recipient the address of the recipient to transfer the tokens to\\n * @param valueLeftToTransfer the value left to transfer to the liquidator that is returned back\\n * @return the value left to transfer\\n */\\n function claimEscrowToken(\\n uint256 loanID,\\n address token,\\n address recipient,\\n uint256 valueLeftToTransfer\\n ) private returns (uint256) {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n // get value of token balance in lending value\\n if (balance > 0) {\\n // If token not the lending token, get value of token\\n uint256 balanceInLending;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n balanceInLending = balance;\\n } else {\\n balanceInLending = PriceAggLib.valueFor(\\n token,\\n LibLoans.loan(loanID).lendingToken,\\n balance\\n );\\n }\\n\\n if (balanceInLending <= valueLeftToTransfer) {\\n LibEscrow.e(loanID).claimToken(token, recipient, balance);\\n valueLeftToTransfer -= balanceInLending;\\n } else {\\n // Token balance is more than enough so calculate ratio of balance to transfer\\n uint256 valueToTransfer;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n valueToTransfer = valueLeftToTransfer;\\n } else {\\n valueToTransfer = NumbersLib.percent(\\n balance,\\n NumbersLib.ratioOf(\\n valueLeftToTransfer,\\n balanceInLending\\n )\\n );\\n }\\n\\n LibEscrow.e(loanID).claimToken(\\n token,\\n recipient,\\n valueToTransfer\\n );\\n valueLeftToTransfer = 0;\\n }\\n }\\n return valueLeftToTransfer;\\n }\\n}\\n\",\"keccak256\":\"0x4cc90a273ddbcfc983b98bd42c18990526a79488c972926952d38f26ff69cabb\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n /**\\n * @notice it initializes an escrow\\n * @param tokenAddress the address of the collateral token to be stored\\n * @param isWETH check if it's wrapped Ethereum\\n */\\n function init(address tokenAddress, bool isWETH) external;\\n\\n /**\\n * @notice it deposits an amount of the respective collateral token into the escrow\\n * @param loanID the ID of the loan\\n * @param amount the amount of collateral tokens to be deposited\\n */\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n /**\\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\\n * @dev only the TellerDiamond can make this call on behalf of the borrower\\n * @param loanID identifier of the loan\\n * @param amount number of collateral tokens to send\\n * @param receiver payable address to transfer money to\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n /**\\n * @notice it returns the supply of the respective loan\\n * @param loanID the respective loan ID\\n * @return supply_ the amount in collateral of the respective loan\\n */\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n /**\\n * @notice it returns the total supply of the collateral token held by the contract\\n * @return supply_ the total amount of collateral\\n */\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x900fed2311f919ba1451a6583ddbf9f3bc8afa8f5189500fff51f0c049258ed3\",\"license\":\"MIT\"},\"contracts/market/libraries/LibCollateral.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport { ICollateralEscrow } from \\\"../collateral/ICollateralEscrow.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\nimport { MarketStorageLib } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibCollateral {\\n /**\\n * @notice This event is emitted when collateral has been deposited for the loan\\n * @param loanID ID of the loan for which collateral was deposited\\n * @param depositor Account that deposited funds\\n * @param amount Amount of collateral deposited\\n */\\n event CollateralDeposited(\\n uint256 indexed loanID,\\n address indexed depositor,\\n uint256 amount\\n );\\n\\n /**\\n * @notice This event is emitted when collateral has been withdrawn\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param receiver Account that received funds\\n * @param amount Value of collateral withdrawn\\n */\\n event CollateralWithdrawn(\\n uint256 indexed loanID,\\n address indexed receiver,\\n uint256 amount\\n );\\n\\n /**\\n * @notice it gets MarketStorage's collateral escrow using the loanID\\n * @param loanID the loanID to be used\\n * @return c_ which is the collateral escrow\\n */\\n function e(uint256 loanID) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[\\n MarketStorageLib.store().loans[loanID].collateralToken\\n ];\\n }\\n\\n function e(address token) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[token];\\n }\\n\\n /**\\n * @notice it deposits an amount of collateral into a collateral escrow's address of a respective loan\\n * @param loanID the respective loan ID\\n * @param amount the amount of collateral to deposit\\n */\\n function deposit(uint256 loanID, uint256 amount) internal {\\n e(loanID).deposit{ value: amount }(loanID, amount);\\n\\n emit CollateralDeposited(loanID, msg.sender, amount);\\n }\\n\\n /**\\n * @notice it withdraws an amount from the collateral escrow\\n * @param loanID the respective loanID to withdraw from\\n * @param amount the number of collateral tokens to withdraw\\n * @param receiver the address who receives the withdrawal\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) internal {\\n e(loanID).withdraw(loanID, amount, receiver);\\n\\n emit CollateralWithdrawn(loanID, receiver, amount);\\n }\\n\\n /**\\n * @notice it withdraws the entire supply in collateral of a respective loan to an address\\n * @param loanID the respective loan's ID\\n * @param receiver the address of the receiver to withdraw tokens from\\n */\\n function withdrawAll(uint256 loanID, address payable receiver) internal {\\n withdraw(loanID, e(loanID).loanSupply(loanID), receiver);\\n }\\n\\n /**\\n * @notice it initializes a new escrow collateral to hold collateral tokens\\n * @param token address of the collateral token it holds\\n */\\n function createEscrow(address token) internal {\\n // Check if collateral escrow exists\\n if (address(e(token)) == address(0)) {\\n // Create escrow\\n address escrow =\\n AppStorageLib.store().collateralEscrowBeacon.cloneProxy(\\\"\\\");\\n ICollateralEscrow(escrow).init(\\n token,\\n // Check if collateral token is WETH\\n token == AppStorageLib.store().assetAddresses[\\\"WETH\\\"]\\n );\\n\\n // Set max allowance\\n IERC20(token).approve(escrow, type(uint256).max);\\n // Save escrow address for loan\\n MarketStorageLib.store().collateralEscrows[\\n token\\n ] = ICollateralEscrow(escrow);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x84dbab8283357a1cc4210e34642fc8247841a58973778f4f6570398cc3046947\",\"license\":\"MIT\"},\"contracts/market/libraries/LibLoans.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibEscrow } from \\\"../../escrow/libraries/LibEscrow.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus,\\n LoanDebt,\\n LoanTerms\\n} from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibLoans {\\n using NumbersLib for int256;\\n using NumbersLib for uint256;\\n\\n bytes32 internal constant ID = keccak256(\\\"LOANS\\\");\\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n * @notice it returns the loan\\n * @param loanID the ID of the respective loan\\n * @return l_ the loan \\n */\\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\\n l_ = s().loans[loanID];\\n }\\n\\n /**\\n * @notice it returns the loan debt from a respective loan\\n * @param loanID the ID of the respective loan\\n * @return d_ the loan debt from a respective loan\\n */\\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\\n d_ = s().loanDebt[loanID];\\n }\\n\\n // DEPRECATED\\n function terms(uint256 loanID)\\n internal\\n view\\n returns (LoanTerms storage t_)\\n {\\n t_ = s()._loanTerms[loanID];\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return owed_ uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID)\\n internal\\n view\\n returns (uint256 owed_)\\n {\\n if (loan(loanID).status == LoanStatus.Active) {\\n owed_ = debt(loanID).principalOwed + (debt(loanID).interestOwed);\\n }\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n internal\\n view\\n returns (uint256)\\n {\\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\\n }\\n \\n function getCollateralNeeded(uint256 loanID)\\n internal\\n view\\n returns (uint256 _needed)\\n {\\n (, _needed, ) = getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the total collateral needed in lending tokens, in collateral tokens and in escrowed loan values\\n * @param loanID the loanID to get the total collateral needed\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n internal\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\\n loanID\\n );\\n\\n // check if needed lending tokens is zero. if true, then needed collateral tokens is zero. else,\\n if (neededInLendingTokens == 0) {\\n neededInCollateralTokens = 0;\\n } else {\\n neededInCollateralTokens = PriceAggLib.valueFor(\\n loan(loanID).lendingToken,\\n loan(loanID).collateralToken,\\n neededInLendingTokens\\n );\\n }\\n }\\n\\n /**\\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\\n * @param loanID The loan ID to get needed collateral info for.\\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\\n */\\n function getCollateralNeededInTokens(uint256 loanID)\\n internal\\n view\\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\\n {\\n if (loan(loanID).collateralRatio == 0) {\\n return (0, 0);\\n }\\n\\n /*\\n The collateral to principal owed ratio is the sum of:\\n * collateral buffer percent\\n * loan interest rate\\n * liquidation reward percent\\n * X factor of additional collateral\\n */\\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n neededInLendingTokens = loan(loanID).borrowedAmount.percent(\\n loan(loanID).collateralRatio\\n );\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n uint16 requiredRatio =\\n loan(loanID).collateralRatio -\\n getInterestRatio(loanID) -\\n uint16(PlatformSettingsLib.getCollateralBufferValue());\\n\\n neededInLendingTokens =\\n debt(loanID).principalOwed +\\n debt(loanID).interestOwed;\\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\\n if (\\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\\n ) {\\n neededInLendingTokens -= escrowLoanValue;\\n }\\n neededInLendingTokens = neededInLendingTokens.percent(\\n requiredRatio\\n );\\n }\\n }\\n\\n /**\\n * @notice check if a loan can go to end of auction with a collateral ratio\\n * @return bool checking if collateralRatio is >= the over collateralized buffer value\\n */\\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\\n internal\\n view\\n returns (bool)\\n {\\n return\\n collateralRatio >=\\n PlatformSettingsLib.getOverCollateralizedBufferValue();\\n }\\n\\n /**\\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\\n * @notice There is a minimum threshold of 1%.\\n * @dev The interest rate is APY (annual percentage yield).\\n * @param loanID The loan ID to get the interest rate for.\\n */\\n function getInterestRatio(uint256 loanID)\\n internal\\n view\\n returns (uint16 ratio_)\\n {\\n ratio_ = uint16(\\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\\n SECONDS_PER_YEAR\\n );\\n\\n if (ratio_ == 0) {\\n ratio_ = 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0xe48b287a583b40e534654e4023422f59a9e6d7dd265d68ae4af43f8da58c09d9\",\"license\":\"MIT\"},\"contracts/nft/IStakeableNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IStakeableNFT {\\n function tokenBaseLoanSize(uint256 tokenId) external view returns (uint256);\\n\\n function tokenURIHash(uint256 tokenId)\\n external\\n view\\n returns (string memory);\\n\\n function tokenContributionAsset(uint256 tokenId)\\n external\\n view\\n returns (address);\\n\\n function tokenContributionSize(uint256 tokenId)\\n external\\n view\\n returns (uint256);\\n\\n function tokenContributionMultiplier(uint256 tokenId)\\n external\\n view\\n returns (uint8);\\n}\\n\",\"keccak256\":\"0xfbf44350ad91a54de26f39195d714580d7dade556ea4c7991a51eef5aa839105\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice it returns the current token index to use as a counter\\n * @return counter_ the current token index\\n */\\n function getCurrentTokenIndex() external view returns (uint256 counter_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x8a6979965f9d275eff9e034f207d605d7eb3506245de3604d2e02acc8196c2a6\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice it returns the current token index to use as a counter\\n * @return counter_ the current token index\\n */\\n function getCurrentTokenIndex()\\n external\\n view\\n override\\n returns (uint256 counter_)\\n {\\n counter_ = _tokenCounter.current();\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf42808068c07aa015fcf4a2922fb91cfb456a2f6c8fcfa6daa08b2dfbedf8817\",\"license\":\"MIT\"},\"contracts/nft/TellerNFTDictionary.sol\":{\"content\":\"/**\\n * @notice TellerNFTDictionary Version 1.02\\n *\\n * @notice This contract is used to gather data for TellerV1 NFTs more efficiently.\\n * @notice This contract has data which must be continuously synchronized with the TellerV1 NFT data\\n *\\n * @author develop@teller.finance\\n */\\n\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Interfaces\\nimport \\\"./IStakeableNFT.sol\\\";\\n\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFTDictionary is IStakeableNFT, AccessControlUpgradeable {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n mapping(uint256 => uint256) public baseLoanSizes;\\n mapping(uint256 => string[]) public hashes;\\n mapping(uint256 => address) public contributionAssets;\\n mapping(uint256 => uint256) public contributionSizes;\\n mapping(uint256 => uint8) public contributionMultipliers;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n\\n /* State Variables */\\n\\n mapping(uint256 => uint256) public _tokenTierMappingCompressed;\\n bool public _tokenTierMappingCompressedSet;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFTDictionary: not admin\\\");\\n _;\\n }\\n\\n function initialize(address initialAdmin) public {\\n _setupRole(ADMIN, initialAdmin);\\n _setRoleAdmin(ADMIN, ADMIN);\\n\\n __AccessControl_init();\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTierIndex(uint256 tokenId)\\n public\\n view\\n returns (uint8 index_)\\n {\\n //32 * 8 = 256 - each uint256 holds the data of 32 tokens . 8 bits each.\\n\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 compressedRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n //use 31 instead of 32 to account for the '0x' in the start.\\n //the '31 -' reverses our bytes order which is necessary\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint8 tierIndex = uint8((compressedRegister >> offset));\\n\\n return tierIndex;\\n }\\n\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory)\\n {\\n return hashes[tierIndex];\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTier(uint256 index, Tier memory newTier)\\n external\\n onlyAdmin\\n returns (bool)\\n {\\n baseLoanSizes[index] = newTier.baseLoanSize;\\n hashes[index] = newTier.hashes;\\n contributionAssets[index] = newTier.contributionAsset;\\n contributionSizes[index] = newTier.contributionSize;\\n contributionMultipliers[index] = newTier.contributionMultiplier;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param tiersMapping Information about the new tiers to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setAllTokenTierMappings(uint256[] memory tiersMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n require(\\n !_tokenTierMappingCompressedSet,\\n \\\"TellerNFTDictionary: token tier mapping already set\\\"\\n );\\n for (uint256 i = 0; i < tiersMapping.length; i++) {\\n _tokenTierMappingCompressed[i] = tiersMapping[i];\\n }\\n\\n _tokenTierMappingCompressedSet = true;\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param index the mapping row, each holds data for 32 tokens\\n * @param tierMapping Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierMapping(uint256 index, uint256 tierMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n _tokenTierMappingCompressed[index] = tierMapping;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenIds the NFT token Ids for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenIds(\\n uint256[] calldata tokenIds,\\n uint256 tokenTier\\n ) public onlyAdmin returns (bool) {\\n for (uint256 i; i < tokenIds.length; i++) {\\n setTokenTierForTokenId(tokenIds[i], tokenTier);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenId the NFT token Id for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenId(uint256 tokenId, uint256 tokenTier)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 existingRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint256 updateMaskShifted =\\n 0x00000000000000000000000000000000000000000000000000000000000000FF <<\\n offset;\\n\\n uint256 updateMaskShiftedNegated = ~updateMaskShifted;\\n\\n uint256 tokenTierShifted =\\n ((0x0000000000000000000000000000000000000000000000000000000000000000 |\\n tokenTier) << offset);\\n\\n uint256 existingRegisterClearedWithMask =\\n existingRegister & updateMaskShiftedNegated;\\n\\n uint256 updatedRegister =\\n existingRegisterClearedWithMask | tokenTierShifted;\\n\\n _tokenTierMappingCompressed[mappingIndex] = updatedRegister;\\n\\n return true;\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(IStakeableNFT).interfaceId ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n New methods for the dictionary\\n */\\n\\n /**\\n * @notice It returns Base Loan Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenBaseLoanSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return baseLoanSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Token URI Hash for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenURIHash(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n string[] memory tierImageHashes = hashes[tokenTier];\\n return tierImageHashes[tokenId % (tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice It returns Contribution Asset for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionAsset(uint256 tokenId)\\n public\\n view\\n override\\n returns (address)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionAssets[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Multiplier for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionMultiplier(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint8)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionMultipliers[tokenTier];\\n }\\n}\\n\",\"keccak256\":\"0xf33e3fa1f609fdd2abb3b5fb9c232269d13363a3e4fa5697ea96269e361e74fa\"},\"contracts/nft/libraries/NFTLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../TellerNFT.sol\\\";\\n\\n// Libraries\\nimport {\\n MerkleProof\\n} from \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\nimport { NFTStorageLib, NFTStorage } from \\\"../../storage/nft.sol\\\";\\n\\nlibrary NFTLib {\\n function s() internal pure returns (NFTStorage storage s_) {\\n s_ = NFTStorageLib.store();\\n }\\n\\n function nft() internal view returns (TellerNFT nft_) {\\n nft_ = AppStorageLib.store().nft;\\n }\\n\\n /**s\\n * @notice it transfers the NFT from the sender to the diamond to stake then adds the NFTID to the list of the owner's stakedNFTs\\n * @param nftID the ID of the NFT to stake\\n * @param owner the owner of the NFT who will stake the NFT\\n */\\n function stake(uint256 nftID, address owner) internal {\\n // Transfer to diamond\\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\\n // Add NFT ID to user set\\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\\n }\\n\\n /**\\n * @notice it unstakes the NFT by removing the NFT ID from the list of the user's staked NFTs\\n * @param nftID the ID of the NFT to remove from the list of the user's staked NFTs\\n * @return success_ the boolean value telling us if the user has unsuccessfully unstaked the NFT\\n */\\n function unstake(uint256 nftID) internal returns (bool success_) {\\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\\n }\\n\\n /**\\n * @notice it gets the list of staked NFTs from the owner\\n * @param nftOwner the owner of the staked NFTs to pull from\\n * @return staked_ the array of the staked NFTs owned by the user\\n */\\n function stakedNFTs(address nftOwner)\\n internal\\n view\\n returns (uint256[] memory staked_)\\n {\\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\\n staked_ = new uint256[](EnumerableSet.length(nfts));\\n for (uint256 i; i < staked_.length; i++) {\\n staked_[i] = EnumerableSet.at(nfts, i);\\n }\\n }\\n\\n /**\\n * @notice if the user fails to pay his loan, then we liquidate the all the NFTs associated with the loan\\n * @param loanID the identifier of the loan to liquidate the NFTs from\\n */\\n function liquidateNFT(uint256 loanID) internal {\\n // Check if NFTs are linked\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n NFTLib.nft().transferFrom(\\n address(this),\\n AppStorageLib.store().nftLiquidationController,\\n EnumerableSet.at(nfts, i)\\n );\\n }\\n }\\n\\n /**\\n * @notice it unstakes an NFT and verifies the proof in order to apply the proof to a loan\\n * @param loanID the identifier of the loan\\n * @param nftID the NFT ID to apply to the loan\\n */\\n function applyToLoan(uint256 loanID, uint256 nftID) internal {\\n // NFT must be currently staked\\n // Remove NFT from being staked - returns bool\\n require(unstake(nftID), \\\"Teller: borrower nft not staked\\\");\\n\\n // Apply NFT to loan\\n EnumerableSet.add(s().loanNFTs[loanID], nftID);\\n }\\n\\n /**\\n * @notice it finds the loan's NFTs and adds them back to the owner's list of staked NFTs\\n * @param loanID the identifier of the respective loan to add the NFTs back to the user's staked NFTs\\n * @param owner the owner to add the unstaked NFTs back to the staked pile\\n */\\n function restakeLinked(uint256 loanID, address owner) internal {\\n // Get linked NFT\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n // Restake the NFT\\n EnumerableSet.add(s().stakedNFTs[owner], EnumerableSet.at(nfts, i));\\n }\\n }\\n}\\n\",\"keccak256\":\"0xccbd35c6e8d0130b38f5025ee81c47d55e4fa48c8fcb8bec6f70c21061e0ce61\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n /**\\n * @notice it returns 10^{numberOfDecimals} for a token\\n * @param token the address to calculate the decimals for\\n * @return 10^number of decimals used to calculate the price and value of different token pairs\\n */\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @notice It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @notice it tries to calculate a price from Compound and Chainlink.\\n * @dev if no price is found on compound, then calculate it on chainlink\\n * @param src the token address to calculate the price for in dst\\n * @param dst the token address to retrieve the price of src\\n * @return price_ the price of src in dst\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n * @param src the address of the src token\\n * @param dst the address of the dst token\\n * @return the price of the src token in dst token\\n\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n * @param src the source token to calculate price for with chainlink\\n * @param dst the destination token to calculate price for with chainlink\\n * @param cRate the compound rate to multiply with the price of the dst token\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @notice Scales the {value} by the difference in decimal values.\\n * @param value the the value of the src in dst\\n * @param srcDecimals src token decimals\\n * @param dstDecimals dst token decimals\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @notice it tries to calculate the price of {src} in {dst}\\n * @param src address of source token\\n * @param dst address of destination token\\n * @return the price of src token in dst\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address WETH = AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n if (dst != WETH) {\\n int256 price1 = _priceFor(src, WETH);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, WETH);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice it checks if a token is a cToken. If it is, then get the underlying address\\n * @param token address of the token\\n * @return isCToken boolean whether it's a cToken\\n * @return underlying the address of the cToken\\n */\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2efb3d71a1c0fb49f8c455c4fa30d04c69a1617d619035fc400dabdeb2ab0c9e\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { PriceAggFacet } from \\\"./PriceAggFacet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\n/**\\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\\n */\\nlibrary PriceAggLib {\\n /**\\n * @notice It calculates the value of one token amount into another\\n * @param src the source token\\n * @param dst the destination token\\n * @param srcAmount the amount of source token\\n * @return value_ the returned value of src in dst\\n */\\n function valueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) internal view returns (uint256 value_) {\\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\\n }\\n\\n /**\\n * @notice It returns the price of the token pair as given from Compound.\\n * @dev if no compound price is calculated, then it checks Chainlink price Aggregator\\n * @param src the address of the source token\\n * @param dst the address of the desitnation token\\n * @return price_ gets the price of src in dst\\n */\\n function priceFor(address src, address dst)\\n internal\\n view\\n returns (int256 price_)\\n {\\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\\n }\\n}\\n\",\"keccak256\":\"0xff59eee567fa4a7f5cac432e31d918be92834f04614f49572d3984a5b030ac79\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\nabstract contract PausableMods {\\n /**\\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\\n * @param id id of the facet to check if is paused.\\n * @param state Boolean that the protocol AND facet should be in.\\n */\\n modifier paused(bytes32 id, bool state) {\\n require(\\n __isPaused(\\\"\\\") == state && __isPaused(id) == state,\\n __pausedMessage(state)\\n );\\n _;\\n }\\n\\n /**\\n * @dev Checks if the given id is paused.\\n * @param id Encoded id of the facet to check if is paused.\\n * @return the bool to tell us if the facet is paused (true) or not (false)\\n */\\n function __isPaused(bytes32 id) private view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n\\n /**\\n * @dev Gets the message that should be reverted with given a state it should be in.\\n * @param state Boolean that an id should be in.\\n * @return a message stating whether the facet is paused or not\\n */\\n function __pausedMessage(bool state) private pure returns (string memory) {\\n return state ? \\\"Pausable: not paused\\\" : \\\"Pausable: paused\\\";\\n }\\n}\\n\",\"keccak256\":\"0x2d3f848ee56ae5fa365539c2509c03c167affc89c89f98bb98cb9b83fbe8ae4c\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0xbeef1937dc1ed1f6f78b80f0737f018565ab264184cf05ef54c3c28ecd55a09b\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xacf6bcb8c4afd2f337a0161e8be64b016c1b350d336cd862245dd922fcd10f33\",\"license\":\"MIT\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n /**\\n * @notice Checks if the account should be allowed to mint tokens in the given market\\n * @param cToken The market to verify the mint against\\n * @param minter The account which would get the minted tokens\\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates mint and reverts on rejection. May emit logs.\\n * @param cToken Asset being minted\\n * @param minter The address minting the tokens\\n * @param mintAmount The amount of the underlying asset being minted\\n * @param mintTokens The number of tokens being minted\\n */\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to redeem tokens in the given market\\n * @param cToken The market to verify the redeem against\\n * @param redeemer The account which would redeem the tokens\\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates redeem and reverts on rejection. May emit logs.\\n * @param cToken Asset being redeemed\\n * @param redeemer The address redeeming the tokens\\n * @param redeemAmount The amount of the underlying asset being redeemed\\n * @param redeemTokens The number of tokens being redeemed\\n */\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\\n * @param cToken The market to verify the borrow against\\n * @param borrower The account which would borrow the asset\\n * @param borrowAmount The amount of underlying the account would borrow\\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates borrow and reverts on rejection. May emit logs.\\n * @param cToken Asset whose underlying is being borrowed\\n * @param borrower The address borrowing the underlying\\n * @param borrowAmount The amount of the underlying asset requested to borrow\\n */\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to repay a borrow in the given market\\n * @param cToken The market to verify the repay against\\n * @param payer The account which would repay the asset\\n * @param borrower The account which would borrowed the asset\\n * @param repayAmount The amount of the underlying asset the account would repay\\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\\n * @param cToken Asset being repaid\\n * @param payer The address repaying the borrow\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param borrowerIndex the index of the borrower\\n */\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n /**\\n * @notice Checks if the liquidation should be allowed to occur\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n */\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the seizing of assets should be allowed to occur\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates seize and reverts on rejection. May emit logs.\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to transfer tokens in the given market\\n * @param cToken The market to verify the transfer against\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates transfer and reverts on rejection. May emit logs.\\n * @param cToken Asset being transferred\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n */\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in all markets\\n * @param holder The address to claim COMP for\\n */\\n function claimComp(address holder) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in the specified markets\\n * @param holder The address to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n */\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n /**\\n * @notice Claim all comp accrued by the holders\\n * @param holders The addresses to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n * @param borrowers Whether or not to claim COMP earned by borrowing\\n * @param suppliers Whether or not to claim COMP earned by supplying\\n */\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n /**\\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\\n * @param cTokenBorrowed The address of the borrowed cToken\\n * @param cTokenCollateral The address of the collateral cToken\\n * @param repayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\\n */\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n /**\\n * @notice Return the address of the COMP token\\n * @return The address of COMP\\n */\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x38a824a4a21ce9370fa581a616d1bb9d311f27d8982a6b96ebeba90bd5fd0adb\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n \\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x37849041e4bee2dfa825677f69078521fcc94804aa5120f67dd12cc4133efcec\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @dev CETH is the only Compound token that does not support the {underlying} function.\\n * @param cToken address of the compound token\\n * @return address of the underlying cToken\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x99206384c27b0e68b1ec7b82260f6a47965f611875c018bc076ff8a688a6c6d7\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n /**\\n * @notice it returns the absolute number of a specified parameter\\n * @param self the number to be returned in it's absolute \\n * @return the absolute number\\n */\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0xa852b8866a3d6d928c6575bf2bcf2ae784eed73717c78c0cadbdedf8b0ba3274\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0c52fdd76b33f74e233c3a27dd3b73b134e9643aab347b3aa649c504809c6559\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\n// DEPRECATED\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\nstruct LoanRequest {\\n LoanUserRequest request;\\n LoanConsensusResponse[] responses;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanUserRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanConsensusResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) _loanTerms; // DEPRECATED: DO NOT REMOVE\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb7e05aeec806b5621512def93f4a389b4ef88c50ef9fe7115a33f57db2f2304b\",\"license\":\"MIT\"},\"contracts/storage/nft.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"../nft/TellerNFTDictionary.sol\\\";\\n\\n// Utils\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct NFTStorage {\\n // Maps NFT owner to set of token IDs owned\\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\\n // Maps loanID to NFT IDs indicating NFT being used for the loan\\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\\n // Merkle root used for verifying nft IDs to base loan size\\n TellerNFTDictionary nftDictionary;\\n}\\n\\nbytes32 constant NFT_STORAGE_POS = keccak256(\\\"teller.staking.storage\\\");\\n\\nlibrary NFTStorageLib {\\n function store() internal pure returns (NFTStorage storage s) {\\n bytes32 pos = NFT_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd44f213be3125ea2e2de120c241832f1861be18b3ff2fd4c3baa52ea20b94812\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "history": [ + { + "address": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "RepayFacet", + "transactionHash": "0x44d6b974ec21f1c4420ecb2be53506c60d1abe4b5fac2a2b5352ae4a3fb3bb5d", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "transactionIndex": 0, + "gasUsed": "1838004", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xecd0c4fcd32a0e212c29bf1a50f9095c4551299b06f40b8cb32c08eeeb3ab526", + "transactionHash": "0x44d6b974ec21f1c4420ecb2be53506c60d1abe4b5fac2a2b5352ae4a3fb3bb5d", + "logs": [], + "blockNumber": 25103793, + "cumulativeGasUsed": "1838004", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "dc3b3c0336b59a4fae33a8cd036a81b5", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"liquidator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"reward\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokensIn\",\"type\":\"uint256\"}],\"name\":\"LoanLiquidated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountPaid\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"totalOwed\",\"type\":\"uint256\"}],\"name\":\"LoanRepaid\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"escrowRepay\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLiquidationReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"inLending_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"inCollateral_\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"liquidateLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"repayLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"params\":{\"borrower\":\"Account address of the borrower\",\"liquidator\":\"Account address of the liquidator\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"reward\":\"Value in lending token paid out to liquidator\",\"tokensIn\":\"Percentage of the collateral price paid by the liquidator to the lending pool\"}},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"params\":{\"amountPaid\":\"Amount of the loan paid back\",\"borrower\":\"Account address of the borrower\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"payer\":\"Account address of the payer\",\"totalOwed\":\"Total amount of the loan to be repaid\"}}},\"kind\":\"dev\",\"methods\":{\"escrowRepay(uint256,uint256)\":{\"details\":\"If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\",\"params\":{\"amount\":\"The amount being repaid.\",\"loanID\":\"The id of the loan being used.\"}},\"getLiquidationReward(uint256)\":{\"params\":{\"loanID\":\"The loan ID to get the info.\"},\"returns\":{\"inCollateral_\":\"The value the liquidator will receive denoted in collateral tokens.\",\"inLending_\":\"The value the liquidator will receive denoted in lending tokens.\"}},\"liquidateLoan(uint256)\":{\"params\":{\"loanID\":\"The ID of the loan to be liquidated\"}},\"repayLoan(uint256,uint256)\":{\"params\":{\"amount\":\"The amount of tokens to pay back to the loan\",\"loanID\":\"The ID of the loan the payment is for\"}}},\"version\":1},\"userdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully liquidated\"},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully repaid\"}},\"kind\":\"user\",\"methods\":{\"escrowRepay(uint256,uint256)\":{\"notice\":\"Repay this Escrow's loan.\"},\"getLiquidationReward(uint256)\":{\"notice\":\"It gets the current liquidation reward for a given loan.\"},\"liquidateLoan(uint256)\":{\"notice\":\"Liquidate a loan if it is expired or under collateralized\"},\"repayLoan(uint256,uint256)\":{\"notice\":\"Make a payment to a loan\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/market/RepayFacet.sol\":\"RepayFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Trees proofs.\\n *\\n * The proofs can be generated using the JavaScript library\\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\\n *\\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n bytes32 computedHash = leaf;\\n\\n for (uint256 i = 0; i < proof.length; i++) {\\n bytes32 proofElement = proof[i];\\n\\n if (computedHash <= proofElement) {\\n // Hash(current computed hash + current element of the proof)\\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\\n } else {\\n // Hash(current element of the proof + current computed hash)\\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\\n }\\n }\\n\\n // Check if the computed hash (root) is equal to the provided root\\n return computedHash == root;\\n }\\n}\\n\",\"keccak256\":\"0xeee34bfb413657b6cd6c8e1e15c2080ba5ebaac479578515922804346fb63f7c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/reentry/ReentryMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nabstract contract ReentryMods {\\n modifier nonReentry(bytes32 id) {\\n AccessControlStorage storage s = AccessControlStorageLib.store();\\n require(!s.entered[id], \\\"AccessControl: reentered\\\");\\n s.entered[id] = true;\\n _;\\n s.entered[id] = false;\\n }\\n}\\n\",\"keccak256\":\"0x033c1164af25ef7d35a38a60973bf379b1cc603596914ffd85dcbcf0acdb6970\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../interfaces/IAToken.sol\\\";\\nimport { IAaveLendingPool } from \\\"../interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x8030b206c87d0073fb7dbebfa2ee8a3e93c479d976d6cdaa0c939f2fedaa1525\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n function setTokenAllowance(address token, address spender) external;\\n\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xdaa338698014e6c00edf7a2aca49026a047e253cbe7fc392a73f5f63a063a7f9\",\"license\":\"MIT\"},\"contracts/escrow/libraries/LibEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibDapps } from \\\"../dapps/libraries/LibDapps.sol\\\";\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibEscrow {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\\n e_ = s().loanEscrows[loanID];\\n }\\n\\n function getEscrowTokens(uint256 loanID)\\n internal\\n view\\n returns (EnumerableSet.AddressSet storage t_)\\n {\\n t_ = s().escrowTokens[loanID];\\n }\\n\\n function balanceOf(uint256 loanID, address token)\\n internal\\n view\\n returns (uint256)\\n {\\n return IERC20(token).balanceOf(address(e(loanID)));\\n }\\n\\n /**\\n * @notice Adds or removes tokens held by the Escrow contract\\n * @param loanID The loan ID to update the token list for\\n * @param tokenAddress The token address to be added or removed\\n */\\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\\n // Skip if is lending token\\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\\n\\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\\n if (balanceOf(loanID, tokenAddress) > 0) {\\n if (!contains) {\\n EnumerableSet.add(tokens, tokenAddress);\\n }\\n } else if (contains) {\\n EnumerableSet.remove(tokens, tokenAddress);\\n }\\n }\\n\\n /**\\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\\n * @param loanID The loan ID to calculate value for\\n * @return value_ Escrow total value denoted in the lending token.\\n */\\n function calculateTotalValue(uint256 loanID)\\n internal\\n view\\n returns (uint256 value_)\\n {\\n address lendingToken = LibLoans.loan(loanID).lendingToken;\\n value_ += balanceOf(loanID, lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\\n if (EnumerableSet.length(tokens) > 0) {\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n uint256 tokenBal =\\n balanceOf(loanID, EnumerableSet.at(tokens, i));\\n value_ += PriceAggLib.valueFor(\\n EnumerableSet.at(tokens, i),\\n lendingToken,\\n tokenBal\\n );\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xcca97599fff1c1bd608e7f11c4674f325e43781794e91bf5322ac9e0ffd7b3df\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when an user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when an user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @return totalSupply_ The total value of the underlying token managed by the LP.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given markets.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider o the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfil the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n */\\n function restrict(bool state) external virtual;\\n\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xe6515c78e0277edbed82aa6926df727afd216379dd0bfbbb790222654c858499\",\"license\":\"MIT\"},\"contracts/market/LoanDataFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { Loan, LoanDebt, LoanTerms } from \\\"../storage/market.sol\\\";\\n\\ncontract LoanDataFacet {\\n /**\\n * @notice Returns the information about the given {loanID}.\\n * @param loanID The loan ID to get information for.\\n * @return loan_ The loan data.\\n */\\n function getLoan(uint256 loanID) external view returns (Loan memory loan_) {\\n loan_ = LibLoans.s().loans[loanID];\\n }\\n\\n /**\\n * @notice Returns the terms for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanTerms The terms that the loan weer created with.\\n */\\n function getLoanTerms(uint256 loanID)\\n external\\n view\\n returns (LoanTerms memory)\\n {\\n return LibLoans.terms(loanID);\\n }\\n\\n /**\\n * @notice Returns the loan IDs created by the {borrower} account.\\n * @param borrower The account to get loan IDs for.\\n * @return loanIDs The IDs for loans created by the {borrower}\\n */\\n function getBorrowerLoans(address borrower)\\n external\\n view\\n returns (uint128[] memory loanIDs)\\n {\\n return LibLoans.s().borrowerLoans[borrower];\\n }\\n\\n /**\\n * @notice Returns the debt owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanDebt The principal and interest owed amount.\\n */\\n function getDebtOwed(uint256 loanID)\\n external\\n view\\n returns (LoanDebt memory)\\n {\\n return LibLoans.debt(loanID);\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) external view returns (uint256) {\\n return LibLoans.getTotalOwed(loanID);\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n external\\n view\\n returns (uint256)\\n {\\n return LibLoans.getInterestOwedFor(loanID, amountBorrow);\\n }\\n\\n function getCollateralNeededInfo(uint256 loanID)\\n external\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n return LibLoans.getCollateralNeededInfo(loanID);\\n }\\n\\n function getLoanEscrow(uint256 loanID)\\n external\\n view\\n returns (address escrow_)\\n {\\n escrow_ = address(LibLoans.s().loanEscrows[loanID]);\\n }\\n\\n function getLoanEscrowValue(uint256 loanID)\\n external\\n view\\n returns (uint256)\\n {\\n return LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n function getEscrowTokens(uint256 loanID)\\n external\\n view\\n returns (address[] memory tokens_)\\n {\\n EnumerableSet.AddressSet storage escrowTokens =\\n LibEscrow.getEscrowTokens(loanID);\\n tokens_ = new address[](EnumerableSet.length(escrowTokens));\\n for (uint256 i; i < tokens_.length; i++) {\\n tokens_[i] = EnumerableSet.at(escrowTokens, i);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf589a2afff647e5288e15f3f6614135395562b4d12c743402a6504a3fb9b39d6\",\"license\":\"MIT\"},\"contracts/market/RepayFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\nimport {\\n ReentryMods\\n} from \\\"../contexts2/access-control/reentry/ReentryMods.sol\\\";\\nimport { AUTHORIZED } from \\\"../shared/roles.sol\\\";\\nimport { LoanDataFacet } from \\\"./LoanDataFacet.sol\\\";\\n\\n// Libraries\\nimport {\\n IERC20,\\n SafeERC20\\n} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibCollateral } from \\\"./libraries/LibCollateral.sol\\\";\\nimport { LibDapps } from \\\"../escrow/dapps/libraries/LibDapps.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { NumbersLib } from \\\"../shared/libraries/NumbersLib.sol\\\";\\nimport { PriceAggLib } from \\\"../price-aggregator/PriceAggLib.sol\\\";\\nimport { NFTLib } from \\\"../nft/libraries/NFTLib.sol\\\";\\n\\n// Interfaces\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus\\n} from \\\"../storage/market.sol\\\";\\n\\ncontract RepayFacet is RolesMods, ReentryMods, PausableMods {\\n /**\\n @notice This event is emitted when a loan has been successfully repaid\\n @param loanID ID of loan from which collateral was withdrawn\\n @param borrower Account address of the borrower\\n @param amountPaid Amount of the loan paid back\\n @param payer Account address of the payer\\n @param totalOwed Total amount of the loan to be repaid\\n */\\n event LoanRepaid(\\n uint256 indexed loanID,\\n address indexed borrower,\\n uint256 amountPaid,\\n address payer,\\n uint256 totalOwed\\n );\\n\\n /**\\n * @notice This event is emitted when a loan has been successfully liquidated\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param borrower Account address of the borrower\\n * @param liquidator Account address of the liquidator\\n * @param reward Value in lending token paid out to liquidator\\n * @param tokensIn Percentage of the collateral price paid by the liquidator to the lending pool\\n */\\n event LoanLiquidated(\\n uint256 indexed loanID,\\n address indexed borrower,\\n address liquidator,\\n uint256 reward,\\n uint256 tokensIn\\n );\\n\\n /**\\n * @notice Repay this Escrow's loan.\\n * @dev If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.\\n * @dev Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\\n * @param loanID The id of the loan being used.\\n * @param amount The amount being repaid.\\n */\\n function escrowRepay(uint256 loanID, uint256 amount)\\n external\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n nonReentry(\\\"\\\")\\n {\\n uint256 balance =\\n LibEscrow.balanceOf(loanID, LibLoans.loan(loanID).lendingToken);\\n uint256 totalOwed = LibLoans.getTotalOwed(loanID);\\n if (balance < totalOwed && amount > balance) {\\n uint256 amountNeeded =\\n amount > totalOwed ? totalOwed - (balance) : amount - (balance);\\n\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n msg.sender,\\n address(LibEscrow.e(loanID)),\\n amountNeeded\\n );\\n }\\n\\n __repayLoan(loanID, amount, address(LibEscrow.e(loanID)), false);\\n }\\n\\n /**\\n * @notice Make a payment to a loan\\n * @param loanID The ID of the loan the payment is for\\n * @param amount The amount of tokens to pay back to the loan\\n */\\n function repayLoan(uint256 loanID, uint256 amount)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n __repayLoan(loanID, amount, msg.sender, false);\\n }\\n\\n function __repayLoan(\\n uint256 loanID,\\n uint256 amount,\\n address sender,\\n bool isLiquidation\\n ) private returns (uint256 leftToPay_) {\\n require(amount > 0, \\\"Teller: zero repay\\\");\\n\\n // calculate the actual amount to repay\\n leftToPay_ =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n if (leftToPay_ < amount) {\\n amount = leftToPay_;\\n leftToPay_ = 0;\\n } else {\\n leftToPay_ -= amount;\\n }\\n\\n // Get the Teller token for the loan\\n ITToken tToken =\\n MarketStorageLib.store().tTokens[\\n LibLoans.loan(loanID).lendingToken\\n ];\\n // Transfer funds from account\\n if (address(LibEscrow.e(loanID)) == sender) {\\n LibEscrow.e(loanID).claimToken(\\n LibLoans.loan(loanID).lendingToken,\\n address(tToken),\\n amount\\n );\\n } else {\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n sender,\\n address(tToken),\\n amount\\n );\\n }\\n\\n // Deduct the interest and principal owed\\n uint256 principalPaid;\\n uint256 interestPaid;\\n if (amount < LibLoans.debt(loanID).interestOwed) {\\n interestPaid = amount;\\n LibLoans.debt(loanID).interestOwed -= amount;\\n } else {\\n if (LibLoans.debt(loanID).interestOwed > 0) {\\n interestPaid = LibLoans.debt(loanID).interestOwed;\\n amount -= interestPaid;\\n LibLoans.debt(loanID).interestOwed = 0;\\n }\\n\\n if (amount > 0) {\\n principalPaid = amount;\\n LibLoans.debt(loanID).principalOwed -= amount;\\n }\\n }\\n\\n // Tell the Teller Token value has been deposited back into the pool.\\n tToken.repayLoan(principalPaid, interestPaid);\\n\\n if (isLiquidation) {\\n // Make sure there is nothing left to repay on the loan\\n require(leftToPay_ == 0, \\\"Teller: liquidate partial repay\\\");\\n\\n // Set loan status\\n LibLoans.loan(loanID).status = LoanStatus.Liquidated;\\n\\n // Transfer NFT if linked\\n NFTLib.liquidateNFT(loanID);\\n } else {\\n // if the loan is now fully paid, close it and withdraw borrower collateral\\n if (leftToPay_ == 0) {\\n LibLoans.loan(loanID).status = LoanStatus.Closed;\\n LibCollateral.withdrawAll(\\n loanID,\\n LibLoans.loan(loanID).borrower\\n );\\n // Restake any NFTs linked to loan for borrower\\n NFTLib.restakeLinked(loanID, LibLoans.loan(loanID).borrower);\\n }\\n\\n emit LoanRepaid(\\n loanID,\\n LibLoans.loan(loanID).borrower,\\n amount,\\n msg.sender,\\n leftToPay_\\n );\\n }\\n }\\n\\n /**\\n * @notice Liquidate a loan if it is expired or under collateralized\\n * @param loanID The ID of the loan to be liquidated\\n */\\n function liquidateLoan(uint256 loanID)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n uint256 collateralAmount = LibCollateral.e(loanID).loanSupply(loanID);\\n require(\\n RepayLib.isLiquidable(loanID, collateralAmount),\\n \\\"Teller: does not need liquidation\\\"\\n );\\n\\n // Calculate the reward before repaying the loan\\n (uint256 rewardInLending, uint256 collateralInLending) =\\n RepayLib.getLiquidationReward(loanID, collateralAmount);\\n\\n // The liquidator pays the amount still owed on the loan\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n __repayLoan(loanID, amountToLiquidate, msg.sender, true);\\n\\n // Payout the liquidator reward owed\\n if (rewardInLending > 0) {\\n RepayLib.payOutLiquidator(\\n loanID,\\n rewardInLending,\\n collateralInLending,\\n collateralAmount,\\n payable(msg.sender)\\n );\\n }\\n\\n emit LoanLiquidated(\\n loanID,\\n loan.borrower,\\n msg.sender,\\n rewardInLending,\\n amountToLiquidate\\n );\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @return inLending_ The value the liquidator will receive denoted in lending tokens.\\n * @return inCollateral_ The value the liquidator will receive denoted in collateral tokens.\\n */\\n function getLiquidationReward(uint256 loanID)\\n external\\n view\\n returns (uint256 inLending_, uint256 inCollateral_)\\n {\\n (inLending_, ) = RepayLib.getLiquidationReward(\\n loanID,\\n LibCollateral.e(loanID).loanSupply(loanID)\\n );\\n inCollateral_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n inLending_\\n );\\n }\\n}\\n\\nlibrary RepayLib {\\n /**\\n * @notice It checks if a loan can be liquidated.\\n * @param loanID The loan ID to check.\\n * @return true if the loan is liquidable.\\n */\\n function isLiquidable(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (bool)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n // Check if loan can be liquidated\\n if (loan.status != LoanStatus.Active) {\\n return false;\\n }\\n\\n if (loan.collateralRatio > 0) {\\n // If loan has a collateral ratio, check how much is needed\\n (, uint256 neededInCollateral, ) =\\n LoanDataFacet(address(this)).getCollateralNeededInfo(loanID);\\n if (neededInCollateral > collateralAmount) {\\n return true;\\n }\\n }\\n\\n // Otherwise, check if the loan has expired\\n return block.timestamp >= loan.loanStartTime + loan.duration;\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @param collateralAmount The amount of collateral for the {loanID}. Passed in to save gas calling the collateral escrow multiple times.\\n * @return reward_ The value the liquidator will receive denoted in lending tokens.\\n */\\n function getLiquidationReward(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (uint256 reward_, uint256 collateralValue_)\\n {\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n // Max reward is amount repaid on loan plus extra percentage\\n uint256 maxReward =\\n amountToLiquidate +\\n NumbersLib.percent(\\n amountToLiquidate,\\n uint16(PlatformSettingsLib.getLiquidateRewardPercent())\\n );\\n\\n // Calculate available collateral for reward\\n if (collateralAmount > 0) {\\n collateralValue_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).collateralToken,\\n LibLoans.loan(loanID).lendingToken,\\n collateralAmount\\n );\\n reward_ += collateralValue_;\\n }\\n\\n // Calculate loan escrow value if collateral not enough to cover reward\\n if (reward_ < maxReward) {\\n reward_ += LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n // Cap the reward to max\\n if (reward_ > maxReward) {\\n reward_ = maxReward;\\n }\\n }\\n\\n /**\\n * @notice Checks if the loan has an Escrow and claims any tokens then pays out the loan collateral.\\n * @dev See Escrow.claimTokens for more info.\\n * @param loanID The loan ID which is being liquidated\\n * @param rewardInLending The total amount of reward based in the lending token to pay the liquidator\\n * @param collateralInLending The amount of collateral that is available for the loan denoted in lending tokens\\n * @param collateralAmount The amount of collateral that is available for the loan\\n * @param liquidator The address of the liquidator where the liquidation reward will be sent to\\n */\\n function payOutLiquidator(\\n uint256 loanID,\\n uint256 rewardInLending,\\n uint256 collateralInLending,\\n uint256 collateralAmount,\\n address payable liquidator\\n ) internal {\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Liquidated,\\n \\\"Teller: loan not liquidated\\\"\\n );\\n\\n if (rewardInLending <= collateralInLending) {\\n uint256 rewardInCollateral =\\n PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n rewardInLending\\n );\\n\\n LibCollateral.withdraw(loanID, rewardInCollateral, liquidator);\\n } else {\\n // Payout whats available in the collateral token\\n LibCollateral.withdraw(loanID, collateralAmount, liquidator);\\n\\n // Claim remaining reward value from the loan escrow\\n claimEscrowTokensByValue(\\n loanID,\\n liquidator,\\n rewardInLending - collateralInLending\\n );\\n }\\n }\\n\\n /**\\n * @dev Send the equivalent of tokens owned by the loan escrow (in lending value) to the recipient,\\n * @param loanID The loan ID to clam tokens from\\n * @param recipient address to send the tokens to\\n * @param value The value of escrow held tokens to be claimed based in lending value\\n */\\n function claimEscrowTokensByValue(\\n uint256 loanID,\\n address recipient,\\n uint256 value\\n ) private {\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n uint256 valueLeftToTransfer = value;\\n\\n // Start with the lending token\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n LibLoans.loan(loanID).lendingToken,\\n recipient,\\n valueLeftToTransfer\\n );\\n\\n // Cycle through remaining tokens\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n if (valueLeftToTransfer == 0) {\\n return;\\n }\\n\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n EnumerableSet.at(tokens, i),\\n recipient,\\n valueLeftToTransfer\\n );\\n }\\n }\\n\\n function claimEscrowToken(\\n uint256 loanID,\\n address token,\\n address recipient,\\n uint256 valueLeftToTransfer\\n ) private returns (uint256) {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n // get value of token balance in lending value\\n if (balance > 0) {\\n // If token not the lending token, get value of token\\n uint256 balanceInLending;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n balanceInLending = balance;\\n } else {\\n balanceInLending = PriceAggLib.valueFor(\\n token,\\n LibLoans.loan(loanID).lendingToken,\\n balance\\n );\\n }\\n\\n if (balanceInLending <= valueLeftToTransfer) {\\n LibEscrow.e(loanID).claimToken(token, recipient, balance);\\n valueLeftToTransfer -= balanceInLending;\\n } else {\\n // Token balance is more than enough so calculate ratio of balance to transfer\\n uint256 valueToTransfer;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n valueToTransfer = valueLeftToTransfer;\\n } else {\\n valueToTransfer = NumbersLib.percent(\\n balance,\\n NumbersLib.ratioOf(\\n valueLeftToTransfer,\\n balanceInLending\\n )\\n );\\n }\\n\\n LibEscrow.e(loanID).claimToken(\\n token,\\n recipient,\\n valueToTransfer\\n );\\n valueLeftToTransfer = 0;\\n }\\n }\\n\\n return valueLeftToTransfer;\\n }\\n}\\n\",\"keccak256\":\"0xdfcd62dbcda7ba0ce92718d72d6cab3f7c78178d9ac9de6b04640124d43bf4cc\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n function init(address tokenAddress, bool isWETH) external;\\n\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x3c83593b5521e85c7f62076b41869cd5a762b34523ac39fc23b4ea1b9042aa59\",\"license\":\"MIT\"},\"contracts/market/libraries/LibCollateral.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport { ICollateralEscrow } from \\\"../collateral/ICollateralEscrow.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\nimport { MarketStorageLib } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibCollateral {\\n /**\\n * @notice This event is emitted when collateral has been deposited for the loan\\n * @param loanID ID of the loan for which collateral was deposited\\n * @param depositor Account that deposited funds\\n * @param amount Amount of collateral deposited\\n */\\n event CollateralDeposited(\\n uint256 indexed loanID,\\n address indexed depositor,\\n uint256 amount\\n );\\n\\n /**\\n * @notice This event is emitted when collateral has been withdrawn\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param receiver Account that received funds\\n * @param amount Value of collateral withdrawn\\n */\\n event CollateralWithdrawn(\\n uint256 indexed loanID,\\n address indexed receiver,\\n uint256 amount\\n );\\n\\n function e(uint256 loanID) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[\\n MarketStorageLib.store().loans[loanID].collateralToken\\n ];\\n }\\n\\n function e(address token) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[token];\\n }\\n\\n function deposit(uint256 loanID, uint256 amount) internal {\\n e(loanID).deposit{ value: amount }(loanID, amount);\\n\\n emit CollateralDeposited(loanID, msg.sender, amount);\\n }\\n\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) internal {\\n e(loanID).withdraw(loanID, amount, receiver);\\n\\n emit CollateralWithdrawn(loanID, receiver, amount);\\n }\\n\\n function withdrawAll(uint256 loanID, address payable receiver) internal {\\n withdraw(loanID, e(loanID).loanSupply(loanID), receiver);\\n }\\n\\n function createEscrow(address token) internal {\\n // Check if collateral escrow exists\\n if (address(e(token)) == address(0)) {\\n // Create escrow\\n address escrow =\\n AppStorageLib.store().collateralEscrowBeacon.cloneProxy(\\\"\\\");\\n ICollateralEscrow(escrow).init(\\n token,\\n // Check if collateral token is WETH\\n token == AppStorageLib.store().assetAddresses[\\\"WETH\\\"]\\n );\\n\\n // Set max allowance\\n IERC20(token).approve(escrow, type(uint256).max);\\n // Save escrow address for loan\\n MarketStorageLib.store().collateralEscrows[\\n token\\n ] = ICollateralEscrow(escrow);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd52b3e577480481b62d6a6c37f4ef596b7ec0120afbd6bc1a08b17923b926445\",\"license\":\"MIT\"},\"contracts/market/libraries/LibLoans.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibEscrow } from \\\"../../escrow/libraries/LibEscrow.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus,\\n LoanDebt,\\n LoanTerms\\n} from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibLoans {\\n using NumbersLib for int256;\\n using NumbersLib for uint256;\\n\\n bytes32 internal constant ID = keccak256(\\\"LOANS\\\");\\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\\n l_ = s().loans[loanID];\\n }\\n\\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\\n d_ = s().loanDebt[loanID];\\n }\\n\\n function terms(uint256 loanID)\\n internal\\n view\\n returns (LoanTerms storage t_)\\n {\\n t_ = s().loanTerms[loanID];\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) internal view returns (uint256) {\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n uint256 interestOwed =\\n getInterestOwedFor(loanID, terms(loanID).maxLoanAmount);\\n return terms(loanID).maxLoanAmount + (interestOwed);\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n return debt(loanID).principalOwed + (debt(loanID).interestOwed);\\n }\\n return 0;\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n internal\\n view\\n returns (uint256)\\n {\\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\\n }\\n\\n function getCollateralNeededInfo(uint256 loanID)\\n internal\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\\n loanID\\n );\\n\\n if (neededInLendingTokens == 0) {\\n neededInCollateralTokens = 0;\\n } else {\\n neededInCollateralTokens = PriceAggLib.valueFor(\\n loan(loanID).lendingToken,\\n loan(loanID).collateralToken,\\n neededInLendingTokens\\n );\\n }\\n }\\n\\n /**\\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\\n * @param loanID The loan ID to get needed collateral info for.\\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\\n */\\n function getCollateralNeededInTokens(uint256 loanID)\\n internal\\n view\\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\\n {\\n if (!_isActiveOrSet(loanID) || loan(loanID).collateralRatio == 0) {\\n return (0, 0);\\n }\\n\\n /*\\n The collateral to principal owed ratio is the sum of:\\n * collateral buffer percent\\n * loan interest rate\\n * liquidation reward percent\\n * X factor of additional collateral\\n */\\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n neededInLendingTokens = _getLoanAmount(loanID).percent(\\n loan(loanID).collateralRatio\\n );\\n } else {\\n uint16 requiredRatio =\\n loan(loanID).collateralRatio -\\n getInterestRatio(loanID) -\\n uint16(PlatformSettingsLib.getCollateralBufferValue());\\n\\n neededInLendingTokens =\\n debt(loanID).principalOwed +\\n debt(loanID).interestOwed;\\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\\n if (\\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\\n ) {\\n neededInLendingTokens -= escrowLoanValue;\\n }\\n neededInLendingTokens = neededInLendingTokens.percent(\\n requiredRatio\\n );\\n }\\n }\\n\\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\\n internal\\n view\\n returns (bool)\\n {\\n return\\n collateralRatio >=\\n PlatformSettingsLib.getOverCollateralizedBufferValue();\\n }\\n\\n /**\\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\\n * @notice There is a minimum threshold of 1%.\\n * @dev The interest rate on the loan terms is APY.\\n * @param loanID The loan ID to get the interest rate for.\\n */\\n function getInterestRatio(uint256 loanID)\\n internal\\n view\\n returns (uint16 ratio_)\\n {\\n ratio_ = uint16(\\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\\n SECONDS_PER_YEAR\\n );\\n\\n if (ratio_ == 0) {\\n ratio_ = 1;\\n }\\n }\\n\\n function _getLoanAmount(uint256 loanID) private view returns (uint256) {\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n return terms(loanID).maxLoanAmount;\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n return loan(loanID).borrowedAmount;\\n }\\n return 0;\\n }\\n\\n function _isActiveOrSet(uint256 loanID) private view returns (bool) {\\n LoanStatus status = loan(loanID).status;\\n return status == LoanStatus.Active || status == LoanStatus.TermsSet;\\n }\\n}\\n\",\"keccak256\":\"0x9bf9fae5b01110da7c5a5d2517fdea6aa880d5c1647ba6125c68cafad278499b\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x7c788b94c175b70eec6b10bfe0655616fc0beb2ce3ef70a6fa750f291d35106c\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}.\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x39fd6d70fd1aa5ae45465d7eeb38f74e2bf90535c2510782fb0bb5f720250ac5\",\"license\":\"MIT\"},\"contracts/nft/libraries/NFTLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../TellerNFT.sol\\\";\\n\\n// Libraries\\nimport {\\n MerkleProof\\n} from \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\nimport { NFTStorageLib, NFTStorage } from \\\"../../storage/nft.sol\\\";\\n\\nstruct NftLoanSizeProof {\\n uint256 id;\\n uint256 baseLoanSize;\\n bytes32[] proof;\\n}\\n\\nlibrary NFTLib {\\n function s() internal pure returns (NFTStorage storage s_) {\\n s_ = NFTStorageLib.store();\\n }\\n\\n function nft() internal view returns (TellerNFT nft_) {\\n nft_ = AppStorageLib.store().nft;\\n }\\n\\n function stake(uint256 nftID, address owner) internal {\\n // Transfer to diamond\\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\\n // Add NFT ID to user set\\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\\n }\\n\\n function unstake(uint256 nftID) internal returns (bool success_) {\\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\\n }\\n\\n function stakedNFTs(address nftOwner)\\n internal\\n view\\n returns (uint256[] memory staked_)\\n {\\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\\n staked_ = new uint256[](EnumerableSet.length(nfts));\\n for (uint256 i; i < staked_.length; i++) {\\n staked_[i] = EnumerableSet.at(nfts, i);\\n }\\n }\\n\\n function liquidateNFT(uint256 loanID) internal {\\n // Check if NFTs are linked\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n NFTLib.nft().transferFrom(\\n address(this),\\n AppStorageLib.store().nftLiquidationController,\\n EnumerableSet.at(nfts, i)\\n );\\n }\\n }\\n\\n function applyToLoan(uint256 loanID, NftLoanSizeProof calldata proof)\\n internal\\n {\\n // NFT must be currently staked\\n // Remove NFT from being staked - returns bool\\n require(unstake(proof.id), \\\"Teller: borrower nft not staked\\\");\\n\\n require(verifyLoanSize(proof), \\\"Teller invalid nft proof\\\");\\n\\n // Apply NFT to loan\\n EnumerableSet.add(s().loanNFTs[loanID], proof.id);\\n }\\n\\n function restakeLinked(uint256 loanID, address owner) internal {\\n // Get linked NFT\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n // Restake the NFT\\n EnumerableSet.add(s().stakedNFTs[owner], EnumerableSet.at(nfts, i));\\n }\\n }\\n\\n function verifyLoanSize(NftLoanSizeProof calldata proof)\\n internal\\n view\\n returns (bool verified_)\\n {\\n verified_ = MerkleProof.verify(\\n proof.proof,\\n s().nftMerkleRoot,\\n keccak256(abi.encodePacked(proof.id, proof.baseLoanSize))\\n );\\n }\\n}\\n\",\"keccak256\":\"0x99ba27095901d86a4d1e1b9ec3a603fbbf7c67ada2ccd11cd5ed0435e5c3c66d\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @dev It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @dev Tries to calculate a price from Compound and Chainlink.\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @dev Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @dev Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @dev Scales the {value} by the difference in decimal values.\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @dev Tries to calculate the price of {src} in {dst}\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address WETH = AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n if (dst != WETH) {\\n int256 price1 = _priceFor(src, WETH);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, WETH);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf84fd8d9a179ca7a70e75677870bdd7a5be7da097cf5f1bccf1c9f93253bda90\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { PriceAggFacet } from \\\"./PriceAggFacet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\n/**\\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\\n */\\nlibrary PriceAggLib {\\n /**\\n * @notice See {PriceAggFacet.getValueFor}\\n */\\n function valueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) internal view returns (uint256 value_) {\\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\\n }\\n\\n /**\\n * @notice See {PriceAggFacet.getPriceFor}\\n */\\n function priceFor(address src, address dst)\\n internal\\n view\\n returns (int256 price_)\\n {\\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\\n }\\n}\\n\",\"keccak256\":\"0x510633e39e7a30533d703eb7ec314c037772721fdb7cea96046cd6837bcb76c3\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\nabstract contract PausableMods {\\n /**\\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\\n * @param id id of the facet to check if is paused.\\n * @param state Boolean that the protocol AND facet should be in.\\n */\\n modifier paused(bytes32 id, bool state) {\\n require(\\n __isPaused(\\\"\\\") == state && __isPaused(id) == state,\\n __pausedMessage(state)\\n );\\n _;\\n }\\n\\n /**\\n * @dev Checks if the given id is paused.\\n * @param id Encoded id of the facet to check if is paused.\\n */\\n function __isPaused(bytes32 id) private view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n\\n /**\\n * @dev Gets the message that should be reverted with given a state it should be in.\\n * @param state Boolean that an id should be in.\\n */\\n function __pausedMessage(bool state) private pure returns (string memory) {\\n return state ? \\\"Pausable: not paused\\\" : \\\"Pausable: paused\\\";\\n }\\n}\\n\",\"keccak256\":\"0x772d8b9b63e9b8e78f243a70988f1a1e1100272cf317259ea173829f7b9bdf0e\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0xbeef1937dc1ed1f6f78b80f0737f018565ab264184cf05ef54c3c28ecd55a09b\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xacf6bcb8c4afd2f337a0161e8be64b016c1b350d336cd862245dd922fcd10f33\",\"license\":\"MIT\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n function claimComp(address holder) external;\\n\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x495d8bb746a524fea6ddc4286c955d7a0160718bf662456330a9d6d14b8a5da9\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n\\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x208769886b3db8f03ef1fa26f1caee189038dfc744b9a499402fc4e4c0090c38\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4d9045666e86d675f7bd48202f9a77d0675fa20b2184131ad369710ac5eb3203\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @notice CETH is the only Compound token that does not support the {underlying} function.\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x14e96659912e9d03ae30732faca8e3d617f3e756a215d948cabedab6642c1465\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0x998aefaf4edbe7b0cb41032750b65b3822b4bec0fec3ee5b396f8fb73b5e9e03\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0x8919fcdfb49018474c872c462c11b21a50faa7ab80f0162abd6b657cbbc5d04c\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x0888cf40ea019be9f0ee94cb8af1e030454c28f8c6512db9d89ed027fe21f18f\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n bool initialized;\\n bool platformRestricted;\\n mapping(bytes32 => bool) paused;\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0xade1dda8163fc39658e5f6929b662187584b29cce47e9cb0915fc0d1832fb4f7\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) loanTerms;\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5f3fdba19ae8040e2007affe422527b7dca58ba424df33ba4dd9cb08d83d00de\",\"license\":\"MIT\"},\"contracts/storage/nft.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Utils\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct NFTStorage {\\n // Maps NFT owner to set of token IDs owned\\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\\n // Maps loanID to NFT IDs indicating NFT being used for the loan\\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\\n // Merkle root used for verifying nft IDs to base loan size\\n bytes32 nftMerkleRoot;\\n}\\n\\nbytes32 constant NFT_STORAGE_POS = keccak256(\\\"teller.staking.storage\\\");\\n\\nlibrary NFTStorageLib {\\n function store() internal pure returns (NFTStorage storage s) {\\n bytes32 pos = NFT_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x8d58bb6ba00310d8c3d89b95c62e5c997430a1124d73224897f7d9b2a43ab50a\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "params": { + "borrower": "Account address of the borrower", + "liquidator": "Account address of the liquidator", + "loanID": "ID of loan from which collateral was withdrawn", + "reward": "Value in lending token paid out to liquidator", + "tokensIn": "Percentage of the collateral price paid by the liquidator to the lending pool" + } + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "params": { + "amountPaid": "Amount of the loan paid back", + "borrower": "Account address of the borrower", + "loanID": "ID of loan from which collateral was withdrawn", + "payer": "Account address of the payer", + "totalOwed": "Total amount of the loan to be repaid" + } + } + }, + "kind": "dev", + "methods": { + "escrowRepay(uint256,uint256)": { + "details": "If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.", + "params": { + "amount": "The amount being repaid.", + "loanID": "The id of the loan being used." + } + }, + "getLiquidationReward(uint256)": { + "params": { + "loanID": "The loan ID to get the info." + }, + "returns": { + "inCollateral_": "The value the liquidator will receive denoted in collateral tokens.", + "inLending_": "The value the liquidator will receive denoted in lending tokens." + } + }, + "liquidateLoan(uint256)": { + "params": { + "loanID": "The ID of the loan to be liquidated" + } + }, + "repayLoan(uint256,uint256)": { + "params": { + "amount": "The amount of tokens to pay back to the loan", + "loanID": "The ID of the loan the payment is for" + } + } + }, + "version": 1 + }, + "userdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "notice": "This event is emitted when a loan has been successfully liquidated" + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "notice": "This event is emitted when a loan has been successfully repaid" + } + }, + "kind": "user", + "methods": { + "escrowRepay(uint256,uint256)": { + "notice": "Repay this Escrow's loan." + }, + "getLiquidationReward(uint256)": { + "notice": "It gets the current liquidation reward for a given loan." + }, + "liquidateLoan(uint256)": { + "notice": "Liquidate a loan if it is expired or under collateralized" + }, + "repayLoan(uint256,uint256)": { + "notice": "Make a payment to a loan" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0x28E2Ce61Ec8dEd7f7bC9CBa02a33573f7dd9f5F5", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "RepayFacet", + "transactionHash": "0x9bb6ed95cafb2cabe8e6ba16a7a301d849e43215e14b90241632191de6f23df4", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x28E2Ce61Ec8dEd7f7bC9CBa02a33573f7dd9f5F5", + "transactionIndex": 0, + "gasUsed": "1757520", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xf56922a6944840f350477d7431a8f2148417641af4a62f6bc382ec1cdf4130d1", + "transactionHash": "0x9bb6ed95cafb2cabe8e6ba16a7a301d849e43215e14b90241632191de6f23df4", + "logs": [], + "blockNumber": 25347871, + "cumulativeGasUsed": "1757520", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "7646e63ef89d3687a032672685314b8f", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"liquidator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"reward\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokensIn\",\"type\":\"uint256\"}],\"name\":\"LoanLiquidated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountPaid\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"totalOwed\",\"type\":\"uint256\"}],\"name\":\"LoanRepaid\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"escrowRepay\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLiquidationReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"inLending_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"inCollateral_\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"liquidateLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"repayLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"params\":{\"borrower\":\"Account address of the borrower\",\"liquidator\":\"Account address of the liquidator\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"reward\":\"Value in lending token paid out to liquidator\",\"tokensIn\":\"Percentage of the collateral price paid by the liquidator to the lending pool\"}},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"params\":{\"amountPaid\":\"Amount of the loan paid back\",\"borrower\":\"Account address of the borrower\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"payer\":\"Account address of the payer\",\"totalOwed\":\"Total amount of the loan to be repaid\"}}},\"kind\":\"dev\",\"methods\":{\"escrowRepay(uint256,uint256)\":{\"details\":\"If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\",\"params\":{\"amount\":\"The amount being repaid.\",\"loanID\":\"The id of the loan being used.\"}},\"getLiquidationReward(uint256)\":{\"params\":{\"loanID\":\"The loan ID to get the info.\"},\"returns\":{\"inCollateral_\":\"The value the liquidator will receive denoted in collateral tokens.\",\"inLending_\":\"The value the liquidator will receive denoted in lending tokens.\"}},\"liquidateLoan(uint256)\":{\"params\":{\"loanID\":\"The ID of the loan to be liquidated\"}},\"repayLoan(uint256,uint256)\":{\"params\":{\"amount\":\"The amount of tokens to pay back to the loan\",\"loanID\":\"The ID of the loan the payment is for\"}}},\"version\":1},\"userdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully liquidated\"},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully repaid\"}},\"kind\":\"user\",\"methods\":{\"escrowRepay(uint256,uint256)\":{\"notice\":\"Repay this Escrow's loan.\"},\"getLiquidationReward(uint256)\":{\"notice\":\"It gets the current liquidation reward for a given loan.\"},\"liquidateLoan(uint256)\":{\"notice\":\"Liquidate a loan if it is expired or under collateralized\"},\"repayLoan(uint256,uint256)\":{\"notice\":\"Make a payment to a loan\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/market/RepayFacet.sol\":\"RepayFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Trees proofs.\\n *\\n * The proofs can be generated using the JavaScript library\\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\\n *\\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n bytes32 computedHash = leaf;\\n\\n for (uint256 i = 0; i < proof.length; i++) {\\n bytes32 proofElement = proof[i];\\n\\n if (computedHash <= proofElement) {\\n // Hash(current computed hash + current element of the proof)\\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\\n } else {\\n // Hash(current element of the proof + current computed hash)\\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\\n }\\n }\\n\\n // Check if the computed hash (root) is equal to the provided root\\n return computedHash == root;\\n }\\n}\\n\",\"keccak256\":\"0xeee34bfb413657b6cd6c8e1e15c2080ba5ebaac479578515922804346fb63f7c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/reentry/ReentryMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nabstract contract ReentryMods {\\n modifier nonReentry(bytes32 id) {\\n AccessControlStorage storage s = AccessControlStorageLib.store();\\n require(!s.entered[id], \\\"AccessControl: reentered\\\");\\n s.entered[id] = true;\\n _;\\n s.entered[id] = false;\\n }\\n}\\n\",\"keccak256\":\"0x033c1164af25ef7d35a38a60973bf379b1cc603596914ffd85dcbcf0acdb6970\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../interfaces/IAToken.sol\\\";\\nimport { IAaveLendingPool } from \\\"../interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x8030b206c87d0073fb7dbebfa2ee8a3e93c479d976d6cdaa0c939f2fedaa1525\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n /**\\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\\n * @param dappAddress address of the target contract address\\n * @param dappData encoded abi of the function in our contract we want to call\\n * @return the called data in bytes\\n */\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n /**\\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\\n * @param token address of the respective ERC20 token to approve for the spender\\n * @param spender address of the respective spender who is approved by the token contract\\n */\\n function setTokenAllowance(address token, address spender) external;\\n\\n /**\\n * @notice it allows user to claim their escrow tokens\\n * @dev only the owner (TellerDiamond) can make this call on behalf of the users\\n * @param token address of the respective token contract to claim tokens from\\n * @param to address where the tokens should be transferred to\\n * @param amount uint256 amount of tokens to be claimed\\n */\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xaf67fc4454ffaa4d2f7e46fe7101876e8ebdb1a5426c30f87b8e18cc573ac019\",\"license\":\"MIT\"},\"contracts/escrow/libraries/LibEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibDapps } from \\\"../dapps/libraries/LibDapps.sol\\\";\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibEscrow {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\\n e_ = s().loanEscrows[loanID];\\n }\\n\\n /**\\n * @notice It returns a list of tokens owned by a loan escrow\\n * @param loanID uint256 index used to return our token list\\n * @return t_ which is a list of tokens \\n */\\n function getEscrowTokens(uint256 loanID)\\n internal\\n view\\n returns (EnumerableSet.AddressSet storage t_)\\n {\\n t_ = s().escrowTokens[loanID];\\n }\\n\\n /**\\n * @notice It returns the balance of a respective token in a loan escrow\\n * @param loanID uint256 index used to point to our loan escrow\\n * @param token address of respective token to give us the balance of in our loan escrow\\n * @return uint256 balance of respective token returned in an escrow loan\\n */\\n function balanceOf(uint256 loanID, address token)\\n internal\\n view\\n returns (uint256)\\n {\\n return IERC20(token).balanceOf(address(e(loanID)));\\n }\\n\\n /**\\n * @notice Adds or removes tokens held by the Escrow contract\\n * @param loanID The loan ID to update the token list for\\n * @param tokenAddress The token address to be added or removed\\n */\\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\\n // Skip if is lending token\\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\\n\\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\\n if (balanceOf(loanID, tokenAddress) > 0) {\\n if (!contains) {\\n EnumerableSet.add(tokens, tokenAddress);\\n }\\n } else if (contains) {\\n EnumerableSet.remove(tokens, tokenAddress);\\n }\\n }\\n\\n /**\\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\\n * @param loanID The loan ID to calculate value for\\n * @return value_ Escrow total value denoted in the lending token.\\n */\\n function calculateTotalValue(uint256 loanID)\\n internal\\n view\\n returns (uint256 value_)\\n {\\n address lendingToken = LibLoans.loan(loanID).lendingToken;\\n value_ += balanceOf(loanID, lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\\n if (EnumerableSet.length(tokens) > 0) {\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n uint256 tokenBal =\\n balanceOf(loanID, EnumerableSet.at(tokens, i));\\n value_ += PriceAggLib.valueFor(\\n EnumerableSet.at(tokens, i),\\n lendingToken,\\n tokenBal\\n );\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x17a7c6b11d6f280948e320525d1e131b89c23f80216918aa070df437a851d915\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when a user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when a user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n * @return ERC20 token\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n * @return balance_ the balance of the account\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice It calculates the total supply of the underlying asset.\\n * @return totalSupply_ the total supply denoted in the underlying asset.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given market.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n \\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfill the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n * @return mintAmount_ the amount minted of the specified token\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n * @return address of the strategy contract\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n * @param state boolean value that resembles the platform's state\\n */\\n function restrict(bool state) external virtual;\\n\\n /**\\n * @notice it initializes the Teller Token\\n * @param admin address of the admin to the respective Teller Token\\n * @param underlying address of the ERC20 token\\n */\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xf30ac4ef491851477ff9a3dd04974ebe74b529c37a3ef4e05798c3f734ceeb3d\",\"license\":\"MIT\"},\"contracts/market/LoanDataFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { Loan, LoanDebt, LoanTerms } from \\\"../storage/market.sol\\\";\\n\\ncontract LoanDataFacet {\\n /**\\n * @notice Returns the information about the given {loanID}.\\n * @param loanID The loan ID to get information for.\\n * @return loan_ The loan data.\\n */\\n function getLoan(uint256 loanID) external view returns (Loan memory loan_) {\\n loan_ = LibLoans.s().loans[loanID];\\n }\\n\\n /**\\n * @notice DEPRECATED\\n * @notice Returns the terms for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanTerms The terms that the loan weer created with.\\n */\\n function getLoanTerms(uint256 loanID)\\n external\\n view\\n returns (LoanTerms memory)\\n {\\n return LibLoans.terms(loanID);\\n }\\n\\n /**\\n * @notice Returns the loan IDs created by the {borrower} account.\\n * @param borrower The account to get loan IDs for.\\n * @return loanIDs The IDs for loans created by the {borrower}\\n */\\n function getBorrowerLoans(address borrower)\\n external\\n view\\n returns (uint128[] memory loanIDs)\\n {\\n return LibLoans.s().borrowerLoans[borrower];\\n }\\n\\n /**\\n * @notice Returns the debt owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanDebt The principal and interest owed amount.\\n */\\n function getDebtOwed(uint256 loanID)\\n external\\n view\\n returns (LoanDebt memory)\\n {\\n return LibLoans.debt(loanID);\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) external view returns (uint256) {\\n return LibLoans.getTotalOwed(loanID);\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n external\\n view\\n returns (uint256)\\n {\\n return LibLoans.getInterestOwedFor(loanID, amountBorrow);\\n }\\n\\n /**\\n * @notice it returns the collateral needed for a loan\\n * @param loanID the identifier of the loan ID to retrieve collateral from\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n external\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n return LibLoans.getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the typed address of a loan escrow\\n * @param loanID the identifier of the respective escrow's loan\\n * @return escrow_ the typed address of the returned ILoanEscrow\\n */\\n function getLoanEscrow(uint256 loanID)\\n external\\n view\\n returns (address escrow_)\\n {\\n escrow_ = address(LibLoans.s().loanEscrows[loanID]);\\n }\\n\\n /**\\n * @notice it returns the escrow's total value by calculating the value all the escrow tokens\\n * @param loanID the identifier of the respective escrow's loan\\n * @return the total value of the loan escrow\\n */\\n function getLoanEscrowValue(uint256 loanID)\\n external\\n view\\n returns (uint256)\\n {\\n return LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n /**\\n * @notice it returns the total escrow tokens held by an escrow\\n * @param loanID the identifier of the respective escrow's loan\\n * @return tokens_ the tokens held at the escrow loan \\n */\\n function getEscrowTokens(uint256 loanID)\\n external\\n view\\n returns (address[] memory tokens_)\\n {\\n EnumerableSet.AddressSet storage escrowTokens =\\n LibEscrow.getEscrowTokens(loanID);\\n tokens_ = new address[](EnumerableSet.length(escrowTokens));\\n for (uint256 i; i < tokens_.length; i++) {\\n tokens_[i] = EnumerableSet.at(escrowTokens, i);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x9a57f5de00ce073af4ffb2f74e7d8a15e56bc017826f2c5a393ef5b64554145f\",\"license\":\"MIT\"},\"contracts/market/RepayFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\nimport {\\n ReentryMods\\n} from \\\"../contexts2/access-control/reentry/ReentryMods.sol\\\";\\nimport { AUTHORIZED } from \\\"../shared/roles.sol\\\";\\nimport { LoanDataFacet } from \\\"./LoanDataFacet.sol\\\";\\n\\n// Libraries\\nimport {\\n IERC20,\\n SafeERC20\\n} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibCollateral } from \\\"./libraries/LibCollateral.sol\\\";\\nimport { LibDapps } from \\\"../escrow/dapps/libraries/LibDapps.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { NumbersLib } from \\\"../shared/libraries/NumbersLib.sol\\\";\\nimport { PriceAggLib } from \\\"../price-aggregator/PriceAggLib.sol\\\";\\nimport { NFTLib } from \\\"../nft/libraries/NFTLib.sol\\\";\\n\\n// Interfaces\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus\\n} from \\\"../storage/market.sol\\\";\\n\\ncontract RepayFacet is RolesMods, ReentryMods, PausableMods {\\n /**\\n @notice This event is emitted when a loan has been successfully repaid\\n @param loanID ID of loan from which collateral was withdrawn\\n @param borrower Account address of the borrower\\n @param amountPaid Amount of the loan paid back\\n @param payer Account address of the payer\\n @param totalOwed Total amount of the loan to be repaid\\n */\\n event LoanRepaid(\\n uint256 indexed loanID,\\n address indexed borrower,\\n uint256 amountPaid,\\n address payer,\\n uint256 totalOwed\\n );\\n\\n /**\\n * @notice This event is emitted when a loan has been successfully liquidated\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param borrower Account address of the borrower\\n * @param liquidator Account address of the liquidator\\n * @param reward Value in lending token paid out to liquidator\\n * @param tokensIn Percentage of the collateral price paid by the liquidator to the lending pool\\n */\\n event LoanLiquidated(\\n uint256 indexed loanID,\\n address indexed borrower,\\n address liquidator,\\n uint256 reward,\\n uint256 tokensIn\\n );\\n\\n /**\\n * @notice Repay this Escrow's loan.\\n * @dev If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.\\n * @dev Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\\n * @param loanID The id of the loan being used.\\n * @param amount The amount being repaid.\\n */\\n function escrowRepay(uint256 loanID, uint256 amount)\\n external\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n nonReentry(\\\"\\\")\\n {\\n uint256 balance =\\n LibEscrow.balanceOf(loanID, LibLoans.loan(loanID).lendingToken);\\n uint256 totalOwed = LibLoans.getTotalOwed(loanID);\\n // if there isn't enough balance in the escrow, then transfer amount needed to the escrow\\n if (balance < totalOwed && amount > balance) {\\n uint256 amountNeeded =\\n amount > totalOwed ? totalOwed - (balance) : amount - (balance);\\n\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n msg.sender,\\n address(LibEscrow.e(loanID)),\\n amountNeeded\\n );\\n }\\n\\n __repayLoan(loanID, amount, address(LibEscrow.e(loanID)), false);\\n }\\n\\n /**\\n * @notice Make a payment to a loan\\n * @param loanID The ID of the loan the payment is for\\n * @param amount The amount of tokens to pay back to the loan\\n */\\n function repayLoan(uint256 loanID, uint256 amount)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n __repayLoan(loanID, amount, msg.sender, false);\\n }\\n\\n /**\\n * @notice it repays the loan, either from an escrow or from a regular address\\n * @param loanID the identifier of the loan to repay\\n * @param amount the amount to repay the loan\\n * @param sender the address of the sender that wants to pay, can also be a loan escrow\\n * @param isLiquidation is this loan being liquidated?\\n * @return leftToPay_ the amount left to pay for the loan\\n */\\n function __repayLoan(\\n uint256 loanID,\\n uint256 amount,\\n address sender,\\n bool isLiquidation\\n ) private returns (uint256 leftToPay_) {\\n require(amount > 0, \\\"Teller: zero repay\\\");\\n\\n // calculate the actual amount to repay\\n leftToPay_ =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n if (leftToPay_ < amount) {\\n amount = leftToPay_;\\n leftToPay_ = 0;\\n } else {\\n leftToPay_ -= amount;\\n }\\n\\n // Get the Teller token for the loan\\n ITToken tToken =\\n MarketStorageLib.store().tTokens[\\n LibLoans.loan(loanID).lendingToken\\n ];\\n // Transfer funds from an escrow if an escrow is calling it\\n // Otherwise, transfer funds from an account\\n if (address(LibEscrow.e(loanID)) == sender) {\\n LibEscrow.e(loanID).claimToken(\\n LibLoans.loan(loanID).lendingToken,\\n address(tToken),\\n amount\\n );\\n } else {\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n sender,\\n address(tToken),\\n amount\\n );\\n }\\n\\n // Deduct the interest and principal owed\\n uint256 principalPaid;\\n uint256 interestPaid;\\n if (amount < LibLoans.debt(loanID).interestOwed) {\\n interestPaid = amount;\\n LibLoans.debt(loanID).interestOwed -= amount;\\n } else {\\n if (LibLoans.debt(loanID).interestOwed > 0) {\\n interestPaid = LibLoans.debt(loanID).interestOwed;\\n amount -= interestPaid;\\n LibLoans.debt(loanID).interestOwed = 0;\\n }\\n\\n if (amount > 0) {\\n principalPaid = amount;\\n LibLoans.debt(loanID).principalOwed -= amount;\\n }\\n }\\n\\n // Tell the Teller Token value has been deposited back into the pool.\\n tToken.repayLoan(principalPaid, interestPaid);\\n\\n if (isLiquidation) {\\n // Make sure there is nothing left to repay on the loan\\n require(leftToPay_ == 0, \\\"Teller: liquidate partial repay\\\");\\n\\n // Set loan status\\n LibLoans.loan(loanID).status = LoanStatus.Liquidated;\\n\\n // Transfer NFT if linked\\n NFTLib.liquidateNFT(loanID);\\n } else {\\n // if the loan is now fully paid, close it and withdraw borrower collateral\\n if (leftToPay_ == 0) {\\n LibLoans.loan(loanID).status = LoanStatus.Closed;\\n LibCollateral.withdrawAll(\\n loanID,\\n LibLoans.loan(loanID).borrower\\n );\\n // Restake any NFTs linked to loan for borrower\\n NFTLib.restakeLinked(loanID, LibLoans.loan(loanID).borrower);\\n }\\n\\n emit LoanRepaid(\\n loanID,\\n LibLoans.loan(loanID).borrower,\\n amount,\\n msg.sender,\\n leftToPay_\\n );\\n }\\n }\\n\\n /**\\n * @notice Liquidate a loan if it is expired or under collateralized\\n * @param loanID The ID of the loan to be liquidated\\n */\\n function liquidateLoan(uint256 loanID)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n uint256 collateralAmount = LibCollateral.e(loanID).loanSupply(loanID);\\n require(\\n RepayLib.isLiquidable(loanID, collateralAmount),\\n \\\"Teller: does not need liquidation\\\"\\n );\\n\\n // Calculate the reward before repaying the loan\\n (uint256 rewardInLending, uint256 collateralInLending) =\\n RepayLib.getLiquidationReward(loanID, collateralAmount);\\n\\n // The liquidator pays the amount still owed on the loan\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n __repayLoan(loanID, amountToLiquidate, msg.sender, true);\\n\\n // Payout the liquidator reward owed\\n if (rewardInLending > 0) {\\n RepayLib.payOutLiquidator(\\n loanID,\\n rewardInLending,\\n collateralInLending,\\n collateralAmount,\\n payable(msg.sender)\\n );\\n }\\n\\n emit LoanLiquidated(\\n loanID,\\n loan.borrower,\\n msg.sender,\\n rewardInLending,\\n amountToLiquidate\\n );\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @return inLending_ The value the liquidator will receive denoted in lending tokens.\\n * @return inCollateral_ The value the liquidator will receive denoted in collateral tokens.\\n */\\n function getLiquidationReward(uint256 loanID)\\n external\\n view\\n returns (uint256 inLending_, uint256 inCollateral_)\\n {\\n (inLending_, ) = RepayLib.getLiquidationReward(\\n loanID,\\n LibCollateral.e(loanID).loanSupply(loanID)\\n );\\n inCollateral_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n inLending_\\n );\\n }\\n}\\n\\nlibrary RepayLib {\\n /**\\n * @notice It checks if a loan can be liquidated.\\n * @param loanID The loan ID to check.\\n * @return true if the loan is liquidable.\\n */\\n function isLiquidable(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (bool)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n // Check if loan can be liquidated\\n if (loan.status != LoanStatus.Active) {\\n return false;\\n }\\n\\n if (loan.collateralRatio > 0) {\\n // If loan has a collateral ratio, check how much is needed\\n (, uint256 neededInCollateral, ) =\\n LoanDataFacet(address(this)).getCollateralNeededInfo(loanID);\\n if (neededInCollateral > collateralAmount) {\\n return true;\\n }\\n }\\n\\n // Otherwise, check if the loan has expired\\n return block.timestamp >= loan.loanStartTime + loan.duration;\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @param collateralAmount The amount of collateral for the {loanID}. Passed in to save gas calling the collateral escrow multiple times.\\n * @return reward_ The value the liquidator will receive denoted in lending tokens.\\n */\\n function getLiquidationReward(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (uint256 reward_, uint256 collateralValue_)\\n {\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n // Max reward is amount repaid on loan plus extra percentage\\n uint256 maxReward =\\n amountToLiquidate +\\n NumbersLib.percent(\\n amountToLiquidate,\\n uint16(PlatformSettingsLib.getLiquidateRewardPercent())\\n );\\n\\n // Calculate available collateral for reward\\n if (collateralAmount > 0) {\\n collateralValue_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).collateralToken,\\n LibLoans.loan(loanID).lendingToken,\\n collateralAmount\\n );\\n reward_ += collateralValue_;\\n }\\n\\n // Calculate loan escrow value if collateral not enough to cover reward\\n if (reward_ < maxReward) {\\n reward_ += LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n // Cap the reward to max\\n if (reward_ > maxReward) {\\n reward_ = maxReward;\\n }\\n }\\n\\n /**\\n * @notice Checks if the loan has an Escrow and claims any tokens then pays out the loan collateral.\\n * @dev See Escrow.claimTokens for more info.\\n * @param loanID The loan ID which is being liquidated\\n * @param rewardInLending The total amount of reward based in the lending token to pay the liquidator\\n * @param collateralInLending The amount of collateral that is available for the loan denoted in lending tokens\\n * @param collateralAmount The amount of collateral that is available for the loan\\n * @param liquidator The address of the liquidator where the liquidation reward will be sent to\\n */\\n function payOutLiquidator(\\n uint256 loanID,\\n uint256 rewardInLending,\\n uint256 collateralInLending,\\n uint256 collateralAmount,\\n address payable liquidator\\n ) internal {\\n // check if loan is liquidated\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Liquidated,\\n \\\"Teller: loan not liquidated\\\"\\n );\\n\\n // if the lending reward is less than the collateral lending tokens, then aggregate\\n // the value for the lending token with the collateral token and send it to the liquidator\\n if (rewardInLending <= collateralInLending) {\\n uint256 rewardInCollateral =\\n PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n rewardInLending\\n );\\n\\n LibCollateral.withdraw(loanID, rewardInCollateral, liquidator);\\n } else {\\n // Payout whats available in the collateral token\\n LibCollateral.withdraw(loanID, collateralAmount, liquidator);\\n\\n // Claim remaining reward value from the loan escrow\\n claimEscrowTokensByValue(\\n loanID,\\n liquidator,\\n rewardInLending - collateralInLending\\n );\\n }\\n }\\n\\n /**\\n * @dev Send the equivalent of tokens owned by the loan escrow (in lending value) to the recipient,\\n * @param loanID The loan ID to clam tokens from\\n * @param recipient address to send the tokens to\\n * @param value The value of escrow held tokens to be claimed based in lending value\\n */\\n function claimEscrowTokensByValue(\\n uint256 loanID,\\n address recipient,\\n uint256 value\\n ) private {\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n uint256 valueLeftToTransfer = value;\\n\\n // Start with the lending token\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n LibLoans.loan(loanID).lendingToken,\\n recipient,\\n valueLeftToTransfer\\n );\\n\\n // Cycle through remaining tokens\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n if (valueLeftToTransfer == 0) {\\n return;\\n }\\n\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n EnumerableSet.at(tokens, i),\\n recipient,\\n valueLeftToTransfer\\n );\\n }\\n }\\n\\n /**\\n * @notice it claims the escrow tokens for the liquidator\\n * @notice it keeps claiming escrow tokens until there aren't anymore tokens or the valueLeftToTransfer is zero\\n * @param loanID the identifier of the escrow loan to claim tokens from\\n * @param token the address of the token asset to claim\\n * @param recipient the address of the recipient to transfer the tokens to\\n * @param valueLeftToTransfer the value left to transfer to the liquidator that is returned back\\n * @return the value left to transfer\\n */\\n function claimEscrowToken(\\n uint256 loanID,\\n address token,\\n address recipient,\\n uint256 valueLeftToTransfer\\n ) private returns (uint256) {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n // get value of token balance in lending value\\n if (balance > 0) {\\n // If token not the lending token, get value of token\\n uint256 balanceInLending;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n balanceInLending = balance;\\n } else {\\n balanceInLending = PriceAggLib.valueFor(\\n token,\\n LibLoans.loan(loanID).lendingToken,\\n balance\\n );\\n }\\n\\n if (balanceInLending <= valueLeftToTransfer) {\\n LibEscrow.e(loanID).claimToken(token, recipient, balance);\\n valueLeftToTransfer -= balanceInLending;\\n } else {\\n // Token balance is more than enough so calculate ratio of balance to transfer\\n uint256 valueToTransfer;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n valueToTransfer = valueLeftToTransfer;\\n } else {\\n valueToTransfer = NumbersLib.percent(\\n balance,\\n NumbersLib.ratioOf(\\n valueLeftToTransfer,\\n balanceInLending\\n )\\n );\\n }\\n\\n LibEscrow.e(loanID).claimToken(\\n token,\\n recipient,\\n valueToTransfer\\n );\\n valueLeftToTransfer = 0;\\n }\\n }\\n return valueLeftToTransfer;\\n }\\n}\\n\",\"keccak256\":\"0x4cc90a273ddbcfc983b98bd42c18990526a79488c972926952d38f26ff69cabb\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n /**\\n * @notice it initializes an escrow\\n * @param tokenAddress the address of the collateral token to be stored\\n * @param isWETH check if it's wrapped Ethereum\\n */\\n function init(address tokenAddress, bool isWETH) external;\\n\\n /**\\n * @notice it deposits an amount of the respective collateral token into the escrow\\n * @param loanID the ID of the loan\\n * @param amount the amount of collateral tokens to be deposited\\n */\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n /**\\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\\n * @dev only the TellerDiamond can make this call on behalf of the borrower\\n * @param loanID identifier of the loan\\n * @param amount number of collateral tokens to send\\n * @param receiver payable address to transfer money to\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n /**\\n * @notice it returns the supply of the respective loan\\n * @param loanID the respective loan ID\\n * @return supply_ the amount in collateral of the respective loan\\n */\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n /**\\n * @notice it returns the total supply of the collateral token held by the contract\\n * @return supply_ the total amount of collateral\\n */\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x900fed2311f919ba1451a6583ddbf9f3bc8afa8f5189500fff51f0c049258ed3\",\"license\":\"MIT\"},\"contracts/market/libraries/LibCollateral.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport { ICollateralEscrow } from \\\"../collateral/ICollateralEscrow.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\nimport { MarketStorageLib } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibCollateral {\\n /**\\n * @notice This event is emitted when collateral has been deposited for the loan\\n * @param loanID ID of the loan for which collateral was deposited\\n * @param depositor Account that deposited funds\\n * @param amount Amount of collateral deposited\\n */\\n event CollateralDeposited(\\n uint256 indexed loanID,\\n address indexed depositor,\\n uint256 amount\\n );\\n\\n /**\\n * @notice This event is emitted when collateral has been withdrawn\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param receiver Account that received funds\\n * @param amount Value of collateral withdrawn\\n */\\n event CollateralWithdrawn(\\n uint256 indexed loanID,\\n address indexed receiver,\\n uint256 amount\\n );\\n\\n /**\\n * @notice it gets MarketStorage's collateral escrow using the loanID\\n * @param loanID the loanID to be used\\n * @return c_ which is the collateral escrow\\n */\\n function e(uint256 loanID) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[\\n MarketStorageLib.store().loans[loanID].collateralToken\\n ];\\n }\\n\\n function e(address token) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[token];\\n }\\n\\n /**\\n * @notice it deposits an amount of collateral into a collateral escrow's address of a respective loan\\n * @param loanID the respective loan ID\\n * @param amount the amount of collateral to deposit\\n */\\n function deposit(uint256 loanID, uint256 amount) internal {\\n e(loanID).deposit{ value: amount }(loanID, amount);\\n\\n emit CollateralDeposited(loanID, msg.sender, amount);\\n }\\n\\n /**\\n * @notice it withdraws an amount from the collateral escrow\\n * @param loanID the respective loanID to withdraw from\\n * @param amount the number of collateral tokens to withdraw\\n * @param receiver the address who receives the withdrawal\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) internal {\\n e(loanID).withdraw(loanID, amount, receiver);\\n\\n emit CollateralWithdrawn(loanID, receiver, amount);\\n }\\n\\n /**\\n * @notice it withdraws the entire supply in collateral of a respective loan to an address\\n * @param loanID the respective loan's ID\\n * @param receiver the address of the receiver to withdraw tokens from\\n */\\n function withdrawAll(uint256 loanID, address payable receiver) internal {\\n withdraw(loanID, e(loanID).loanSupply(loanID), receiver);\\n }\\n\\n /**\\n * @notice it initializes a new escrow collateral to hold collateral tokens\\n * @param token address of the collateral token it holds\\n */\\n function createEscrow(address token) internal {\\n // Check if collateral escrow exists\\n if (address(e(token)) == address(0)) {\\n // Create escrow\\n address escrow =\\n AppStorageLib.store().collateralEscrowBeacon.cloneProxy(\\\"\\\");\\n ICollateralEscrow(escrow).init(\\n token,\\n // Check if collateral token is WETH\\n token == AppStorageLib.store().assetAddresses[\\\"WETH\\\"]\\n );\\n\\n // Set max allowance\\n IERC20(token).approve(escrow, type(uint256).max);\\n // Save escrow address for loan\\n MarketStorageLib.store().collateralEscrows[\\n token\\n ] = ICollateralEscrow(escrow);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x84dbab8283357a1cc4210e34642fc8247841a58973778f4f6570398cc3046947\",\"license\":\"MIT\"},\"contracts/market/libraries/LibLoans.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibEscrow } from \\\"../../escrow/libraries/LibEscrow.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus,\\n LoanDebt,\\n LoanTerms\\n} from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibLoans {\\n using NumbersLib for int256;\\n using NumbersLib for uint256;\\n\\n bytes32 internal constant ID = keccak256(\\\"LOANS\\\");\\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n * @notice it returns the loan\\n * @param loanID the ID of the respective loan\\n * @return l_ the loan \\n */\\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\\n l_ = s().loans[loanID];\\n }\\n\\n /**\\n * @notice it returns the loan debt from a respective loan\\n * @param loanID the ID of the respective loan\\n * @return d_ the loan debt from a respective loan\\n */\\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\\n d_ = s().loanDebt[loanID];\\n }\\n\\n // DEPRECATED\\n function terms(uint256 loanID)\\n internal\\n view\\n returns (LoanTerms storage t_)\\n {\\n t_ = s()._loanTerms[loanID];\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return owed_ uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID)\\n internal\\n view\\n returns (uint256 owed_)\\n {\\n if (loan(loanID).status == LoanStatus.Active) {\\n owed_ = debt(loanID).principalOwed + (debt(loanID).interestOwed);\\n }\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n internal\\n view\\n returns (uint256)\\n {\\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\\n }\\n \\n function getCollateralNeeded(uint256 loanID)\\n internal\\n view\\n returns (uint256 _needed)\\n {\\n (, _needed, ) = getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the total collateral needed in lending tokens, in collateral tokens and in escrowed loan values\\n * @param loanID the loanID to get the total collateral needed\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n internal\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\\n loanID\\n );\\n\\n // check if needed lending tokens is zero. if true, then needed collateral tokens is zero. else,\\n if (neededInLendingTokens == 0) {\\n neededInCollateralTokens = 0;\\n } else {\\n neededInCollateralTokens = PriceAggLib.valueFor(\\n loan(loanID).lendingToken,\\n loan(loanID).collateralToken,\\n neededInLendingTokens\\n );\\n }\\n }\\n\\n /**\\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\\n * @param loanID The loan ID to get needed collateral info for.\\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\\n */\\n function getCollateralNeededInTokens(uint256 loanID)\\n internal\\n view\\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\\n {\\n if (loan(loanID).collateralRatio == 0) {\\n return (0, 0);\\n }\\n\\n /*\\n The collateral to principal owed ratio is the sum of:\\n * collateral buffer percent\\n * loan interest rate\\n * liquidation reward percent\\n * X factor of additional collateral\\n */\\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n neededInLendingTokens = loan(loanID).borrowedAmount.percent(\\n loan(loanID).collateralRatio\\n );\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n uint16 requiredRatio =\\n loan(loanID).collateralRatio -\\n getInterestRatio(loanID) -\\n uint16(PlatformSettingsLib.getCollateralBufferValue());\\n\\n neededInLendingTokens =\\n debt(loanID).principalOwed +\\n debt(loanID).interestOwed;\\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\\n if (\\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\\n ) {\\n neededInLendingTokens -= escrowLoanValue;\\n }\\n neededInLendingTokens = neededInLendingTokens.percent(\\n requiredRatio\\n );\\n }\\n }\\n\\n /**\\n * @notice check if a loan can go to end of auction with a collateral ratio\\n * @return bool checking if collateralRatio is >= the over collateralized buffer value\\n */\\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\\n internal\\n view\\n returns (bool)\\n {\\n return\\n collateralRatio >=\\n PlatformSettingsLib.getOverCollateralizedBufferValue();\\n }\\n\\n /**\\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\\n * @notice There is a minimum threshold of 1%.\\n * @dev The interest rate is APY (annual percentage yield).\\n * @param loanID The loan ID to get the interest rate for.\\n */\\n function getInterestRatio(uint256 loanID)\\n internal\\n view\\n returns (uint16 ratio_)\\n {\\n ratio_ = uint16(\\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\\n SECONDS_PER_YEAR\\n );\\n\\n if (ratio_ == 0) {\\n ratio_ = 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0xe48b287a583b40e534654e4023422f59a9e6d7dd265d68ae4af43f8da58c09d9\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice it returns the current token index to use as a counter\\n * @return counter_ the current token index\\n */\\n function getCurrentTokenIndex() external view returns (uint256 counter_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x8a6979965f9d275eff9e034f207d605d7eb3506245de3604d2e02acc8196c2a6\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice it returns the current token index to use as a counter\\n * @return counter_ the current token index\\n */\\n function getCurrentTokenIndex()\\n external\\n view\\n override\\n returns (uint256 counter_)\\n {\\n counter_ = _tokenCounter.current();\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf42808068c07aa015fcf4a2922fb91cfb456a2f6c8fcfa6daa08b2dfbedf8817\",\"license\":\"MIT\"},\"contracts/nft/libraries/NFTLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../TellerNFT.sol\\\";\\n\\n// Libraries\\nimport {\\n MerkleProof\\n} from \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\nimport { NFTStorageLib, NFTStorage } from \\\"../../storage/nft.sol\\\";\\n\\nstruct NftLoanSizeProof {\\n uint256 id;\\n uint256 baseLoanSize;\\n bytes32[] proof;\\n}\\n\\nlibrary NFTLib {\\n function s() internal pure returns (NFTStorage storage s_) {\\n s_ = NFTStorageLib.store();\\n }\\n\\n function nft() internal view returns (TellerNFT nft_) {\\n nft_ = AppStorageLib.store().nft;\\n }\\n\\n /**s\\n * @notice it transfers the NFT from the sender to the diamond to stake then adds the NFTID to the list of the owner's stakedNFTs\\n * @param nftID the ID of the NFT to stake\\n * @param owner the owner of the NFT who will stake the NFT\\n */\\n function stake(uint256 nftID, address owner) internal {\\n // Transfer to diamond\\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\\n // Add NFT ID to user set\\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\\n }\\n\\n /**\\n * @notice it unstakes the NFT by removing the NFT ID from the list of the user's staked NFTs\\n * @param nftID the ID of the NFT to remove from the list of the user's staked NFTs\\n * @return success_ the boolean value telling us if the user has unsuccessfully unstaked the NFT\\n */\\n function unstake(uint256 nftID) internal returns (bool success_) {\\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\\n }\\n\\n /**\\n * @notice it gets the list of staked NFTs from the owner\\n * @param nftOwner the owner of the staked NFTs to pull from\\n * @return staked_ the array of the staked NFTs owned by the user\\n */\\n function stakedNFTs(address nftOwner)\\n internal\\n view\\n returns (uint256[] memory staked_)\\n {\\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\\n staked_ = new uint256[](EnumerableSet.length(nfts));\\n for (uint256 i; i < staked_.length; i++) {\\n staked_[i] = EnumerableSet.at(nfts, i);\\n }\\n }\\n\\n /**\\n * @notice if the user fails to pay his loan, then we liquidate the all the NFTs associated with the loan\\n * @param loanID the identifier of the loan to liquidate the NFTs from\\n */\\n function liquidateNFT(uint256 loanID) internal {\\n // Check if NFTs are linked\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n NFTLib.nft().transferFrom(\\n address(this),\\n AppStorageLib.store().nftLiquidationController,\\n EnumerableSet.at(nfts, i)\\n );\\n }\\n }\\n\\n /**\\n * @notice it unstakes an NFT and verifies the proof in order to apply the proof to a loan\\n * @param loanID the identifier of the loan\\n * @param proof the proof to be attached to a loan after verifying the loan size\\n */\\n function applyToLoan(uint256 loanID, NftLoanSizeProof calldata proof)\\n internal\\n {\\n // NFT must be currently staked\\n // Remove NFT from being staked - returns bool\\n require(unstake(proof.id), \\\"Teller: borrower nft not staked\\\");\\n\\n require(verifyLoanSize(proof), \\\"Teller invalid nft proof\\\");\\n\\n // Apply NFT to loan\\n EnumerableSet.add(s().loanNFTs[loanID], proof.id);\\n }\\n\\n /**\\n * @notice it finds the loan's NFTs and adds them back to the owner's list of staked NFTs\\n * @param loanID the identifier of the respective loan to add the NFTs back to the user's staked NFTs\\n * @param owner the owner to add the unstaked NFTs back to the staked pile\\n */\\n function restakeLinked(uint256 loanID, address owner) internal {\\n // Get linked NFT\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n // Restake the NFT\\n EnumerableSet.add(s().stakedNFTs[owner], EnumerableSet.at(nfts, i));\\n }\\n }\\n\\n /**\\n * @notice it verifies the NFT id to base loan size using the merkle proof\\n * @param proof the NFTLoanSizeProof to verify with the nft;s merkle root\\n * @return verified_ tells us if the loan is verified or not\\n */\\n function verifyLoanSize(NftLoanSizeProof calldata proof)\\n internal\\n view\\n returns (bool verified_)\\n {\\n verified_ = MerkleProof.verify(\\n proof.proof,\\n s().nftMerkleRoot,\\n keccak256(abi.encodePacked(proof.id, proof.baseLoanSize))\\n );\\n }\\n}\\n\",\"keccak256\":\"0x05effea10b3d191192b3b8f5515c2b083d2a8a80c1fae19c6a1abce53d8635fa\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n /**\\n * @notice it returns 10^{numberOfDecimals} for a token\\n * @param token the address to calculate the decimals for\\n * @return 10^number of decimals used to calculate the price and value of different token pairs\\n */\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @notice It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @notice it tries to calculate a price from Compound and Chainlink.\\n * @dev if no price is found on compound, then calculate it on chainlink\\n * @param src the token address to calculate the price for in dst\\n * @param dst the token address to retrieve the price of src\\n * @return price_ the price of src in dst\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n * @param src the address of the src token\\n * @param dst the address of the dst token\\n * @return the price of the src token in dst token\\n\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n * @param src the source token to calculate price for with chainlink\\n * @param dst the destination token to calculate price for with chainlink\\n * @param cRate the compound rate to multiply with the price of the dst token\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @notice Scales the {value} by the difference in decimal values.\\n * @param value the the value of the src in dst\\n * @param srcDecimals src token decimals\\n * @param dstDecimals dst token decimals\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @notice it tries to calculate the price of {src} in {dst}\\n * @param src address of source token\\n * @param dst address of destination token\\n * @return the price of src token in dst\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address WETH = AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n if (dst != WETH) {\\n int256 price1 = _priceFor(src, WETH);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, WETH);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice it checks if a token is a cToken. If it is, then get the underlying address\\n * @param token address of the token\\n * @return isCToken boolean whether it's a cToken\\n * @return underlying the address of the cToken\\n */\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2efb3d71a1c0fb49f8c455c4fa30d04c69a1617d619035fc400dabdeb2ab0c9e\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { PriceAggFacet } from \\\"./PriceAggFacet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\n/**\\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\\n */\\nlibrary PriceAggLib {\\n /**\\n * @notice It calculates the value of one token amount into another\\n * @param src the source token\\n * @param dst the destination token\\n * @param srcAmount the amount of source token\\n * @return value_ the returned value of src in dst\\n */\\n function valueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) internal view returns (uint256 value_) {\\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\\n }\\n\\n /**\\n * @notice It returns the price of the token pair as given from Compound.\\n * @dev if no compound price is calculated, then it checks Chainlink price Aggregator\\n * @param src the address of the source token\\n * @param dst the address of the desitnation token\\n * @return price_ gets the price of src in dst\\n */\\n function priceFor(address src, address dst)\\n internal\\n view\\n returns (int256 price_)\\n {\\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\\n }\\n}\\n\",\"keccak256\":\"0xff59eee567fa4a7f5cac432e31d918be92834f04614f49572d3984a5b030ac79\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\nabstract contract PausableMods {\\n /**\\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\\n * @param id id of the facet to check if is paused.\\n * @param state Boolean that the protocol AND facet should be in.\\n */\\n modifier paused(bytes32 id, bool state) {\\n require(\\n __isPaused(\\\"\\\") == state && __isPaused(id) == state,\\n __pausedMessage(state)\\n );\\n _;\\n }\\n\\n /**\\n * @dev Checks if the given id is paused.\\n * @param id Encoded id of the facet to check if is paused.\\n * @return the bool to tell us if the facet is paused (true) or not (false)\\n */\\n function __isPaused(bytes32 id) private view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n\\n /**\\n * @dev Gets the message that should be reverted with given a state it should be in.\\n * @param state Boolean that an id should be in.\\n * @return a message stating whether the facet is paused or not\\n */\\n function __pausedMessage(bool state) private pure returns (string memory) {\\n return state ? \\\"Pausable: not paused\\\" : \\\"Pausable: paused\\\";\\n }\\n}\\n\",\"keccak256\":\"0x2d3f848ee56ae5fa365539c2509c03c167affc89c89f98bb98cb9b83fbe8ae4c\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0xbeef1937dc1ed1f6f78b80f0737f018565ab264184cf05ef54c3c28ecd55a09b\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xacf6bcb8c4afd2f337a0161e8be64b016c1b350d336cd862245dd922fcd10f33\",\"license\":\"MIT\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n /**\\n * @notice Checks if the account should be allowed to mint tokens in the given market\\n * @param cToken The market to verify the mint against\\n * @param minter The account which would get the minted tokens\\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates mint and reverts on rejection. May emit logs.\\n * @param cToken Asset being minted\\n * @param minter The address minting the tokens\\n * @param mintAmount The amount of the underlying asset being minted\\n * @param mintTokens The number of tokens being minted\\n */\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to redeem tokens in the given market\\n * @param cToken The market to verify the redeem against\\n * @param redeemer The account which would redeem the tokens\\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates redeem and reverts on rejection. May emit logs.\\n * @param cToken Asset being redeemed\\n * @param redeemer The address redeeming the tokens\\n * @param redeemAmount The amount of the underlying asset being redeemed\\n * @param redeemTokens The number of tokens being redeemed\\n */\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\\n * @param cToken The market to verify the borrow against\\n * @param borrower The account which would borrow the asset\\n * @param borrowAmount The amount of underlying the account would borrow\\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates borrow and reverts on rejection. May emit logs.\\n * @param cToken Asset whose underlying is being borrowed\\n * @param borrower The address borrowing the underlying\\n * @param borrowAmount The amount of the underlying asset requested to borrow\\n */\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to repay a borrow in the given market\\n * @param cToken The market to verify the repay against\\n * @param payer The account which would repay the asset\\n * @param borrower The account which would borrowed the asset\\n * @param repayAmount The amount of the underlying asset the account would repay\\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\\n * @param cToken Asset being repaid\\n * @param payer The address repaying the borrow\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param borrowerIndex the index of the borrower\\n */\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n /**\\n * @notice Checks if the liquidation should be allowed to occur\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n */\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the seizing of assets should be allowed to occur\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates seize and reverts on rejection. May emit logs.\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to transfer tokens in the given market\\n * @param cToken The market to verify the transfer against\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates transfer and reverts on rejection. May emit logs.\\n * @param cToken Asset being transferred\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n */\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in all markets\\n * @param holder The address to claim COMP for\\n */\\n function claimComp(address holder) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in the specified markets\\n * @param holder The address to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n */\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n /**\\n * @notice Claim all comp accrued by the holders\\n * @param holders The addresses to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n * @param borrowers Whether or not to claim COMP earned by borrowing\\n * @param suppliers Whether or not to claim COMP earned by supplying\\n */\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n /**\\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\\n * @param cTokenBorrowed The address of the borrowed cToken\\n * @param cTokenCollateral The address of the collateral cToken\\n * @param repayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\\n */\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n /**\\n * @notice Return the address of the COMP token\\n * @return The address of COMP\\n */\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x38a824a4a21ce9370fa581a616d1bb9d311f27d8982a6b96ebeba90bd5fd0adb\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n \\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x37849041e4bee2dfa825677f69078521fcc94804aa5120f67dd12cc4133efcec\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @dev CETH is the only Compound token that does not support the {underlying} function.\\n * @param cToken address of the compound token\\n * @return address of the underlying cToken\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x99206384c27b0e68b1ec7b82260f6a47965f611875c018bc076ff8a688a6c6d7\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n /**\\n * @notice it returns the absolute number of a specified parameter\\n * @param self the number to be returned in it's absolute \\n * @return the absolute number\\n */\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0xa852b8866a3d6d928c6575bf2bcf2ae784eed73717c78c0cadbdedf8b0ba3274\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0c52fdd76b33f74e233c3a27dd3b73b134e9643aab347b3aa649c504809c6559\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\n// DEPRECATED\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\nstruct LoanRequest {\\n LoanUserRequest request;\\n LoanConsensusResponse[] responses;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanUserRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanConsensusResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) _loanTerms; // DEPRECATED: DO NOT REMOVE\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb7e05aeec806b5621512def93f4a389b4ef88c50ef9fe7115a33f57db2f2304b\",\"license\":\"MIT\"},\"contracts/storage/nft.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Utils\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct NFTStorage {\\n // Maps NFT owner to set of token IDs owned\\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\\n // Maps loanID to NFT IDs indicating NFT being used for the loan\\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\\n // Merkle root used for verifying nft IDs to base loan size\\n bytes32 nftMerkleRoot;\\n}\\n\\nbytes32 constant NFT_STORAGE_POS = keccak256(\\\"teller.staking.storage\\\");\\n\\nlibrary NFTStorageLib {\\n function store() internal pure returns (NFTStorage storage s) {\\n bytes32 pos = NFT_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\",\"keccak256\":\"0x09f8baabf2668e42e0554da99fda42f661e959f94645c2875e15585826a3a6e4\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "history": [ + { + "address": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "RepayFacet", + "transactionHash": "0x44d6b974ec21f1c4420ecb2be53506c60d1abe4b5fac2a2b5352ae4a3fb3bb5d", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "transactionIndex": 0, + "gasUsed": "1838004", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xecd0c4fcd32a0e212c29bf1a50f9095c4551299b06f40b8cb32c08eeeb3ab526", + "transactionHash": "0x44d6b974ec21f1c4420ecb2be53506c60d1abe4b5fac2a2b5352ae4a3fb3bb5d", + "logs": [], + "blockNumber": 25103793, + "cumulativeGasUsed": "1838004", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "dc3b3c0336b59a4fae33a8cd036a81b5", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"liquidator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"reward\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokensIn\",\"type\":\"uint256\"}],\"name\":\"LoanLiquidated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountPaid\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"totalOwed\",\"type\":\"uint256\"}],\"name\":\"LoanRepaid\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"escrowRepay\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLiquidationReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"inLending_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"inCollateral_\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"liquidateLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"repayLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"params\":{\"borrower\":\"Account address of the borrower\",\"liquidator\":\"Account address of the liquidator\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"reward\":\"Value in lending token paid out to liquidator\",\"tokensIn\":\"Percentage of the collateral price paid by the liquidator to the lending pool\"}},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"params\":{\"amountPaid\":\"Amount of the loan paid back\",\"borrower\":\"Account address of the borrower\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"payer\":\"Account address of the payer\",\"totalOwed\":\"Total amount of the loan to be repaid\"}}},\"kind\":\"dev\",\"methods\":{\"escrowRepay(uint256,uint256)\":{\"details\":\"If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\",\"params\":{\"amount\":\"The amount being repaid.\",\"loanID\":\"The id of the loan being used.\"}},\"getLiquidationReward(uint256)\":{\"params\":{\"loanID\":\"The loan ID to get the info.\"},\"returns\":{\"inCollateral_\":\"The value the liquidator will receive denoted in collateral tokens.\",\"inLending_\":\"The value the liquidator will receive denoted in lending tokens.\"}},\"liquidateLoan(uint256)\":{\"params\":{\"loanID\":\"The ID of the loan to be liquidated\"}},\"repayLoan(uint256,uint256)\":{\"params\":{\"amount\":\"The amount of tokens to pay back to the loan\",\"loanID\":\"The ID of the loan the payment is for\"}}},\"version\":1},\"userdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully liquidated\"},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully repaid\"}},\"kind\":\"user\",\"methods\":{\"escrowRepay(uint256,uint256)\":{\"notice\":\"Repay this Escrow's loan.\"},\"getLiquidationReward(uint256)\":{\"notice\":\"It gets the current liquidation reward for a given loan.\"},\"liquidateLoan(uint256)\":{\"notice\":\"Liquidate a loan if it is expired or under collateralized\"},\"repayLoan(uint256,uint256)\":{\"notice\":\"Make a payment to a loan\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/market/RepayFacet.sol\":\"RepayFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Trees proofs.\\n *\\n * The proofs can be generated using the JavaScript library\\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\\n *\\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n bytes32 computedHash = leaf;\\n\\n for (uint256 i = 0; i < proof.length; i++) {\\n bytes32 proofElement = proof[i];\\n\\n if (computedHash <= proofElement) {\\n // Hash(current computed hash + current element of the proof)\\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\\n } else {\\n // Hash(current element of the proof + current computed hash)\\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\\n }\\n }\\n\\n // Check if the computed hash (root) is equal to the provided root\\n return computedHash == root;\\n }\\n}\\n\",\"keccak256\":\"0xeee34bfb413657b6cd6c8e1e15c2080ba5ebaac479578515922804346fb63f7c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/reentry/ReentryMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nabstract contract ReentryMods {\\n modifier nonReentry(bytes32 id) {\\n AccessControlStorage storage s = AccessControlStorageLib.store();\\n require(!s.entered[id], \\\"AccessControl: reentered\\\");\\n s.entered[id] = true;\\n _;\\n s.entered[id] = false;\\n }\\n}\\n\",\"keccak256\":\"0x033c1164af25ef7d35a38a60973bf379b1cc603596914ffd85dcbcf0acdb6970\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../interfaces/IAToken.sol\\\";\\nimport { IAaveLendingPool } from \\\"../interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x8030b206c87d0073fb7dbebfa2ee8a3e93c479d976d6cdaa0c939f2fedaa1525\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n function setTokenAllowance(address token, address spender) external;\\n\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xdaa338698014e6c00edf7a2aca49026a047e253cbe7fc392a73f5f63a063a7f9\",\"license\":\"MIT\"},\"contracts/escrow/libraries/LibEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibDapps } from \\\"../dapps/libraries/LibDapps.sol\\\";\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibEscrow {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\\n e_ = s().loanEscrows[loanID];\\n }\\n\\n function getEscrowTokens(uint256 loanID)\\n internal\\n view\\n returns (EnumerableSet.AddressSet storage t_)\\n {\\n t_ = s().escrowTokens[loanID];\\n }\\n\\n function balanceOf(uint256 loanID, address token)\\n internal\\n view\\n returns (uint256)\\n {\\n return IERC20(token).balanceOf(address(e(loanID)));\\n }\\n\\n /**\\n * @notice Adds or removes tokens held by the Escrow contract\\n * @param loanID The loan ID to update the token list for\\n * @param tokenAddress The token address to be added or removed\\n */\\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\\n // Skip if is lending token\\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\\n\\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\\n if (balanceOf(loanID, tokenAddress) > 0) {\\n if (!contains) {\\n EnumerableSet.add(tokens, tokenAddress);\\n }\\n } else if (contains) {\\n EnumerableSet.remove(tokens, tokenAddress);\\n }\\n }\\n\\n /**\\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\\n * @param loanID The loan ID to calculate value for\\n * @return value_ Escrow total value denoted in the lending token.\\n */\\n function calculateTotalValue(uint256 loanID)\\n internal\\n view\\n returns (uint256 value_)\\n {\\n address lendingToken = LibLoans.loan(loanID).lendingToken;\\n value_ += balanceOf(loanID, lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\\n if (EnumerableSet.length(tokens) > 0) {\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n uint256 tokenBal =\\n balanceOf(loanID, EnumerableSet.at(tokens, i));\\n value_ += PriceAggLib.valueFor(\\n EnumerableSet.at(tokens, i),\\n lendingToken,\\n tokenBal\\n );\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xcca97599fff1c1bd608e7f11c4674f325e43781794e91bf5322ac9e0ffd7b3df\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when an user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when an user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @return totalSupply_ The total value of the underlying token managed by the LP.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given markets.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider o the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfil the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n */\\n function restrict(bool state) external virtual;\\n\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xe6515c78e0277edbed82aa6926df727afd216379dd0bfbbb790222654c858499\",\"license\":\"MIT\"},\"contracts/market/LoanDataFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { Loan, LoanDebt, LoanTerms } from \\\"../storage/market.sol\\\";\\n\\ncontract LoanDataFacet {\\n /**\\n * @notice Returns the information about the given {loanID}.\\n * @param loanID The loan ID to get information for.\\n * @return loan_ The loan data.\\n */\\n function getLoan(uint256 loanID) external view returns (Loan memory loan_) {\\n loan_ = LibLoans.s().loans[loanID];\\n }\\n\\n /**\\n * @notice Returns the terms for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanTerms The terms that the loan weer created with.\\n */\\n function getLoanTerms(uint256 loanID)\\n external\\n view\\n returns (LoanTerms memory)\\n {\\n return LibLoans.terms(loanID);\\n }\\n\\n /**\\n * @notice Returns the loan IDs created by the {borrower} account.\\n * @param borrower The account to get loan IDs for.\\n * @return loanIDs The IDs for loans created by the {borrower}\\n */\\n function getBorrowerLoans(address borrower)\\n external\\n view\\n returns (uint128[] memory loanIDs)\\n {\\n return LibLoans.s().borrowerLoans[borrower];\\n }\\n\\n /**\\n * @notice Returns the debt owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanDebt The principal and interest owed amount.\\n */\\n function getDebtOwed(uint256 loanID)\\n external\\n view\\n returns (LoanDebt memory)\\n {\\n return LibLoans.debt(loanID);\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) external view returns (uint256) {\\n return LibLoans.getTotalOwed(loanID);\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n external\\n view\\n returns (uint256)\\n {\\n return LibLoans.getInterestOwedFor(loanID, amountBorrow);\\n }\\n\\n function getCollateralNeededInfo(uint256 loanID)\\n external\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n return LibLoans.getCollateralNeededInfo(loanID);\\n }\\n\\n function getLoanEscrow(uint256 loanID)\\n external\\n view\\n returns (address escrow_)\\n {\\n escrow_ = address(LibLoans.s().loanEscrows[loanID]);\\n }\\n\\n function getLoanEscrowValue(uint256 loanID)\\n external\\n view\\n returns (uint256)\\n {\\n return LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n function getEscrowTokens(uint256 loanID)\\n external\\n view\\n returns (address[] memory tokens_)\\n {\\n EnumerableSet.AddressSet storage escrowTokens =\\n LibEscrow.getEscrowTokens(loanID);\\n tokens_ = new address[](EnumerableSet.length(escrowTokens));\\n for (uint256 i; i < tokens_.length; i++) {\\n tokens_[i] = EnumerableSet.at(escrowTokens, i);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf589a2afff647e5288e15f3f6614135395562b4d12c743402a6504a3fb9b39d6\",\"license\":\"MIT\"},\"contracts/market/RepayFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\nimport {\\n ReentryMods\\n} from \\\"../contexts2/access-control/reentry/ReentryMods.sol\\\";\\nimport { AUTHORIZED } from \\\"../shared/roles.sol\\\";\\nimport { LoanDataFacet } from \\\"./LoanDataFacet.sol\\\";\\n\\n// Libraries\\nimport {\\n IERC20,\\n SafeERC20\\n} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibCollateral } from \\\"./libraries/LibCollateral.sol\\\";\\nimport { LibDapps } from \\\"../escrow/dapps/libraries/LibDapps.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { NumbersLib } from \\\"../shared/libraries/NumbersLib.sol\\\";\\nimport { PriceAggLib } from \\\"../price-aggregator/PriceAggLib.sol\\\";\\nimport { NFTLib } from \\\"../nft/libraries/NFTLib.sol\\\";\\n\\n// Interfaces\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus\\n} from \\\"../storage/market.sol\\\";\\n\\ncontract RepayFacet is RolesMods, ReentryMods, PausableMods {\\n /**\\n @notice This event is emitted when a loan has been successfully repaid\\n @param loanID ID of loan from which collateral was withdrawn\\n @param borrower Account address of the borrower\\n @param amountPaid Amount of the loan paid back\\n @param payer Account address of the payer\\n @param totalOwed Total amount of the loan to be repaid\\n */\\n event LoanRepaid(\\n uint256 indexed loanID,\\n address indexed borrower,\\n uint256 amountPaid,\\n address payer,\\n uint256 totalOwed\\n );\\n\\n /**\\n * @notice This event is emitted when a loan has been successfully liquidated\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param borrower Account address of the borrower\\n * @param liquidator Account address of the liquidator\\n * @param reward Value in lending token paid out to liquidator\\n * @param tokensIn Percentage of the collateral price paid by the liquidator to the lending pool\\n */\\n event LoanLiquidated(\\n uint256 indexed loanID,\\n address indexed borrower,\\n address liquidator,\\n uint256 reward,\\n uint256 tokensIn\\n );\\n\\n /**\\n * @notice Repay this Escrow's loan.\\n * @dev If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.\\n * @dev Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\\n * @param loanID The id of the loan being used.\\n * @param amount The amount being repaid.\\n */\\n function escrowRepay(uint256 loanID, uint256 amount)\\n external\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n nonReentry(\\\"\\\")\\n {\\n uint256 balance =\\n LibEscrow.balanceOf(loanID, LibLoans.loan(loanID).lendingToken);\\n uint256 totalOwed = LibLoans.getTotalOwed(loanID);\\n if (balance < totalOwed && amount > balance) {\\n uint256 amountNeeded =\\n amount > totalOwed ? totalOwed - (balance) : amount - (balance);\\n\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n msg.sender,\\n address(LibEscrow.e(loanID)),\\n amountNeeded\\n );\\n }\\n\\n __repayLoan(loanID, amount, address(LibEscrow.e(loanID)), false);\\n }\\n\\n /**\\n * @notice Make a payment to a loan\\n * @param loanID The ID of the loan the payment is for\\n * @param amount The amount of tokens to pay back to the loan\\n */\\n function repayLoan(uint256 loanID, uint256 amount)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n __repayLoan(loanID, amount, msg.sender, false);\\n }\\n\\n function __repayLoan(\\n uint256 loanID,\\n uint256 amount,\\n address sender,\\n bool isLiquidation\\n ) private returns (uint256 leftToPay_) {\\n require(amount > 0, \\\"Teller: zero repay\\\");\\n\\n // calculate the actual amount to repay\\n leftToPay_ =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n if (leftToPay_ < amount) {\\n amount = leftToPay_;\\n leftToPay_ = 0;\\n } else {\\n leftToPay_ -= amount;\\n }\\n\\n // Get the Teller token for the loan\\n ITToken tToken =\\n MarketStorageLib.store().tTokens[\\n LibLoans.loan(loanID).lendingToken\\n ];\\n // Transfer funds from account\\n if (address(LibEscrow.e(loanID)) == sender) {\\n LibEscrow.e(loanID).claimToken(\\n LibLoans.loan(loanID).lendingToken,\\n address(tToken),\\n amount\\n );\\n } else {\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n sender,\\n address(tToken),\\n amount\\n );\\n }\\n\\n // Deduct the interest and principal owed\\n uint256 principalPaid;\\n uint256 interestPaid;\\n if (amount < LibLoans.debt(loanID).interestOwed) {\\n interestPaid = amount;\\n LibLoans.debt(loanID).interestOwed -= amount;\\n } else {\\n if (LibLoans.debt(loanID).interestOwed > 0) {\\n interestPaid = LibLoans.debt(loanID).interestOwed;\\n amount -= interestPaid;\\n LibLoans.debt(loanID).interestOwed = 0;\\n }\\n\\n if (amount > 0) {\\n principalPaid = amount;\\n LibLoans.debt(loanID).principalOwed -= amount;\\n }\\n }\\n\\n // Tell the Teller Token value has been deposited back into the pool.\\n tToken.repayLoan(principalPaid, interestPaid);\\n\\n if (isLiquidation) {\\n // Make sure there is nothing left to repay on the loan\\n require(leftToPay_ == 0, \\\"Teller: liquidate partial repay\\\");\\n\\n // Set loan status\\n LibLoans.loan(loanID).status = LoanStatus.Liquidated;\\n\\n // Transfer NFT if linked\\n NFTLib.liquidateNFT(loanID);\\n } else {\\n // if the loan is now fully paid, close it and withdraw borrower collateral\\n if (leftToPay_ == 0) {\\n LibLoans.loan(loanID).status = LoanStatus.Closed;\\n LibCollateral.withdrawAll(\\n loanID,\\n LibLoans.loan(loanID).borrower\\n );\\n // Restake any NFTs linked to loan for borrower\\n NFTLib.restakeLinked(loanID, LibLoans.loan(loanID).borrower);\\n }\\n\\n emit LoanRepaid(\\n loanID,\\n LibLoans.loan(loanID).borrower,\\n amount,\\n msg.sender,\\n leftToPay_\\n );\\n }\\n }\\n\\n /**\\n * @notice Liquidate a loan if it is expired or under collateralized\\n * @param loanID The ID of the loan to be liquidated\\n */\\n function liquidateLoan(uint256 loanID)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n uint256 collateralAmount = LibCollateral.e(loanID).loanSupply(loanID);\\n require(\\n RepayLib.isLiquidable(loanID, collateralAmount),\\n \\\"Teller: does not need liquidation\\\"\\n );\\n\\n // Calculate the reward before repaying the loan\\n (uint256 rewardInLending, uint256 collateralInLending) =\\n RepayLib.getLiquidationReward(loanID, collateralAmount);\\n\\n // The liquidator pays the amount still owed on the loan\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n __repayLoan(loanID, amountToLiquidate, msg.sender, true);\\n\\n // Payout the liquidator reward owed\\n if (rewardInLending > 0) {\\n RepayLib.payOutLiquidator(\\n loanID,\\n rewardInLending,\\n collateralInLending,\\n collateralAmount,\\n payable(msg.sender)\\n );\\n }\\n\\n emit LoanLiquidated(\\n loanID,\\n loan.borrower,\\n msg.sender,\\n rewardInLending,\\n amountToLiquidate\\n );\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @return inLending_ The value the liquidator will receive denoted in lending tokens.\\n * @return inCollateral_ The value the liquidator will receive denoted in collateral tokens.\\n */\\n function getLiquidationReward(uint256 loanID)\\n external\\n view\\n returns (uint256 inLending_, uint256 inCollateral_)\\n {\\n (inLending_, ) = RepayLib.getLiquidationReward(\\n loanID,\\n LibCollateral.e(loanID).loanSupply(loanID)\\n );\\n inCollateral_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n inLending_\\n );\\n }\\n}\\n\\nlibrary RepayLib {\\n /**\\n * @notice It checks if a loan can be liquidated.\\n * @param loanID The loan ID to check.\\n * @return true if the loan is liquidable.\\n */\\n function isLiquidable(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (bool)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n // Check if loan can be liquidated\\n if (loan.status != LoanStatus.Active) {\\n return false;\\n }\\n\\n if (loan.collateralRatio > 0) {\\n // If loan has a collateral ratio, check how much is needed\\n (, uint256 neededInCollateral, ) =\\n LoanDataFacet(address(this)).getCollateralNeededInfo(loanID);\\n if (neededInCollateral > collateralAmount) {\\n return true;\\n }\\n }\\n\\n // Otherwise, check if the loan has expired\\n return block.timestamp >= loan.loanStartTime + loan.duration;\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @param collateralAmount The amount of collateral for the {loanID}. Passed in to save gas calling the collateral escrow multiple times.\\n * @return reward_ The value the liquidator will receive denoted in lending tokens.\\n */\\n function getLiquidationReward(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (uint256 reward_, uint256 collateralValue_)\\n {\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n // Max reward is amount repaid on loan plus extra percentage\\n uint256 maxReward =\\n amountToLiquidate +\\n NumbersLib.percent(\\n amountToLiquidate,\\n uint16(PlatformSettingsLib.getLiquidateRewardPercent())\\n );\\n\\n // Calculate available collateral for reward\\n if (collateralAmount > 0) {\\n collateralValue_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).collateralToken,\\n LibLoans.loan(loanID).lendingToken,\\n collateralAmount\\n );\\n reward_ += collateralValue_;\\n }\\n\\n // Calculate loan escrow value if collateral not enough to cover reward\\n if (reward_ < maxReward) {\\n reward_ += LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n // Cap the reward to max\\n if (reward_ > maxReward) {\\n reward_ = maxReward;\\n }\\n }\\n\\n /**\\n * @notice Checks if the loan has an Escrow and claims any tokens then pays out the loan collateral.\\n * @dev See Escrow.claimTokens for more info.\\n * @param loanID The loan ID which is being liquidated\\n * @param rewardInLending The total amount of reward based in the lending token to pay the liquidator\\n * @param collateralInLending The amount of collateral that is available for the loan denoted in lending tokens\\n * @param collateralAmount The amount of collateral that is available for the loan\\n * @param liquidator The address of the liquidator where the liquidation reward will be sent to\\n */\\n function payOutLiquidator(\\n uint256 loanID,\\n uint256 rewardInLending,\\n uint256 collateralInLending,\\n uint256 collateralAmount,\\n address payable liquidator\\n ) internal {\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Liquidated,\\n \\\"Teller: loan not liquidated\\\"\\n );\\n\\n if (rewardInLending <= collateralInLending) {\\n uint256 rewardInCollateral =\\n PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n rewardInLending\\n );\\n\\n LibCollateral.withdraw(loanID, rewardInCollateral, liquidator);\\n } else {\\n // Payout whats available in the collateral token\\n LibCollateral.withdraw(loanID, collateralAmount, liquidator);\\n\\n // Claim remaining reward value from the loan escrow\\n claimEscrowTokensByValue(\\n loanID,\\n liquidator,\\n rewardInLending - collateralInLending\\n );\\n }\\n }\\n\\n /**\\n * @dev Send the equivalent of tokens owned by the loan escrow (in lending value) to the recipient,\\n * @param loanID The loan ID to clam tokens from\\n * @param recipient address to send the tokens to\\n * @param value The value of escrow held tokens to be claimed based in lending value\\n */\\n function claimEscrowTokensByValue(\\n uint256 loanID,\\n address recipient,\\n uint256 value\\n ) private {\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n uint256 valueLeftToTransfer = value;\\n\\n // Start with the lending token\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n LibLoans.loan(loanID).lendingToken,\\n recipient,\\n valueLeftToTransfer\\n );\\n\\n // Cycle through remaining tokens\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n if (valueLeftToTransfer == 0) {\\n return;\\n }\\n\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n EnumerableSet.at(tokens, i),\\n recipient,\\n valueLeftToTransfer\\n );\\n }\\n }\\n\\n function claimEscrowToken(\\n uint256 loanID,\\n address token,\\n address recipient,\\n uint256 valueLeftToTransfer\\n ) private returns (uint256) {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n // get value of token balance in lending value\\n if (balance > 0) {\\n // If token not the lending token, get value of token\\n uint256 balanceInLending;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n balanceInLending = balance;\\n } else {\\n balanceInLending = PriceAggLib.valueFor(\\n token,\\n LibLoans.loan(loanID).lendingToken,\\n balance\\n );\\n }\\n\\n if (balanceInLending <= valueLeftToTransfer) {\\n LibEscrow.e(loanID).claimToken(token, recipient, balance);\\n valueLeftToTransfer -= balanceInLending;\\n } else {\\n // Token balance is more than enough so calculate ratio of balance to transfer\\n uint256 valueToTransfer;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n valueToTransfer = valueLeftToTransfer;\\n } else {\\n valueToTransfer = NumbersLib.percent(\\n balance,\\n NumbersLib.ratioOf(\\n valueLeftToTransfer,\\n balanceInLending\\n )\\n );\\n }\\n\\n LibEscrow.e(loanID).claimToken(\\n token,\\n recipient,\\n valueToTransfer\\n );\\n valueLeftToTransfer = 0;\\n }\\n }\\n\\n return valueLeftToTransfer;\\n }\\n}\\n\",\"keccak256\":\"0xdfcd62dbcda7ba0ce92718d72d6cab3f7c78178d9ac9de6b04640124d43bf4cc\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n function init(address tokenAddress, bool isWETH) external;\\n\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x3c83593b5521e85c7f62076b41869cd5a762b34523ac39fc23b4ea1b9042aa59\",\"license\":\"MIT\"},\"contracts/market/libraries/LibCollateral.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport { ICollateralEscrow } from \\\"../collateral/ICollateralEscrow.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\nimport { MarketStorageLib } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibCollateral {\\n /**\\n * @notice This event is emitted when collateral has been deposited for the loan\\n * @param loanID ID of the loan for which collateral was deposited\\n * @param depositor Account that deposited funds\\n * @param amount Amount of collateral deposited\\n */\\n event CollateralDeposited(\\n uint256 indexed loanID,\\n address indexed depositor,\\n uint256 amount\\n );\\n\\n /**\\n * @notice This event is emitted when collateral has been withdrawn\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param receiver Account that received funds\\n * @param amount Value of collateral withdrawn\\n */\\n event CollateralWithdrawn(\\n uint256 indexed loanID,\\n address indexed receiver,\\n uint256 amount\\n );\\n\\n function e(uint256 loanID) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[\\n MarketStorageLib.store().loans[loanID].collateralToken\\n ];\\n }\\n\\n function e(address token) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[token];\\n }\\n\\n function deposit(uint256 loanID, uint256 amount) internal {\\n e(loanID).deposit{ value: amount }(loanID, amount);\\n\\n emit CollateralDeposited(loanID, msg.sender, amount);\\n }\\n\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) internal {\\n e(loanID).withdraw(loanID, amount, receiver);\\n\\n emit CollateralWithdrawn(loanID, receiver, amount);\\n }\\n\\n function withdrawAll(uint256 loanID, address payable receiver) internal {\\n withdraw(loanID, e(loanID).loanSupply(loanID), receiver);\\n }\\n\\n function createEscrow(address token) internal {\\n // Check if collateral escrow exists\\n if (address(e(token)) == address(0)) {\\n // Create escrow\\n address escrow =\\n AppStorageLib.store().collateralEscrowBeacon.cloneProxy(\\\"\\\");\\n ICollateralEscrow(escrow).init(\\n token,\\n // Check if collateral token is WETH\\n token == AppStorageLib.store().assetAddresses[\\\"WETH\\\"]\\n );\\n\\n // Set max allowance\\n IERC20(token).approve(escrow, type(uint256).max);\\n // Save escrow address for loan\\n MarketStorageLib.store().collateralEscrows[\\n token\\n ] = ICollateralEscrow(escrow);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd52b3e577480481b62d6a6c37f4ef596b7ec0120afbd6bc1a08b17923b926445\",\"license\":\"MIT\"},\"contracts/market/libraries/LibLoans.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibEscrow } from \\\"../../escrow/libraries/LibEscrow.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus,\\n LoanDebt,\\n LoanTerms\\n} from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibLoans {\\n using NumbersLib for int256;\\n using NumbersLib for uint256;\\n\\n bytes32 internal constant ID = keccak256(\\\"LOANS\\\");\\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\\n l_ = s().loans[loanID];\\n }\\n\\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\\n d_ = s().loanDebt[loanID];\\n }\\n\\n function terms(uint256 loanID)\\n internal\\n view\\n returns (LoanTerms storage t_)\\n {\\n t_ = s().loanTerms[loanID];\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) internal view returns (uint256) {\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n uint256 interestOwed =\\n getInterestOwedFor(loanID, terms(loanID).maxLoanAmount);\\n return terms(loanID).maxLoanAmount + (interestOwed);\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n return debt(loanID).principalOwed + (debt(loanID).interestOwed);\\n }\\n return 0;\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n internal\\n view\\n returns (uint256)\\n {\\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\\n }\\n\\n function getCollateralNeededInfo(uint256 loanID)\\n internal\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\\n loanID\\n );\\n\\n if (neededInLendingTokens == 0) {\\n neededInCollateralTokens = 0;\\n } else {\\n neededInCollateralTokens = PriceAggLib.valueFor(\\n loan(loanID).lendingToken,\\n loan(loanID).collateralToken,\\n neededInLendingTokens\\n );\\n }\\n }\\n\\n /**\\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\\n * @param loanID The loan ID to get needed collateral info for.\\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\\n */\\n function getCollateralNeededInTokens(uint256 loanID)\\n internal\\n view\\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\\n {\\n if (!_isActiveOrSet(loanID) || loan(loanID).collateralRatio == 0) {\\n return (0, 0);\\n }\\n\\n /*\\n The collateral to principal owed ratio is the sum of:\\n * collateral buffer percent\\n * loan interest rate\\n * liquidation reward percent\\n * X factor of additional collateral\\n */\\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n neededInLendingTokens = _getLoanAmount(loanID).percent(\\n loan(loanID).collateralRatio\\n );\\n } else {\\n uint16 requiredRatio =\\n loan(loanID).collateralRatio -\\n getInterestRatio(loanID) -\\n uint16(PlatformSettingsLib.getCollateralBufferValue());\\n\\n neededInLendingTokens =\\n debt(loanID).principalOwed +\\n debt(loanID).interestOwed;\\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\\n if (\\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\\n ) {\\n neededInLendingTokens -= escrowLoanValue;\\n }\\n neededInLendingTokens = neededInLendingTokens.percent(\\n requiredRatio\\n );\\n }\\n }\\n\\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\\n internal\\n view\\n returns (bool)\\n {\\n return\\n collateralRatio >=\\n PlatformSettingsLib.getOverCollateralizedBufferValue();\\n }\\n\\n /**\\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\\n * @notice There is a minimum threshold of 1%.\\n * @dev The interest rate on the loan terms is APY.\\n * @param loanID The loan ID to get the interest rate for.\\n */\\n function getInterestRatio(uint256 loanID)\\n internal\\n view\\n returns (uint16 ratio_)\\n {\\n ratio_ = uint16(\\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\\n SECONDS_PER_YEAR\\n );\\n\\n if (ratio_ == 0) {\\n ratio_ = 1;\\n }\\n }\\n\\n function _getLoanAmount(uint256 loanID) private view returns (uint256) {\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n return terms(loanID).maxLoanAmount;\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n return loan(loanID).borrowedAmount;\\n }\\n return 0;\\n }\\n\\n function _isActiveOrSet(uint256 loanID) private view returns (bool) {\\n LoanStatus status = loan(loanID).status;\\n return status == LoanStatus.Active || status == LoanStatus.TermsSet;\\n }\\n}\\n\",\"keccak256\":\"0x9bf9fae5b01110da7c5a5d2517fdea6aa880d5c1647ba6125c68cafad278499b\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x7c788b94c175b70eec6b10bfe0655616fc0beb2ce3ef70a6fa750f291d35106c\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}.\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x39fd6d70fd1aa5ae45465d7eeb38f74e2bf90535c2510782fb0bb5f720250ac5\",\"license\":\"MIT\"},\"contracts/nft/libraries/NFTLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../TellerNFT.sol\\\";\\n\\n// Libraries\\nimport {\\n MerkleProof\\n} from \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\nimport { NFTStorageLib, NFTStorage } from \\\"../../storage/nft.sol\\\";\\n\\nstruct NftLoanSizeProof {\\n uint256 id;\\n uint256 baseLoanSize;\\n bytes32[] proof;\\n}\\n\\nlibrary NFTLib {\\n function s() internal pure returns (NFTStorage storage s_) {\\n s_ = NFTStorageLib.store();\\n }\\n\\n function nft() internal view returns (TellerNFT nft_) {\\n nft_ = AppStorageLib.store().nft;\\n }\\n\\n function stake(uint256 nftID, address owner) internal {\\n // Transfer to diamond\\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\\n // Add NFT ID to user set\\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\\n }\\n\\n function unstake(uint256 nftID) internal returns (bool success_) {\\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\\n }\\n\\n function stakedNFTs(address nftOwner)\\n internal\\n view\\n returns (uint256[] memory staked_)\\n {\\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\\n staked_ = new uint256[](EnumerableSet.length(nfts));\\n for (uint256 i; i < staked_.length; i++) {\\n staked_[i] = EnumerableSet.at(nfts, i);\\n }\\n }\\n\\n function liquidateNFT(uint256 loanID) internal {\\n // Check if NFTs are linked\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n NFTLib.nft().transferFrom(\\n address(this),\\n AppStorageLib.store().nftLiquidationController,\\n EnumerableSet.at(nfts, i)\\n );\\n }\\n }\\n\\n function applyToLoan(uint256 loanID, NftLoanSizeProof calldata proof)\\n internal\\n {\\n // NFT must be currently staked\\n // Remove NFT from being staked - returns bool\\n require(unstake(proof.id), \\\"Teller: borrower nft not staked\\\");\\n\\n require(verifyLoanSize(proof), \\\"Teller invalid nft proof\\\");\\n\\n // Apply NFT to loan\\n EnumerableSet.add(s().loanNFTs[loanID], proof.id);\\n }\\n\\n function restakeLinked(uint256 loanID, address owner) internal {\\n // Get linked NFT\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n // Restake the NFT\\n EnumerableSet.add(s().stakedNFTs[owner], EnumerableSet.at(nfts, i));\\n }\\n }\\n\\n function verifyLoanSize(NftLoanSizeProof calldata proof)\\n internal\\n view\\n returns (bool verified_)\\n {\\n verified_ = MerkleProof.verify(\\n proof.proof,\\n s().nftMerkleRoot,\\n keccak256(abi.encodePacked(proof.id, proof.baseLoanSize))\\n );\\n }\\n}\\n\",\"keccak256\":\"0x99ba27095901d86a4d1e1b9ec3a603fbbf7c67ada2ccd11cd5ed0435e5c3c66d\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @dev It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @dev Tries to calculate a price from Compound and Chainlink.\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @dev Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @dev Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @dev Scales the {value} by the difference in decimal values.\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @dev Tries to calculate the price of {src} in {dst}\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address WETH = AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n if (dst != WETH) {\\n int256 price1 = _priceFor(src, WETH);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, WETH);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf84fd8d9a179ca7a70e75677870bdd7a5be7da097cf5f1bccf1c9f93253bda90\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { PriceAggFacet } from \\\"./PriceAggFacet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\n/**\\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\\n */\\nlibrary PriceAggLib {\\n /**\\n * @notice See {PriceAggFacet.getValueFor}\\n */\\n function valueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) internal view returns (uint256 value_) {\\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\\n }\\n\\n /**\\n * @notice See {PriceAggFacet.getPriceFor}\\n */\\n function priceFor(address src, address dst)\\n internal\\n view\\n returns (int256 price_)\\n {\\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\\n }\\n}\\n\",\"keccak256\":\"0x510633e39e7a30533d703eb7ec314c037772721fdb7cea96046cd6837bcb76c3\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\nabstract contract PausableMods {\\n /**\\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\\n * @param id id of the facet to check if is paused.\\n * @param state Boolean that the protocol AND facet should be in.\\n */\\n modifier paused(bytes32 id, bool state) {\\n require(\\n __isPaused(\\\"\\\") == state && __isPaused(id) == state,\\n __pausedMessage(state)\\n );\\n _;\\n }\\n\\n /**\\n * @dev Checks if the given id is paused.\\n * @param id Encoded id of the facet to check if is paused.\\n */\\n function __isPaused(bytes32 id) private view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n\\n /**\\n * @dev Gets the message that should be reverted with given a state it should be in.\\n * @param state Boolean that an id should be in.\\n */\\n function __pausedMessage(bool state) private pure returns (string memory) {\\n return state ? \\\"Pausable: not paused\\\" : \\\"Pausable: paused\\\";\\n }\\n}\\n\",\"keccak256\":\"0x772d8b9b63e9b8e78f243a70988f1a1e1100272cf317259ea173829f7b9bdf0e\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0xbeef1937dc1ed1f6f78b80f0737f018565ab264184cf05ef54c3c28ecd55a09b\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xacf6bcb8c4afd2f337a0161e8be64b016c1b350d336cd862245dd922fcd10f33\",\"license\":\"MIT\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n function claimComp(address holder) external;\\n\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x495d8bb746a524fea6ddc4286c955d7a0160718bf662456330a9d6d14b8a5da9\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n\\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x208769886b3db8f03ef1fa26f1caee189038dfc744b9a499402fc4e4c0090c38\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4d9045666e86d675f7bd48202f9a77d0675fa20b2184131ad369710ac5eb3203\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @notice CETH is the only Compound token that does not support the {underlying} function.\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x14e96659912e9d03ae30732faca8e3d617f3e756a215d948cabedab6642c1465\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0x998aefaf4edbe7b0cb41032750b65b3822b4bec0fec3ee5b396f8fb73b5e9e03\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0x8919fcdfb49018474c872c462c11b21a50faa7ab80f0162abd6b657cbbc5d04c\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x0888cf40ea019be9f0ee94cb8af1e030454c28f8c6512db9d89ed027fe21f18f\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n bool initialized;\\n bool platformRestricted;\\n mapping(bytes32 => bool) paused;\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0xade1dda8163fc39658e5f6929b662187584b29cce47e9cb0915fc0d1832fb4f7\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) loanTerms;\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5f3fdba19ae8040e2007affe422527b7dca58ba424df33ba4dd9cb08d83d00de\",\"license\":\"MIT\"},\"contracts/storage/nft.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Utils\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct NFTStorage {\\n // Maps NFT owner to set of token IDs owned\\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\\n // Maps loanID to NFT IDs indicating NFT being used for the loan\\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\\n // Merkle root used for verifying nft IDs to base loan size\\n bytes32 nftMerkleRoot;\\n}\\n\\nbytes32 constant NFT_STORAGE_POS = keccak256(\\\"teller.staking.storage\\\");\\n\\nlibrary NFTStorageLib {\\n function store() internal pure returns (NFTStorage storage s) {\\n bytes32 pos = NFT_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x8d58bb6ba00310d8c3d89b95c62e5c997430a1124d73224897f7d9b2a43ab50a\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "params": { + "borrower": "Account address of the borrower", + "liquidator": "Account address of the liquidator", + "loanID": "ID of loan from which collateral was withdrawn", + "reward": "Value in lending token paid out to liquidator", + "tokensIn": "Percentage of the collateral price paid by the liquidator to the lending pool" + } + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "params": { + "amountPaid": "Amount of the loan paid back", + "borrower": "Account address of the borrower", + "loanID": "ID of loan from which collateral was withdrawn", + "payer": "Account address of the payer", + "totalOwed": "Total amount of the loan to be repaid" + } + } + }, + "kind": "dev", + "methods": { + "escrowRepay(uint256,uint256)": { + "details": "If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.", + "params": { + "amount": "The amount being repaid.", + "loanID": "The id of the loan being used." + } + }, + "getLiquidationReward(uint256)": { + "params": { + "loanID": "The loan ID to get the info." + }, + "returns": { + "inCollateral_": "The value the liquidator will receive denoted in collateral tokens.", + "inLending_": "The value the liquidator will receive denoted in lending tokens." + } + }, + "liquidateLoan(uint256)": { + "params": { + "loanID": "The ID of the loan to be liquidated" + } + }, + "repayLoan(uint256,uint256)": { + "params": { + "amount": "The amount of tokens to pay back to the loan", + "loanID": "The ID of the loan the payment is for" + } + } + }, + "version": 1 + }, + "userdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "notice": "This event is emitted when a loan has been successfully liquidated" + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "notice": "This event is emitted when a loan has been successfully repaid" + } + }, + "kind": "user", + "methods": { + "escrowRepay(uint256,uint256)": { + "notice": "Repay this Escrow's loan." + }, + "getLiquidationReward(uint256)": { + "notice": "It gets the current liquidation reward for a given loan." + }, + "liquidateLoan(uint256)": { + "notice": "Liquidate a loan if it is expired or under collateralized" + }, + "repayLoan(uint256,uint256)": { + "notice": "Make a payment to a loan" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "params": { + "borrower": "Account address of the borrower", + "liquidator": "Account address of the liquidator", + "loanID": "ID of loan from which collateral was withdrawn", + "reward": "Value in lending token paid out to liquidator", + "tokensIn": "Percentage of the collateral price paid by the liquidator to the lending pool" + } + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "params": { + "amountPaid": "Amount of the loan paid back", + "borrower": "Account address of the borrower", + "loanID": "ID of loan from which collateral was withdrawn", + "payer": "Account address of the payer", + "totalOwed": "Total amount of the loan to be repaid" + } + } + }, + "kind": "dev", + "methods": { + "escrowRepay(uint256,uint256)": { + "details": "If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.", + "params": { + "amount": "The amount being repaid.", + "loanID": "The id of the loan being used." + } + }, + "getLiquidationReward(uint256)": { + "params": { + "loanID": "The loan ID to get the info." + }, + "returns": { + "inCollateral_": "The value the liquidator will receive denoted in collateral tokens.", + "inLending_": "The value the liquidator will receive denoted in lending tokens." + } + }, + "liquidateLoan(uint256)": { + "params": { + "loanID": "The ID of the loan to be liquidated" + } + }, + "repayLoan(uint256,uint256)": { + "params": { + "amount": "The amount of tokens to pay back to the loan", + "loanID": "The ID of the loan the payment is for" + } + } + }, + "version": 1 + }, + "userdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "notice": "This event is emitted when a loan has been successfully liquidated" + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "notice": "This event is emitted when a loan has been successfully repaid" + } + }, + "kind": "user", + "methods": { + "escrowRepay(uint256,uint256)": { + "notice": "Repay this Escrow's loan." + }, + "getLiquidationReward(uint256)": { + "notice": "It gets the current liquidation reward for a given loan." + }, + "liquidateLoan(uint256)": { + "notice": "Liquidate a loan if it is expired or under collateralized" + }, + "repayLoan(uint256,uint256)": { + "notice": "Make a payment to a loan" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "params": { + "borrower": "Account address of the borrower", + "liquidator": "Account address of the liquidator", + "loanID": "ID of loan from which collateral was withdrawn", + "reward": "Value in lending token paid out to liquidator", + "tokensIn": "Percentage of the collateral price paid by the liquidator to the lending pool" + } + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "params": { + "amountPaid": "Amount of the loan paid back", + "borrower": "Account address of the borrower", + "loanID": "ID of loan from which collateral was withdrawn", + "payer": "Account address of the payer", + "totalOwed": "Total amount of the loan to be repaid" + } + } + }, + "kind": "dev", + "methods": { + "escrowRepay(uint256,uint256)": { + "details": "If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.", + "params": { + "amount": "The amount being repaid.", + "loanID": "The id of the loan being used." + } + }, + "getLiquidationReward(uint256)": { + "params": { + "loanID": "The loan ID to get the info." + }, + "returns": { + "inCollateral_": "The value the liquidator will receive denoted in collateral tokens.", + "inLending_": "The value the liquidator will receive denoted in lending tokens." + } + }, + "liquidateLoan(uint256)": { + "params": { + "loanID": "The ID of the loan to be liquidated" + } + }, + "repayLoan(uint256,uint256)": { + "params": { + "amount": "The amount of tokens to pay back to the loan", + "loanID": "The ID of the loan the payment is for" + } + } + }, + "version": 1 + }, + "userdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "notice": "This event is emitted when a loan has been successfully liquidated" + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "notice": "This event is emitted when a loan has been successfully repaid" + } + }, + "kind": "user", + "methods": { + "escrowRepay(uint256,uint256)": { + "notice": "Repay this Escrow's loan." + }, + "getLiquidationReward(uint256)": { + "notice": "It gets the current liquidation reward for a given loan." + }, + "liquidateLoan(uint256)": { + "notice": "Liquidate a loan if it is expired or under collateralized" + }, + "repayLoan(uint256,uint256)": { + "notice": "Make a payment to a loan" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "params": { + "borrower": "Account address of the borrower", + "liquidator": "Account address of the liquidator", + "loanID": "ID of loan from which collateral was withdrawn", + "reward": "Value in lending token paid out to liquidator", + "tokensIn": "Percentage of the collateral price paid by the liquidator to the lending pool" + } + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "params": { + "amountPaid": "Amount of the loan paid back", + "borrower": "Account address of the borrower", + "loanID": "ID of loan from which collateral was withdrawn", + "payer": "Account address of the payer", + "totalOwed": "Total amount of the loan to be repaid" + } + } + }, + "kind": "dev", + "methods": { + "claimTokens(uint256)": { + "params": { + "loanID": "The id of the loan being used." + } + }, + "escrowRepay(uint256,uint256)": { + "details": "If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.", + "params": { + "amount": "The amount being repaid.", + "loanID": "The id of the loan being used." + } + }, + "getLiquidationReward(uint256)": { + "params": { + "loanID": "The loan ID to get the info." + }, + "returns": { + "inCollateral_": "The value the liquidator will receive denoted in collateral tokens.", + "inLending_": "The value the liquidator will receive denoted in lending tokens." + } + }, + "liquidateLoan(uint256)": { + "params": { + "loanID": "The ID of the loan to be liquidated" + } + }, + "repayLoan(uint256,uint256)": { + "params": { + "amount": "The amount of tokens to pay back to the loan", + "loanID": "The ID of the loan the payment is for" + } + } + }, + "version": 1 + }, + "userdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "notice": "This event is emitted when a loan has been successfully liquidated" + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "notice": "This event is emitted when a loan has been successfully repaid" + }, + "TokensClaimed(address)": { + "notice": "Notifies when the Escrow's tokens have been claimed." + } + }, + "kind": "user", + "methods": { + "claimTokens(uint256)": { + "notice": "Sends the tokens owned by this escrow to the owner." + }, + "escrowRepay(uint256,uint256)": { + "notice": "Repay this Escrow's loan." + }, + "getLiquidationReward(uint256)": { + "notice": "It gets the current liquidation reward for a given loan." + }, + "liquidateLoan(uint256)": { + "notice": "Liquidate a loan if it is expired or under collateralized" + }, + "repayLoan(uint256,uint256)": { + "notice": "Make a payment to a loan" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } } ], "devdoc": { diff --git a/deployments/kovan/TellerDiamond.json b/deployments/kovan/TellerDiamond.json index 98f9833e3..14638ea02 100644 --- a/deployments/kovan/TellerDiamond.json +++ b/deployments/kovan/TellerDiamond.json @@ -2124,144 +2124,6 @@ "stateMutability": "nonpayable", "type": "function" }, - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "address", - "name": "tokenAddress", - "type": "address" - }, - { - "indexed": true, - "internalType": "address", - "name": "aTokenAddress", - "type": "address" - }, - { - "indexed": false, - "internalType": "uint256", - "name": "amount", - "type": "uint256" - }, - { - "indexed": false, - "internalType": "uint256", - "name": "aTokenBalanceBeforeDeposit", - "type": "uint256" - }, - { - "indexed": false, - "internalType": "uint256", - "name": "aTokenBalanceAfterDeposit", - "type": "uint256" - } - ], - "name": "AaveDeposited", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "address", - "name": "tokenAddress", - "type": "address" - }, - { - "indexed": true, - "internalType": "address", - "name": "aTokenAddress", - "type": "address" - }, - { - "indexed": false, - "internalType": "uint256", - "name": "amount", - "type": "uint256" - }, - { - "indexed": false, - "internalType": "uint256", - "name": "aTokenBalanceBeforeDeposit", - "type": "uint256" - }, - { - "indexed": false, - "internalType": "uint256", - "name": "aTokenBalanceAfterWithdrawal", - "type": "uint256" - } - ], - "name": "AaveWithdrawn", - "type": "event" - }, - { - "inputs": [ - { - "internalType": "uint256", - "name": "loanID", - "type": "uint256" - }, - { - "internalType": "address", - "name": "tokenAddress", - "type": "address" - }, - { - "internalType": "uint256", - "name": "amount", - "type": "uint256" - } - ], - "name": "aaveDeposit", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "uint256", - "name": "loanID", - "type": "uint256" - }, - { - "internalType": "address", - "name": "tokenAddress", - "type": "address" - }, - { - "internalType": "uint256", - "name": "amount", - "type": "uint256" - } - ], - "name": "aaveWithdraw", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "uint256", - "name": "loanID", - "type": "uint256" - }, - { - "internalType": "address", - "name": "tokenAddress", - "type": "address" - } - ], - "name": "aaveWithdrawAll", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, { "anonymous": false, "inputs": [ @@ -2437,51 +2299,51 @@ } ], "artifactName": "Diamond", - "transactionHash": "0x9566ec6c0954c46702b1c054a240a8bd14e82e95ef95b304d2a1836fef9a5dd5", + "transactionHash": "0x4443cca9be807f06b216bd633560013bc17ae9301a6810e4dff3d94b669983f0", "receipt": { "to": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", "contractAddress": null, "transactionIndex": 0, - "gasUsed": "253745", + "gasUsed": "119564", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000000000000000000000000040000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000", - "blockHash": "0xad859cd487ddc58a51cd1accfef8d6ac516cd760adaefc12805f1eb0ae0ccb37", - "transactionHash": "0x9566ec6c0954c46702b1c054a240a8bd14e82e95ef95b304d2a1836fef9a5dd5", + "blockHash": "0xfe9e47178e0d829b68e432222ed01aa0c12ab975762feacb3df4c6ff35bb5f45", + "transactionHash": "0x4443cca9be807f06b216bd633560013bc17ae9301a6810e4dff3d94b669983f0", "logs": [ { "transactionIndex": 0, - "blockNumber": 25521615, - "transactionHash": "0x9566ec6c0954c46702b1c054a240a8bd14e82e95ef95b304d2a1836fef9a5dd5", + "blockNumber": 25672048, + "transactionHash": "0x4443cca9be807f06b216bd633560013bc17ae9301a6810e4dff3d94b669983f0", "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", "topics": [ "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" ], - "data": "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003c0000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000024000000000000000000000000005a4c38216c33f2bc454309cc4f8464a6fb36f96000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002ea40e51a00000000000000000000000000000000000000000000000000000000fe5d095b00000000000000000000000000000000000000000000000000000000000000000000000000000000e6fc54f4e4346b03636a0911efd51eca21242bb700000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000546e04a2f00000000000000000000000000000000000000000000000000000000e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b530000000000000000000000000000000000000000000000000000000000000000000000000000000002ab15be170eb83801e0d85365bc2103c3a3d48a000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004a7baf6fc000000000000000000000000000000000000000000000000000000006f70d21200000000000000000000000000000000000000000000000000000000987df220000000000000000000000000000000000000000000000000000000000f48a482000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "data": "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002c0000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000371d78fbc00000000000000000000000000000000000000000000000000000000f63761240000000000000000000000000000000000000000000000000000000033c72dfe0000000000000000000000000000000000000000000000000000000000000000000000000000000033b74a5abfc9fb0c8ac9f463361aefcde38ce88600000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000546e04a2f00000000000000000000000000000000000000000000000000000000e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b53000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "logIndex": 0, - "blockHash": "0xad859cd487ddc58a51cd1accfef8d6ac516cd760adaefc12805f1eb0ae0ccb37" + "blockHash": "0xfe9e47178e0d829b68e432222ed01aa0c12ab975762feacb3df4c6ff35bb5f45" } ], "events": [ { "transactionIndex": 0, - "blockNumber": 25521615, - "transactionHash": "0x9566ec6c0954c46702b1c054a240a8bd14e82e95ef95b304d2a1836fef9a5dd5", + "blockNumber": 25672048, + "transactionHash": "0x4443cca9be807f06b216bd633560013bc17ae9301a6810e4dff3d94b669983f0", "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", "topics": [ "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" ], - "data": "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003c0000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000024000000000000000000000000005a4c38216c33f2bc454309cc4f8464a6fb36f96000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002ea40e51a00000000000000000000000000000000000000000000000000000000fe5d095b00000000000000000000000000000000000000000000000000000000000000000000000000000000e6fc54f4e4346b03636a0911efd51eca21242bb700000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000546e04a2f00000000000000000000000000000000000000000000000000000000e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b530000000000000000000000000000000000000000000000000000000000000000000000000000000002ab15be170eb83801e0d85365bc2103c3a3d48a000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004a7baf6fc000000000000000000000000000000000000000000000000000000006f70d21200000000000000000000000000000000000000000000000000000000987df220000000000000000000000000000000000000000000000000000000000f48a482000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "data": "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002c0000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000371d78fbc00000000000000000000000000000000000000000000000000000000f63761240000000000000000000000000000000000000000000000000000000033c72dfe0000000000000000000000000000000000000000000000000000000000000000000000000000000033b74a5abfc9fb0c8ac9f463361aefcde38ce88600000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000546e04a2f00000000000000000000000000000000000000000000000000000000e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b53000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "logIndex": 0, - "blockHash": "0xad859cd487ddc58a51cd1accfef8d6ac516cd760adaefc12805f1eb0ae0ccb37", + "blockHash": "0xfe9e47178e0d829b68e432222ed01aa0c12ab975762feacb3df4c6ff35bb5f45", "args": [ [ [ - "0x05a4C38216C33F2BC454309cc4F8464A6fB36f96", - 1, - ["0xea40e51a", "0xfe5d095b"] + "0x0000000000000000000000000000000000000000", + 2, + ["0x71d78fbc", "0xf6376124", "0x33c72dfe"] ], [ - "0xe6fc54F4e4346b03636a0911Efd51ECa21242Bb7", + "0x33B74a5AbFc9FB0c8AC9f463361AEFCDe38cE886", 1, [ "0x46e04a2f", @@ -2490,11 +2352,6 @@ "0xccdd9f5d", "0x8a700b53" ] - ], - [ - "0x02ab15bE170EB83801E0d85365Bc2103c3a3d48A", - 1, - ["0xa7baf6fc", "0x6f70d212", "0x987df220", "0x0f48a482"] ] ], "0x0000000000000000000000000000000000000000", @@ -2504,8 +2361,8 @@ "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" } ], - "blockNumber": 25521615, - "cumulativeGasUsed": "253745", + "blockNumber": 25672048, + "cumulativeGasUsed": "119564", "status": 1, "byzantium": true }, @@ -2608,7 +2465,7 @@ ] }, { - "facetAddress": "0xe6fc54F4e4346b03636a0911Efd51ECa21242Bb7", + "facetAddress": "0x33B74a5AbFc9FB0c8AC9f463361AEFCDe38cE886", "functionSelectors": [ "0x46e04a2f", "0xe89ad656", @@ -2630,10 +2487,6 @@ "0x0f48a482" ] }, - { - "facetAddress": "0xFc7c599947DCa76440DD3729a1292190C645Eb92", - "functionSelectors": ["0x71d78fbc", "0xf6376124", "0x33c72dfe"] - }, { "facetAddress": "0x5B5481Ad34b79D8e920B5F0f83d718ED225A7102", "functionSelectors": ["0x262201b6"] @@ -2645,12 +2498,12 @@ ], "diamondCut": [ { - "facetAddress": "0x05a4C38216C33F2BC454309cc4F8464A6fB36f96", - "functionSelectors": ["0xea40e51a", "0xfe5d095b"], - "action": 1 + "facetAddress": "0x0000000000000000000000000000000000000000", + "functionSelectors": ["0x71d78fbc", "0xf6376124", "0x33c72dfe"], + "action": 2 }, { - "facetAddress": "0xe6fc54F4e4346b03636a0911Efd51ECa21242Bb7", + "facetAddress": "0x33B74a5AbFc9FB0c8AC9f463361AEFCDe38cE886", "functionSelectors": [ "0x46e04a2f", "0xe89ad656", @@ -2659,16 +2512,6 @@ "0x8a700b53" ], "action": 1 - }, - { - "facetAddress": "0x02ab15bE170EB83801E0d85365Bc2103c3a3d48A", - "functionSelectors": [ - "0xa7baf6fc", - "0x6f70d212", - "0x987df220", - "0x0f48a482" - ], - "action": 1 } ], "history": [ @@ -91609,6 +91452,92175 @@ "storage": [], "types": null } + }, + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanUserRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanConsensusResponse[]", + "name": "responses", + "type": "tuple[]" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanUserRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanConsensusResponse[]", + "name": "responses", + "type": "tuple[]" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "internalType": "uint16[]", + "name": "nftIDs", + "type": "uint16[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "dictAddress", + "type": "address" + } + ], + "name": "setNFTDictionary", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x9566ec6c0954c46702b1c054a240a8bd14e82e95ef95b304d2a1836fef9a5dd5", + "receipt": { + "to": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "253745", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000000000000000000000000040000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xad859cd487ddc58a51cd1accfef8d6ac516cd760adaefc12805f1eb0ae0ccb37", + "transactionHash": "0x9566ec6c0954c46702b1c054a240a8bd14e82e95ef95b304d2a1836fef9a5dd5", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25521615, + "transactionHash": "0x9566ec6c0954c46702b1c054a240a8bd14e82e95ef95b304d2a1836fef9a5dd5", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003c0000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000024000000000000000000000000005a4c38216c33f2bc454309cc4f8464a6fb36f96000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002ea40e51a00000000000000000000000000000000000000000000000000000000fe5d095b00000000000000000000000000000000000000000000000000000000000000000000000000000000e6fc54f4e4346b03636a0911efd51eca21242bb700000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000546e04a2f00000000000000000000000000000000000000000000000000000000e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b530000000000000000000000000000000000000000000000000000000000000000000000000000000002ab15be170eb83801e0d85365bc2103c3a3d48a000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004a7baf6fc000000000000000000000000000000000000000000000000000000006f70d21200000000000000000000000000000000000000000000000000000000987df220000000000000000000000000000000000000000000000000000000000f48a482000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xad859cd487ddc58a51cd1accfef8d6ac516cd760adaefc12805f1eb0ae0ccb37" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25521615, + "transactionHash": "0x9566ec6c0954c46702b1c054a240a8bd14e82e95ef95b304d2a1836fef9a5dd5", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003c0000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000024000000000000000000000000005a4c38216c33f2bc454309cc4f8464a6fb36f96000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002ea40e51a00000000000000000000000000000000000000000000000000000000fe5d095b00000000000000000000000000000000000000000000000000000000000000000000000000000000e6fc54f4e4346b03636a0911efd51eca21242bb700000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000546e04a2f00000000000000000000000000000000000000000000000000000000e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b530000000000000000000000000000000000000000000000000000000000000000000000000000000002ab15be170eb83801e0d85365bc2103c3a3d48a000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004a7baf6fc000000000000000000000000000000000000000000000000000000006f70d21200000000000000000000000000000000000000000000000000000000987df220000000000000000000000000000000000000000000000000000000000f48a482000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xad859cd487ddc58a51cd1accfef8d6ac516cd760adaefc12805f1eb0ae0ccb37", + "args": [ + [ + [ + "0x05a4C38216C33F2BC454309cc4F8464A6fB36f96", + 1, + ["0xea40e51a", "0xfe5d095b"] + ], + [ + "0xe6fc54F4e4346b03636a0911Efd51ECa21242Bb7", + 1, + [ + "0x46e04a2f", + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + ], + [ + "0x02ab15bE170EB83801E0d85365Bc2103c3a3d48A", + 1, + ["0xa7baf6fc", "0x6f70d212", "0x987df220", "0x0f48a482"] + ] + ], + "0x0000000000000000000000000000000000000000", + "0x" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 25521615, + "cumulativeGasUsed": "253745", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "0x608060405260405162002d4538038062002d45833981016040819052620000269162000db2565b604080516000808252602082019092526200004e918491620000f560201b620000db1760201c565b620000688160000151620002b560201b6200027d1760201c565b60006200007f6200031760201b620003021760201c565b6301ffc9a760e01b600090815260039091016020526040808220805460ff1990811660019081179092556307e4c70760e21b845282842080548216831790556348e2b09360e01b845282842080548216831790556307f5828d60e41b845291909220805490911690911790555062001442915050565b60005b8351811015620002665760008482815181106200011157fe5b6020026020010151602001519050600060028111156200012d57fe5b8160028111156200013a57fe5b14156200018957620001838583815181106200015257fe5b6020026020010151600001518684815181106200016b57fe5b6020026020010151604001516200033b60201b60201c565b6200025c565b60018160028111156200019857fe5b1415620001e15762000183858381518110620001b057fe5b602002602001015160000151868481518110620001c957fe5b6020026020010151604001516200054e60201b60201c565b6002816002811115620001f057fe5b14156200023957620001838583815181106200020857fe5b6020026020010151600001518684815181106200022157fe5b6020026020010151604001516200077860201b60201c565b60405162461bcd60e51b815260040162000253906200117c565b60405180910390fd5b50600101620000f8565b507f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb6738383836040516200029c9392919062000f25565b60405180910390a1620002b082826200083f565b505050565b6000620002c162000317565b6004810180546001600160a01b038581166001600160a01b031983168117909355604051939450169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c90565b60008151116200035f5760405162461bcd60e51b81526004016200025390620010d4565b60006200036b62000317565b90506001600160a01b038316620003965760405162461bcd60e51b81526004016200025390620011c3565b6001600160a01b038316600090815260018201602052604090205461ffff81166200043c57620003e08460405180606001604052806024815260200162002d21602491396200097c565b6002820180546001600160a01b038616600081815260018087016020908152604083208201805461ffff191661ffff90961695909517909455845490810185559381529190912090910180546001600160a01b03191690911790555b60005b8351811015620005475760008482815181106200045857fe5b6020908102919091018101516001600160e01b031981166000908152918690526040909120549091506001600160a01b03168015620004ab5760405162461bcd60e51b81526004016200025390620012ba565b506001600160a01b0386166000818152600186810160209081526040808420805480850182559085528285206008820401805463ffffffff60079093166004026101000a928302191660e089901c929092029190911790556001600160e01b0319909516835287905292902080546001600160a01b03191690911761ffff60a01b1916600160a01b61ffff86160217905591820191016200043f565b5050505050565b6000815111620005725760405162461bcd60e51b81526004016200025390620010d4565b60006200057e62000317565b90506001600160a01b038316620005a95760405162461bcd60e51b81526004016200025390620011c3565b6001600160a01b038316600090815260018201602052604090205461ffff81166200064f57620005f38460405180606001604052806024815260200162002d21602491396200097c565b6002820180546001600160a01b038616600081815260018087016020908152604083208201805461ffff191661ffff90961695909517909455845490810185559381529190912090910180546001600160a01b03191690911790555b60005b8351811015620005475760008482815181106200066b57fe5b6020908102919091018101516001600160e01b031981166000908152918690526040909120549091506001600160a01b03908116908716811415620006c45760405162461bcd60e51b8152600401620002539062001317565b620006d08183620009a0565b506001600160e01b03198116600081815260208681526040808320805461ffff60a01b1916600160a01b61ffff8a16021781556001600160a01b038b168085526001808b018552928520805480850182559086528486206008820401805463ffffffff60079093166004026101000a928302191660e09990991c91909102979097179096559390925286905281546001600160a01b0319169092179055918201910162000652565b60008151116200079c5760405162461bcd60e51b81526004016200025390620010d4565b6000620007a862000317565b90506001600160a01b03831615620007d45760405162461bcd60e51b8152600401620002539062001374565b60005b825181101562000839576000838281518110620007f057fe5b6020908102919091018101516001600160e01b031981166000908152918590526040909120549091506001600160a01b03166200082e8183620009a0565b5050600101620007d7565b50505050565b6001600160a01b0382166200087657805115620008705760405162461bcd60e51b8152600401620002539062001031565b62000978565b60008151116200089a5760405162461bcd60e51b815260040162000253906200120f565b6001600160a01b0382163014620008d057620008d08260405180606001604052806028815260200162002cf9602891396200097c565b600080836001600160a01b031683604051620008ed919062000f07565b600060405180830381855af49150503d80600081146200092a576040519150601f19603f3d011682016040523d82523d6000602084013e6200092f565b606091505b50915091508162000839578051156200095e578060405162461bcd60e51b815260040162000253919062001015565b60405162461bcd60e51b815260040162000253906200108e565b5050565b813b8181620008395760405162461bcd60e51b815260040162000253919062001015565b6000620009ac62000317565b90506001600160a01b038316620009d75760405162461bcd60e51b815260040162000253906200111f565b6001600160a01b03831630141562000a035760405162461bcd60e51b815260040162000253906200126c565b6001600160e01b03198216600090815260208281526040808320546001600160a01b03871684526001850190925290912054600160a01b90910461ffff16906000190180821462000b27576001600160a01b0385166000908152600184016020526040812080548390811062000a7557fe5b600091825260208083206008830401546001600160a01b038a168452600188019091526040909220805460079092166004026101000a90920460e01b92508291908590811062000ac157fe5b600091825260208083206008830401805463ffffffff60079094166004026101000a938402191660e09590951c929092029390931790556001600160e01b031992909216825284905260409020805461ffff60a01b1916600160a01b61ffff8516021790555b6001600160a01b0385166000908152600184016020526040902080548062000b4b57fe5b60008281526020808220600860001990940193840401805463ffffffff600460078716026101000a0219169055919092556001600160e01b0319861682528490526040902080546001600160b01b031916905580620005475760028301546001600160a01b03861660009081526001858101602052604090912001546000199091019061ffff1680821462000c6357600085600201838154811062000bec57fe5b6000918252602090912001546002870180546001600160a01b03909216925082918490811062000c1857fe5b600091825260208083209190910180546001600160a01b0319166001600160a01b0394851617905592909116815260018781019092526040902001805461ffff191661ffff83161790555b8460020180548062000c7157fe5b60008281526020808220830160001990810180546001600160a01b03191690559092019092556001600160a01b03891682526001878101909152604090912001805461ffff1916905550505050505050565b80516001600160a01b038116811462000cdb57600080fd5b919050565b600082601f83011262000cf1578081fd5b8151602062000d0a62000d0483620013f5565b620013d1565b828152818101908583018385028701840188101562000d27578586fd5b855b8581101562000d5d5781516001600160e01b03198116811462000d4a578788fd5b8452928401929084019060010162000d29565b5090979650505050505050565b60006020828403121562000d7c578081fd5b604051602081016001600160401b038111828210171562000d9957fe5b60405290508062000daa8362000cc3565b905292915050565b6000806040838503121562000dc5578182fd5b82516001600160401b038082111562000ddc578384fd5b818501915085601f83011262000df0578384fd5b8151602062000e0362000d0483620013f5565b82815281810190858301885b8581101562000eaa57815188016060818e03601f1901121562000e30578a8bfd5b604051606081018181108a8211171562000e4657fe5b60405262000e5682880162000cc3565b815260408201516003811062000e6a578c8dfd5b8188015260608201518981111562000e80578c8dfd5b62000e908f898386010162000ce0565b604083015250855250928401929084019060010162000e0f565b5050809750505062000ebf8882890162000d6a565b9450505050509250929050565b6001600160a01b03169052565b6000815180845262000ef381602086016020860162001413565b601f01601f19169290920160200192915050565b6000825162000f1b81846020870162001413565b9190910192915050565b606080825284518282018190526000919060809081850190602080820287018401818b01875b8481101562000fe257898303607f19018652815180516001600160a01b0316845284810151898501906003811062000f7f57fe5b858701526040918201519185018a9052815190819052908501908a90898601905b8083101562000fcc5783516001600160e01b031916825292870192600192909201919087019062000fa0565b5097860197945050509083019060010162000f4b565b505062000ff28289018b62000ecc565b878103604089015262001006818a62000ed9565b9b9a5050505050505050505050565b6000602082526200102a602083018462000ed9565b9392505050565b6020808252603c908201527f4c69624469616d6f6e644375743a205f696e697420697320616464726573732860408201527f3029206275745f63616c6c64617461206973206e6f7420656d70747900000000606082015260800190565b60208082526026908201527f4c69624469616d6f6e644375743a205f696e69742066756e6374696f6e2072656040820152651d995c9d195960d21b606082015260800190565b6020808252602b908201527f4c69624469616d6f6e644375743a204e6f2073656c6563746f727320696e206660408201526a1858d95d081d1bc818dd5d60aa1b606082015260800190565b60208082526037908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f76652066756e6360408201527f74696f6e207468617420646f65736e2774206578697374000000000000000000606082015260800190565b60208082526027908201527f4c69624469616d6f6e644375743a20496e636f727265637420466163657443756040820152663a20b1ba34b7b760c91b606082015260800190565b6020808252602c908201527f4c69624469616d6f6e644375743a204164642066616365742063616e2774206260408201526b65206164647265737328302960a01b606082015260800190565b6020808252603d908201527f4c69624469616d6f6e644375743a205f63616c6c6461746120697320656d707460408201527f7920627574205f696e6974206973206e6f742061646472657373283029000000606082015260800190565b6020808252602e908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f766520696d6d7560408201526d3a30b1363290333ab731ba34b7b760911b606082015260800190565b60208082526035908201527f4c69624469616d6f6e644375743a2043616e2774206164642066756e6374696f60408201527f6e207468617420616c7265616479206578697374730000000000000000000000606082015260800190565b60208082526038908201527f4c69624469616d6f6e644375743a2043616e2774207265706c6163652066756e60408201527f6374696f6e20776974682073616d652066756e6374696f6e0000000000000000606082015260800190565b60208082526036908201527f4c69624469616d6f6e644375743a2052656d6f7665206661636574206164647260408201527f657373206d757374206265206164647265737328302900000000000000000000606082015260800190565b6040518181016001600160401b0381118282101715620013ed57fe5b604052919050565b60006001600160401b038211156200140957fe5b5060209081020190565b60005b838110156200143057818101518382015260200162001416565b83811115620008395750506000910152565b6118a780620014526000396000f3fe60806040523661000b57005b600080357fffffffff000000000000000000000000000000000000000000000000000000001681527fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c6020819052604090912054819073ffffffffffffffffffffffffffffffffffffffff16806100b7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906115f3565b60405180910390fd5b3660008037600080366000845af43d6000803e8080156100d6573d6000f35b3d6000fd5b60005b83518110156102325760008482815181106100f557fe5b60200260200101516020015190506000600281111561011057fe5b81600281111561011c57fe5b141561015f5761015a85838151811061013157fe5b60200260200101516000015186848151811061014957fe5b602002602001015160400151610326565b610229565b600181600281111561016d57fe5b14156101ab5761015a85838151811061018257fe5b60200260200101516000015186848151811061019a57fe5b60200260200101516040015161065e565b60028160028111156101b957fe5b14156101f75761015a8583815181106101ce57fe5b6020026020010151600001518684815181106101e657fe5b6020026020010151604001516109ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611539565b506001016100de565b507f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb67383838360405161026693929190611282565b60405180910390a16102788282610acb565b505050565b6000610287610302565b60048101805473ffffffffffffffffffffffffffffffffffffffff8581167fffffffffffffffffffffffff000000000000000000000000000000000000000083168117909355604051939450169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c90565b6000815111610361576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b600061036b610302565b905073ffffffffffffffffffffffffffffffffffffffff83166103ba576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166104ab5761040d8460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106104c557fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff168015610554576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906116e2565b5073ffffffffffffffffffffffffffffffffffffffff86166000818152600186810160209081526040808420805480850182559085528285206008820401805463ffffffff60079093166004026101000a928302191660e089901c929092029190911790557fffffffff00000000000000000000000000000000000000000000000000000000909516835287905292902080547fffffffffffffffffffffffff0000000000000000000000000000000000000000169091177fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff86160217905591820191016104ae565b5050505050565b6000815111610699576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006106a3610302565b905073ffffffffffffffffffffffffffffffffffffffff83166106f2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166107e3576107458460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106107fd57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff908116908716811415610892576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061173f565b61089c8183610cbc565b507fffffffff00000000000000000000000000000000000000000000000000000000811660008181526020868152604080832080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8a160217815573ffffffffffffffffffffffffffffffffffffffff8b168085526001808b018552928520805480850182559086528486206008820401805463ffffffff60079093166004026101000a928302191660e09990991c91909102979097179096559390925286905281547fffffffffffffffffffffffff000000000000000000000000000000000000000016909217905591820191016107e6565b60008151116109e6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006109f0610302565b905073ffffffffffffffffffffffffffffffffffffffff831615610a40576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061179c565b60005b8251811015610ac5576000838281518110610a5a57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529185905260409091205490915073ffffffffffffffffffffffffffffffffffffffff16610abb8183610cbc565b5050600101610a43565b50505050565b73ffffffffffffffffffffffffffffffffffffffff8216610b2457805115610b1f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906113c5565b610c7d565b6000815111610b5f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611628565b73ffffffffffffffffffffffffffffffffffffffff82163014610b9e57610b9e8260405180606001604052806028815260200161182660289139610c81565b6000808373ffffffffffffffffffffffffffffffffffffffff1683604051610bc69190611266565b600060405180830381855af49150503d8060008114610c01576040519150601f19603f3d011682016040523d82523d6000602084013e610c06565b606091505b509150915081610ac557805115610c4b57806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611422565b5050565b813b8181610ac5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6000610cc6610302565b905073ffffffffffffffffffffffffffffffffffffffff8316610d15576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906114dc565b73ffffffffffffffffffffffffffffffffffffffff8316301415610d65576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611685565b7fffffffff0000000000000000000000000000000000000000000000000000000082166000908152602082815260408083205473ffffffffffffffffffffffffffffffffffffffff8716845260018501909252909120547401000000000000000000000000000000000000000090910461ffff16907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01808214610f375773ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260408120805483908110610e3657fe5b6000918252602080832060088304015473ffffffffffffffffffffffffffffffffffffffff8a168452600188019091526040909220805460079092166004026101000a90920460e01b925082919085908110610e8e57fe5b600091825260208083206008830401805463ffffffff60079094166004026101000a938402191660e09590951c929092029390931790557fffffffff000000000000000000000000000000000000000000000000000000009290921682528490526040902080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8516021790555b73ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260409020805480610f6757fe5b6000828152602080822060087fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90940193840401805463ffffffff600460078716026101000a0219169055919092557fffffffff00000000000000000000000000000000000000000000000000000000861682528490526040902080547fffffffffffffffffffff000000000000000000000000000000000000000000001690558061065757600283015473ffffffffffffffffffffffffffffffffffffffff861660009081526001858101602052604090912001547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9091019061ffff1680821461114357600085600201838154811061107e57fe5b60009182526020909120015460028701805473ffffffffffffffffffffffffffffffffffffffff90921692508291849081106110b657fe5b600091825260208083209190910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff9485161790559290911681526001878101909252604090200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff83161790555b8460020180548061115057fe5b6000828152602080822083017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90810180547fffffffffffffffffffffffff000000000000000000000000000000000000000016905590920190925573ffffffffffffffffffffffffffffffffffffffff89168252600187810190915260409091200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000016905550505050505050565b73ffffffffffffffffffffffffffffffffffffffff169052565b600081518084526112348160208601602086016117f9565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b600082516112788184602087016117f9565b9190910192915050565b606080825284518282018190526000919060809081850190602080820287018401818b01875b8481101561137c577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff808a8403018652815188840173ffffffffffffffffffffffffffffffffffffffff8251168552858201516003811061130457fe5b858701526040918201519185018a9052815190819052908501908a90898601905b808310156113675783517fffffffff00000000000000000000000000000000000000000000000000000000168252928701926001929092019190870190611325565b509786019794505050908301906001016112a8565b505061138a8289018b611202565b878103604089015261139c818a61121c565b9b9a5050505050505050505050565b6000602082526113be602083018461121c565b9392505050565b6020808252603c908201527f4c69624469616d6f6e644375743a205f696e697420697320616464726573732860408201527f3029206275745f63616c6c64617461206973206e6f7420656d70747900000000606082015260800190565b60208082526026908201527f4c69624469616d6f6e644375743a205f696e69742066756e6374696f6e20726560408201527f7665727465640000000000000000000000000000000000000000000000000000606082015260800190565b6020808252602b908201527f4c69624469616d6f6e644375743a204e6f2073656c6563746f727320696e206660408201527f6163657420746f20637574000000000000000000000000000000000000000000606082015260800190565b60208082526037908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f76652066756e6360408201527f74696f6e207468617420646f65736e2774206578697374000000000000000000606082015260800190565b60208082526027908201527f4c69624469616d6f6e644375743a20496e636f7272656374204661636574437560408201527f74416374696f6e00000000000000000000000000000000000000000000000000606082015260800190565b6020808252602c908201527f4c69624469616d6f6e644375743a204164642066616365742063616e2774206260408201527f6520616464726573732830290000000000000000000000000000000000000000606082015260800190565b6020808252818101527f4469616d6f6e643a2046756e6374696f6e20646f6573206e6f74206578697374604082015260600190565b6020808252603d908201527f4c69624469616d6f6e644375743a205f63616c6c6461746120697320656d707460408201527f7920627574205f696e6974206973206e6f742061646472657373283029000000606082015260800190565b6020808252602e908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f766520696d6d7560408201527f7461626c652066756e6374696f6e000000000000000000000000000000000000606082015260800190565b60208082526035908201527f4c69624469616d6f6e644375743a2043616e2774206164642066756e6374696f60408201527f6e207468617420616c7265616479206578697374730000000000000000000000606082015260800190565b60208082526038908201527f4c69624469616d6f6e644375743a2043616e2774207265706c6163652066756e60408201527f6374696f6e20776974682073616d652066756e6374696f6e0000000000000000606082015260800190565b60208082526036908201527f4c69624469616d6f6e644375743a2052656d6f7665206661636574206164647260408201527f657373206d757374206265206164647265737328302900000000000000000000606082015260800190565b60005b838110156118145781810151838201526020016117fc565b83811115610ac5575050600091015256fe4c69624469616d6f6e644375743a205f696e6974206164647265737320686173206e6f20636f64654c69624469616d6f6e644375743a204e657720666163657420686173206e6f20636f6465a264697066735822122054a3c3a118803545231f43700030cb5e290869be0182196a4a05e7d4a1b71d7e64736f6c634300070600334c69624469616d6f6e644375743a205f696e6974206164647265737320686173206e6f20636f64654c69624469616d6f6e644375743a204e657720666163657420686173206e6f20636f6465", + "deployedBytecode": "0x60806040523661000b57005b600080357fffffffff000000000000000000000000000000000000000000000000000000001681527fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c6020819052604090912054819073ffffffffffffffffffffffffffffffffffffffff16806100b7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906115f3565b60405180910390fd5b3660008037600080366000845af43d6000803e8080156100d6573d6000f35b3d6000fd5b60005b83518110156102325760008482815181106100f557fe5b60200260200101516020015190506000600281111561011057fe5b81600281111561011c57fe5b141561015f5761015a85838151811061013157fe5b60200260200101516000015186848151811061014957fe5b602002602001015160400151610326565b610229565b600181600281111561016d57fe5b14156101ab5761015a85838151811061018257fe5b60200260200101516000015186848151811061019a57fe5b60200260200101516040015161065e565b60028160028111156101b957fe5b14156101f75761015a8583815181106101ce57fe5b6020026020010151600001518684815181106101e657fe5b6020026020010151604001516109ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611539565b506001016100de565b507f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb67383838360405161026693929190611282565b60405180910390a16102788282610acb565b505050565b6000610287610302565b60048101805473ffffffffffffffffffffffffffffffffffffffff8581167fffffffffffffffffffffffff000000000000000000000000000000000000000083168117909355604051939450169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c90565b6000815111610361576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b600061036b610302565b905073ffffffffffffffffffffffffffffffffffffffff83166103ba576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166104ab5761040d8460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106104c557fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff168015610554576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906116e2565b5073ffffffffffffffffffffffffffffffffffffffff86166000818152600186810160209081526040808420805480850182559085528285206008820401805463ffffffff60079093166004026101000a928302191660e089901c929092029190911790557fffffffff00000000000000000000000000000000000000000000000000000000909516835287905292902080547fffffffffffffffffffffffff0000000000000000000000000000000000000000169091177fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff86160217905591820191016104ae565b5050505050565b6000815111610699576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006106a3610302565b905073ffffffffffffffffffffffffffffffffffffffff83166106f2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166107e3576107458460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106107fd57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff908116908716811415610892576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061173f565b61089c8183610cbc565b507fffffffff00000000000000000000000000000000000000000000000000000000811660008181526020868152604080832080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8a160217815573ffffffffffffffffffffffffffffffffffffffff8b168085526001808b018552928520805480850182559086528486206008820401805463ffffffff60079093166004026101000a928302191660e09990991c91909102979097179096559390925286905281547fffffffffffffffffffffffff000000000000000000000000000000000000000016909217905591820191016107e6565b60008151116109e6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006109f0610302565b905073ffffffffffffffffffffffffffffffffffffffff831615610a40576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061179c565b60005b8251811015610ac5576000838281518110610a5a57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529185905260409091205490915073ffffffffffffffffffffffffffffffffffffffff16610abb8183610cbc565b5050600101610a43565b50505050565b73ffffffffffffffffffffffffffffffffffffffff8216610b2457805115610b1f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906113c5565b610c7d565b6000815111610b5f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611628565b73ffffffffffffffffffffffffffffffffffffffff82163014610b9e57610b9e8260405180606001604052806028815260200161182660289139610c81565b6000808373ffffffffffffffffffffffffffffffffffffffff1683604051610bc69190611266565b600060405180830381855af49150503d8060008114610c01576040519150601f19603f3d011682016040523d82523d6000602084013e610c06565b606091505b509150915081610ac557805115610c4b57806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611422565b5050565b813b8181610ac5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6000610cc6610302565b905073ffffffffffffffffffffffffffffffffffffffff8316610d15576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906114dc565b73ffffffffffffffffffffffffffffffffffffffff8316301415610d65576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611685565b7fffffffff0000000000000000000000000000000000000000000000000000000082166000908152602082815260408083205473ffffffffffffffffffffffffffffffffffffffff8716845260018501909252909120547401000000000000000000000000000000000000000090910461ffff16907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01808214610f375773ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260408120805483908110610e3657fe5b6000918252602080832060088304015473ffffffffffffffffffffffffffffffffffffffff8a168452600188019091526040909220805460079092166004026101000a90920460e01b925082919085908110610e8e57fe5b600091825260208083206008830401805463ffffffff60079094166004026101000a938402191660e09590951c929092029390931790557fffffffff000000000000000000000000000000000000000000000000000000009290921682528490526040902080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8516021790555b73ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260409020805480610f6757fe5b6000828152602080822060087fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90940193840401805463ffffffff600460078716026101000a0219169055919092557fffffffff00000000000000000000000000000000000000000000000000000000861682528490526040902080547fffffffffffffffffffff000000000000000000000000000000000000000000001690558061065757600283015473ffffffffffffffffffffffffffffffffffffffff861660009081526001858101602052604090912001547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9091019061ffff1680821461114357600085600201838154811061107e57fe5b60009182526020909120015460028701805473ffffffffffffffffffffffffffffffffffffffff90921692508291849081106110b657fe5b600091825260208083209190910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff9485161790559290911681526001878101909252604090200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff83161790555b8460020180548061115057fe5b6000828152602080822083017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90810180547fffffffffffffffffffffffff000000000000000000000000000000000000000016905590920190925573ffffffffffffffffffffffffffffffffffffffff89168252600187810190915260409091200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000016905550505050505050565b73ffffffffffffffffffffffffffffffffffffffff169052565b600081518084526112348160208601602086016117f9565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b600082516112788184602087016117f9565b9190910192915050565b606080825284518282018190526000919060809081850190602080820287018401818b01875b8481101561137c577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff808a8403018652815188840173ffffffffffffffffffffffffffffffffffffffff8251168552858201516003811061130457fe5b858701526040918201519185018a9052815190819052908501908a90898601905b808310156113675783517fffffffff00000000000000000000000000000000000000000000000000000000168252928701926001929092019190870190611325565b509786019794505050908301906001016112a8565b505061138a8289018b611202565b878103604089015261139c818a61121c565b9b9a5050505050505050505050565b6000602082526113be602083018461121c565b9392505050565b6020808252603c908201527f4c69624469616d6f6e644375743a205f696e697420697320616464726573732860408201527f3029206275745f63616c6c64617461206973206e6f7420656d70747900000000606082015260800190565b60208082526026908201527f4c69624469616d6f6e644375743a205f696e69742066756e6374696f6e20726560408201527f7665727465640000000000000000000000000000000000000000000000000000606082015260800190565b6020808252602b908201527f4c69624469616d6f6e644375743a204e6f2073656c6563746f727320696e206660408201527f6163657420746f20637574000000000000000000000000000000000000000000606082015260800190565b60208082526037908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f76652066756e6360408201527f74696f6e207468617420646f65736e2774206578697374000000000000000000606082015260800190565b60208082526027908201527f4c69624469616d6f6e644375743a20496e636f7272656374204661636574437560408201527f74416374696f6e00000000000000000000000000000000000000000000000000606082015260800190565b6020808252602c908201527f4c69624469616d6f6e644375743a204164642066616365742063616e2774206260408201527f6520616464726573732830290000000000000000000000000000000000000000606082015260800190565b6020808252818101527f4469616d6f6e643a2046756e6374696f6e20646f6573206e6f74206578697374604082015260600190565b6020808252603d908201527f4c69624469616d6f6e644375743a205f63616c6c6461746120697320656d707460408201527f7920627574205f696e6974206973206e6f742061646472657373283029000000606082015260800190565b6020808252602e908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f766520696d6d7560408201527f7461626c652066756e6374696f6e000000000000000000000000000000000000606082015260800190565b60208082526035908201527f4c69624469616d6f6e644375743a2043616e2774206164642066756e6374696f60408201527f6e207468617420616c7265616479206578697374730000000000000000000000606082015260800190565b60208082526038908201527f4c69624469616d6f6e644375743a2043616e2774207265706c6163652066756e60408201527f6374696f6e20776974682073616d652066756e6374696f6e0000000000000000606082015260800190565b60208082526036908201527f4c69624469616d6f6e644375743a2052656d6f7665206661636574206164647260408201527f657373206d757374206265206164647265737328302900000000000000000000606082015260800190565b60005b838110156118145781810151838201526020016117fc565b83811115610ac5575050600091015256fe4c69624469616d6f6e644375743a205f696e6974206164647265737320686173206e6f20636f64654c69624469616d6f6e644375743a204e657720666163657420686173206e6f20636f6465a264697066735822122054a3c3a118803545231f43700030cb5e290869be0182196a4a05e7d4a1b71d7e64736f6c63430007060033", + "facets": [ + ["0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", ["0x1f931c1c"]], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + ["0xadfca15e", "0x7a0ed627", "0xcdffacc6", "0x52ef6b2c", "0x01ffc9a7"] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x03655Add6798b6a8B9b2756E59486Cea85e8ba24", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0x31D88294E48f70233bE242A524B0bebb0d155BC4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3F4e01c435433CfF56Cc7e6A054Fe210EFd06645", + "functionSelectors": ["0xc76d202d", "0x839bb9a6", "0x8e756bb3"] + }, + { + "facetAddress": "0x85FD223609f69b8aB88383F8c9FA6a37d38582CC", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x1Ac15086EFeFb7aa04A6a39f3F4b83608103D2fA", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xa6682e09318c47832D95f202b177Edb397a8a342", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x07B24e3192B05FE37842F5C71aEEa7d726a3caD5", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xcA79e8EEAe776AFfC65f539d6cdA998a76b250FE", + "functionSelectors": ["0x9912dde8", "0x5a601668", "0x8a4f4f92"] + }, + { + "facetAddress": "0xAf60235Bc891Aa08776E59Eb6c123fd21A38E750", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x05a4C38216C33F2BC454309cc4F8464A6fB36f96", + "functionSelectors": ["0xea40e51a", "0xfe5d095b"] + }, + { + "facetAddress": "0xFC11f4ebe9f7c7399464c82825A0B8678fdc4cff", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xe6fc54F4e4346b03636a0911Efd51ECa21242Bb7", + "functionSelectors": [ + "0x46e04a2f", + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0xc3cB507553f192879c74879102fBB80286bcf12F", + "functionSelectors": ["0x2239f556", "0x46efd16c", "0x78b248e4"] + }, + { + "facetAddress": "0x02ab15bE170EB83801E0d85365Bc2103c3a3d48A", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x987df220", + "0x0f48a482" + ] + }, + { + "facetAddress": "0xFc7c599947DCa76440DD3729a1292190C645Eb92", + "functionSelectors": ["0x71d78fbc", "0xf6376124", "0x33c72dfe"] + }, + { + "facetAddress": "0x5B5481Ad34b79D8e920B5F0f83d718ED225A7102", + "functionSelectors": ["0x262201b6"] + }, + { + "facetAddress": "0x2966b694D1642392CD759B8d8D316B55eaE7aA69", + "functionSelectors": ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"] + } + ], + "diamondCut": [ + { + "facetAddress": "0x05a4C38216C33F2BC454309cc4F8464A6fB36f96", + "functionSelectors": ["0xea40e51a", "0xfe5d095b"], + "action": 1 + }, + { + "facetAddress": "0xe6fc54F4e4346b03636a0911Efd51ECa21242Bb7", + "functionSelectors": [ + "0x46e04a2f", + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 1 + }, + { + "facetAddress": "0x02ab15bE170EB83801E0d85365Bc2103c3a3d48A", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x987df220", + "0x0f48a482" + ], + "action": 1 + } + ], + "history": [ + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "5530229", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000020000020000008000000840000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000008000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000420000000000000000000000000000000000000000000000000000000000000008000", + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "args": ["0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0"], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "blockNumber": 25103807, + "cumulativeGasUsed": "5530229", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": ["0xc76d202d", "0x839bb9a6", "0x8e756bb3"], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": ["0x9912dde8", "0x5a601668", "0x8a4f4f92"], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": ["0xce6e9f9f", "0x02bc2cdb", "0x0448a5c4"], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": ["0x2239f556", "0x46efd16c", "0x78b248e4"], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": ["0x71d78fbc", "0xf6376124", "0x33c72dfe"], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": ["0xc76d202d", "0x839bb9a6", "0x8e756bb3"] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": ["0x9912dde8", "0x5a601668", "0x8a4f4f92"] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": ["0xce6e9f9f", "0x02bc2cdb", "0x0448a5c4"] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": ["0x2239f556", "0x46efd16c", "0x78b248e4"] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": ["0x71d78fbc", "0xf6376124", "0x33c72dfe"] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": ["0xc76d202d", "0x839bb9a6", "0x8e756bb3"], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": ["0x9912dde8", "0x5a601668", "0x8a4f4f92"], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": ["0xce6e9f9f", "0x02bc2cdb", "0x0448a5c4"], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": ["0x2239f556", "0x46efd16c", "0x78b248e4"], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": ["0x71d78fbc", "0xf6376124", "0x33c72dfe"], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0x61460874a7196d6a22d1ee4922473664b3e95270" + }, + { + "sym": "ADAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "PCDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "YDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "WETH", + "addr": "0xd0a1e359811322d97991e03f863a0c30c2cf029c" + }, + { + "sym": "DAI", + "addr": "0x4f96fe3b7a6cf9725f59d353f723c1bdb64ca6aa" + }, + { + "sym": "USDC", + "addr": "0xb7a4f3e9097c08da09517b5ab877f7a917224ede" + }, + { + "sym": "LINK", + "addr": "0xa36085F69e2889c224210F603D836748e7dC0088" + } + ], + "cTokens": [ + "0xf0d0eb522cfa50b716b3b1604c4f0fa6f04376ad", + "0x4a92e71227d294f041bd82dd8f78591b75140d63", + "0x41b5844f4680a8c38fbb695b7f9cfd1f64474a72" + ], + "tellerNFT": "0x7360904A663B9Cb66baB538F406C04D8da86229d", + "loansEscrowBeacon": "0xAb59409415e28deEb6255ba64527E3271D057FED", + "collateralEscrowBeacon": "0x7cCb2ddB4f7a239CA9edF765edC0bb4e7e04Ef5F", + "tTokenBeacon": "0x18D45BC9319937d2099Dc8e0D0EdCEEe033fCf25", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "receipt": { + "to": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "204539", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000000000000000000000000040000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb", + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25104070, + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000617bf3ec25f4b04ca986ae559ed37be7f68cccad0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25104070, + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000617bf3ec25f4b04ca986ae559ed37be7f68cccad0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb", + "args": [ + [ + [ + "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + 0, + ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"] + ] + ], + "0x0000000000000000000000000000000000000000", + "0x" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 25104070, + "cumulativeGasUsed": "204539", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "0x608060405260405162002d4538038062002d45833981016040819052620000269162000db2565b604080516000808252602082019092526200004e918491620000f560201b620000db1760201c565b620000688160000151620002b560201b6200027d1760201c565b60006200007f6200031760201b620003021760201c565b6301ffc9a760e01b600090815260039091016020526040808220805460ff1990811660019081179092556307e4c70760e21b845282842080548216831790556348e2b09360e01b845282842080548216831790556307f5828d60e41b845291909220805490911690911790555062001442915050565b60005b8351811015620002665760008482815181106200011157fe5b6020026020010151602001519050600060028111156200012d57fe5b8160028111156200013a57fe5b14156200018957620001838583815181106200015257fe5b6020026020010151600001518684815181106200016b57fe5b6020026020010151604001516200033b60201b60201c565b6200025c565b60018160028111156200019857fe5b1415620001e15762000183858381518110620001b057fe5b602002602001015160000151868481518110620001c957fe5b6020026020010151604001516200054e60201b60201c565b6002816002811115620001f057fe5b14156200023957620001838583815181106200020857fe5b6020026020010151600001518684815181106200022157fe5b6020026020010151604001516200077860201b60201c565b60405162461bcd60e51b815260040162000253906200117c565b60405180910390fd5b50600101620000f8565b507f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb6738383836040516200029c9392919062000f25565b60405180910390a1620002b082826200083f565b505050565b6000620002c162000317565b6004810180546001600160a01b038581166001600160a01b031983168117909355604051939450169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c90565b60008151116200035f5760405162461bcd60e51b81526004016200025390620010d4565b60006200036b62000317565b90506001600160a01b038316620003965760405162461bcd60e51b81526004016200025390620011c3565b6001600160a01b038316600090815260018201602052604090205461ffff81166200043c57620003e08460405180606001604052806024815260200162002d21602491396200097c565b6002820180546001600160a01b038616600081815260018087016020908152604083208201805461ffff191661ffff90961695909517909455845490810185559381529190912090910180546001600160a01b03191690911790555b60005b8351811015620005475760008482815181106200045857fe5b6020908102919091018101516001600160e01b031981166000908152918690526040909120549091506001600160a01b03168015620004ab5760405162461bcd60e51b81526004016200025390620012ba565b506001600160a01b0386166000818152600186810160209081526040808420805480850182559085528285206008820401805463ffffffff60079093166004026101000a928302191660e089901c929092029190911790556001600160e01b0319909516835287905292902080546001600160a01b03191690911761ffff60a01b1916600160a01b61ffff86160217905591820191016200043f565b5050505050565b6000815111620005725760405162461bcd60e51b81526004016200025390620010d4565b60006200057e62000317565b90506001600160a01b038316620005a95760405162461bcd60e51b81526004016200025390620011c3565b6001600160a01b038316600090815260018201602052604090205461ffff81166200064f57620005f38460405180606001604052806024815260200162002d21602491396200097c565b6002820180546001600160a01b038616600081815260018087016020908152604083208201805461ffff191661ffff90961695909517909455845490810185559381529190912090910180546001600160a01b03191690911790555b60005b8351811015620005475760008482815181106200066b57fe5b6020908102919091018101516001600160e01b031981166000908152918690526040909120549091506001600160a01b03908116908716811415620006c45760405162461bcd60e51b8152600401620002539062001317565b620006d08183620009a0565b506001600160e01b03198116600081815260208681526040808320805461ffff60a01b1916600160a01b61ffff8a16021781556001600160a01b038b168085526001808b018552928520805480850182559086528486206008820401805463ffffffff60079093166004026101000a928302191660e09990991c91909102979097179096559390925286905281546001600160a01b0319169092179055918201910162000652565b60008151116200079c5760405162461bcd60e51b81526004016200025390620010d4565b6000620007a862000317565b90506001600160a01b03831615620007d45760405162461bcd60e51b8152600401620002539062001374565b60005b825181101562000839576000838281518110620007f057fe5b6020908102919091018101516001600160e01b031981166000908152918590526040909120549091506001600160a01b03166200082e8183620009a0565b5050600101620007d7565b50505050565b6001600160a01b0382166200087657805115620008705760405162461bcd60e51b8152600401620002539062001031565b62000978565b60008151116200089a5760405162461bcd60e51b815260040162000253906200120f565b6001600160a01b0382163014620008d057620008d08260405180606001604052806028815260200162002cf9602891396200097c565b600080836001600160a01b031683604051620008ed919062000f07565b600060405180830381855af49150503d80600081146200092a576040519150601f19603f3d011682016040523d82523d6000602084013e6200092f565b606091505b50915091508162000839578051156200095e578060405162461bcd60e51b815260040162000253919062001015565b60405162461bcd60e51b815260040162000253906200108e565b5050565b813b8181620008395760405162461bcd60e51b815260040162000253919062001015565b6000620009ac62000317565b90506001600160a01b038316620009d75760405162461bcd60e51b815260040162000253906200111f565b6001600160a01b03831630141562000a035760405162461bcd60e51b815260040162000253906200126c565b6001600160e01b03198216600090815260208281526040808320546001600160a01b03871684526001850190925290912054600160a01b90910461ffff16906000190180821462000b27576001600160a01b0385166000908152600184016020526040812080548390811062000a7557fe5b600091825260208083206008830401546001600160a01b038a168452600188019091526040909220805460079092166004026101000a90920460e01b92508291908590811062000ac157fe5b600091825260208083206008830401805463ffffffff60079094166004026101000a938402191660e09590951c929092029390931790556001600160e01b031992909216825284905260409020805461ffff60a01b1916600160a01b61ffff8516021790555b6001600160a01b0385166000908152600184016020526040902080548062000b4b57fe5b60008281526020808220600860001990940193840401805463ffffffff600460078716026101000a0219169055919092556001600160e01b0319861682528490526040902080546001600160b01b031916905580620005475760028301546001600160a01b03861660009081526001858101602052604090912001546000199091019061ffff1680821462000c6357600085600201838154811062000bec57fe5b6000918252602090912001546002870180546001600160a01b03909216925082918490811062000c1857fe5b600091825260208083209190910180546001600160a01b0319166001600160a01b0394851617905592909116815260018781019092526040902001805461ffff191661ffff83161790555b8460020180548062000c7157fe5b60008281526020808220830160001990810180546001600160a01b03191690559092019092556001600160a01b03891682526001878101909152604090912001805461ffff1916905550505050505050565b80516001600160a01b038116811462000cdb57600080fd5b919050565b600082601f83011262000cf1578081fd5b8151602062000d0a62000d0483620013f5565b620013d1565b828152818101908583018385028701840188101562000d27578586fd5b855b8581101562000d5d5781516001600160e01b03198116811462000d4a578788fd5b8452928401929084019060010162000d29565b5090979650505050505050565b60006020828403121562000d7c578081fd5b604051602081016001600160401b038111828210171562000d9957fe5b60405290508062000daa8362000cc3565b905292915050565b6000806040838503121562000dc5578182fd5b82516001600160401b038082111562000ddc578384fd5b818501915085601f83011262000df0578384fd5b8151602062000e0362000d0483620013f5565b82815281810190858301885b8581101562000eaa57815188016060818e03601f1901121562000e30578a8bfd5b604051606081018181108a8211171562000e4657fe5b60405262000e5682880162000cc3565b815260408201516003811062000e6a578c8dfd5b8188015260608201518981111562000e80578c8dfd5b62000e908f898386010162000ce0565b604083015250855250928401929084019060010162000e0f565b5050809750505062000ebf8882890162000d6a565b9450505050509250929050565b6001600160a01b03169052565b6000815180845262000ef381602086016020860162001413565b601f01601f19169290920160200192915050565b6000825162000f1b81846020870162001413565b9190910192915050565b606080825284518282018190526000919060809081850190602080820287018401818b01875b8481101562000fe257898303607f19018652815180516001600160a01b0316845284810151898501906003811062000f7f57fe5b858701526040918201519185018a9052815190819052908501908a90898601905b8083101562000fcc5783516001600160e01b031916825292870192600192909201919087019062000fa0565b5097860197945050509083019060010162000f4b565b505062000ff28289018b62000ecc565b878103604089015262001006818a62000ed9565b9b9a5050505050505050505050565b6000602082526200102a602083018462000ed9565b9392505050565b6020808252603c908201527f4c69624469616d6f6e644375743a205f696e697420697320616464726573732860408201527f3029206275745f63616c6c64617461206973206e6f7420656d70747900000000606082015260800190565b60208082526026908201527f4c69624469616d6f6e644375743a205f696e69742066756e6374696f6e2072656040820152651d995c9d195960d21b606082015260800190565b6020808252602b908201527f4c69624469616d6f6e644375743a204e6f2073656c6563746f727320696e206660408201526a1858d95d081d1bc818dd5d60aa1b606082015260800190565b60208082526037908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f76652066756e6360408201527f74696f6e207468617420646f65736e2774206578697374000000000000000000606082015260800190565b60208082526027908201527f4c69624469616d6f6e644375743a20496e636f727265637420466163657443756040820152663a20b1ba34b7b760c91b606082015260800190565b6020808252602c908201527f4c69624469616d6f6e644375743a204164642066616365742063616e2774206260408201526b65206164647265737328302960a01b606082015260800190565b6020808252603d908201527f4c69624469616d6f6e644375743a205f63616c6c6461746120697320656d707460408201527f7920627574205f696e6974206973206e6f742061646472657373283029000000606082015260800190565b6020808252602e908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f766520696d6d7560408201526d3a30b1363290333ab731ba34b7b760911b606082015260800190565b60208082526035908201527f4c69624469616d6f6e644375743a2043616e2774206164642066756e6374696f60408201527f6e207468617420616c7265616479206578697374730000000000000000000000606082015260800190565b60208082526038908201527f4c69624469616d6f6e644375743a2043616e2774207265706c6163652066756e60408201527f6374696f6e20776974682073616d652066756e6374696f6e0000000000000000606082015260800190565b60208082526036908201527f4c69624469616d6f6e644375743a2052656d6f7665206661636574206164647260408201527f657373206d757374206265206164647265737328302900000000000000000000606082015260800190565b6040518181016001600160401b0381118282101715620013ed57fe5b604052919050565b60006001600160401b038211156200140957fe5b5060209081020190565b60005b838110156200143057818101518382015260200162001416565b83811115620008395750506000910152565b6118a780620014526000396000f3fe60806040523661000b57005b600080357fffffffff000000000000000000000000000000000000000000000000000000001681527fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c6020819052604090912054819073ffffffffffffffffffffffffffffffffffffffff16806100b7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906115f3565b60405180910390fd5b3660008037600080366000845af43d6000803e8080156100d6573d6000f35b3d6000fd5b60005b83518110156102325760008482815181106100f557fe5b60200260200101516020015190506000600281111561011057fe5b81600281111561011c57fe5b141561015f5761015a85838151811061013157fe5b60200260200101516000015186848151811061014957fe5b602002602001015160400151610326565b610229565b600181600281111561016d57fe5b14156101ab5761015a85838151811061018257fe5b60200260200101516000015186848151811061019a57fe5b60200260200101516040015161065e565b60028160028111156101b957fe5b14156101f75761015a8583815181106101ce57fe5b6020026020010151600001518684815181106101e657fe5b6020026020010151604001516109ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611539565b506001016100de565b507f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb67383838360405161026693929190611282565b60405180910390a16102788282610acb565b505050565b6000610287610302565b60048101805473ffffffffffffffffffffffffffffffffffffffff8581167fffffffffffffffffffffffff000000000000000000000000000000000000000083168117909355604051939450169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c90565b6000815111610361576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b600061036b610302565b905073ffffffffffffffffffffffffffffffffffffffff83166103ba576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166104ab5761040d8460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106104c557fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff168015610554576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906116e2565b5073ffffffffffffffffffffffffffffffffffffffff86166000818152600186810160209081526040808420805480850182559085528285206008820401805463ffffffff60079093166004026101000a928302191660e089901c929092029190911790557fffffffff00000000000000000000000000000000000000000000000000000000909516835287905292902080547fffffffffffffffffffffffff0000000000000000000000000000000000000000169091177fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff86160217905591820191016104ae565b5050505050565b6000815111610699576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006106a3610302565b905073ffffffffffffffffffffffffffffffffffffffff83166106f2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166107e3576107458460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106107fd57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff908116908716811415610892576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061173f565b61089c8183610cbc565b507fffffffff00000000000000000000000000000000000000000000000000000000811660008181526020868152604080832080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8a160217815573ffffffffffffffffffffffffffffffffffffffff8b168085526001808b018552928520805480850182559086528486206008820401805463ffffffff60079093166004026101000a928302191660e09990991c91909102979097179096559390925286905281547fffffffffffffffffffffffff000000000000000000000000000000000000000016909217905591820191016107e6565b60008151116109e6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006109f0610302565b905073ffffffffffffffffffffffffffffffffffffffff831615610a40576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061179c565b60005b8251811015610ac5576000838281518110610a5a57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529185905260409091205490915073ffffffffffffffffffffffffffffffffffffffff16610abb8183610cbc565b5050600101610a43565b50505050565b73ffffffffffffffffffffffffffffffffffffffff8216610b2457805115610b1f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906113c5565b610c7d565b6000815111610b5f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611628565b73ffffffffffffffffffffffffffffffffffffffff82163014610b9e57610b9e8260405180606001604052806028815260200161182660289139610c81565b6000808373ffffffffffffffffffffffffffffffffffffffff1683604051610bc69190611266565b600060405180830381855af49150503d8060008114610c01576040519150601f19603f3d011682016040523d82523d6000602084013e610c06565b606091505b509150915081610ac557805115610c4b57806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611422565b5050565b813b8181610ac5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6000610cc6610302565b905073ffffffffffffffffffffffffffffffffffffffff8316610d15576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906114dc565b73ffffffffffffffffffffffffffffffffffffffff8316301415610d65576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611685565b7fffffffff0000000000000000000000000000000000000000000000000000000082166000908152602082815260408083205473ffffffffffffffffffffffffffffffffffffffff8716845260018501909252909120547401000000000000000000000000000000000000000090910461ffff16907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01808214610f375773ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260408120805483908110610e3657fe5b6000918252602080832060088304015473ffffffffffffffffffffffffffffffffffffffff8a168452600188019091526040909220805460079092166004026101000a90920460e01b925082919085908110610e8e57fe5b600091825260208083206008830401805463ffffffff60079094166004026101000a938402191660e09590951c929092029390931790557fffffffff000000000000000000000000000000000000000000000000000000009290921682528490526040902080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8516021790555b73ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260409020805480610f6757fe5b6000828152602080822060087fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90940193840401805463ffffffff600460078716026101000a0219169055919092557fffffffff00000000000000000000000000000000000000000000000000000000861682528490526040902080547fffffffffffffffffffff000000000000000000000000000000000000000000001690558061065757600283015473ffffffffffffffffffffffffffffffffffffffff861660009081526001858101602052604090912001547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9091019061ffff1680821461114357600085600201838154811061107e57fe5b60009182526020909120015460028701805473ffffffffffffffffffffffffffffffffffffffff90921692508291849081106110b657fe5b600091825260208083209190910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff9485161790559290911681526001878101909252604090200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff83161790555b8460020180548061115057fe5b6000828152602080822083017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90810180547fffffffffffffffffffffffff000000000000000000000000000000000000000016905590920190925573ffffffffffffffffffffffffffffffffffffffff89168252600187810190915260409091200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000016905550505050505050565b73ffffffffffffffffffffffffffffffffffffffff169052565b600081518084526112348160208601602086016117f9565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b600082516112788184602087016117f9565b9190910192915050565b606080825284518282018190526000919060809081850190602080820287018401818b01875b8481101561137c577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff808a8403018652815188840173ffffffffffffffffffffffffffffffffffffffff8251168552858201516003811061130457fe5b858701526040918201519185018a9052815190819052908501908a90898601905b808310156113675783517fffffffff00000000000000000000000000000000000000000000000000000000168252928701926001929092019190870190611325565b509786019794505050908301906001016112a8565b505061138a8289018b611202565b878103604089015261139c818a61121c565b9b9a5050505050505050505050565b6000602082526113be602083018461121c565b9392505050565b6020808252603c908201527f4c69624469616d6f6e644375743a205f696e697420697320616464726573732860408201527f3029206275745f63616c6c64617461206973206e6f7420656d70747900000000606082015260800190565b60208082526026908201527f4c69624469616d6f6e644375743a205f696e69742066756e6374696f6e20726560408201527f7665727465640000000000000000000000000000000000000000000000000000606082015260800190565b6020808252602b908201527f4c69624469616d6f6e644375743a204e6f2073656c6563746f727320696e206660408201527f6163657420746f20637574000000000000000000000000000000000000000000606082015260800190565b60208082526037908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f76652066756e6360408201527f74696f6e207468617420646f65736e2774206578697374000000000000000000606082015260800190565b60208082526027908201527f4c69624469616d6f6e644375743a20496e636f7272656374204661636574437560408201527f74416374696f6e00000000000000000000000000000000000000000000000000606082015260800190565b6020808252602c908201527f4c69624469616d6f6e644375743a204164642066616365742063616e2774206260408201527f6520616464726573732830290000000000000000000000000000000000000000606082015260800190565b6020808252818101527f4469616d6f6e643a2046756e6374696f6e20646f6573206e6f74206578697374604082015260600190565b6020808252603d908201527f4c69624469616d6f6e644375743a205f63616c6c6461746120697320656d707460408201527f7920627574205f696e6974206973206e6f742061646472657373283029000000606082015260800190565b6020808252602e908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f766520696d6d7560408201527f7461626c652066756e6374696f6e000000000000000000000000000000000000606082015260800190565b60208082526035908201527f4c69624469616d6f6e644375743a2043616e2774206164642066756e6374696f60408201527f6e207468617420616c7265616479206578697374730000000000000000000000606082015260800190565b60208082526038908201527f4c69624469616d6f6e644375743a2043616e2774207265706c6163652066756e60408201527f6374696f6e20776974682073616d652066756e6374696f6e0000000000000000606082015260800190565b60208082526036908201527f4c69624469616d6f6e644375743a2052656d6f7665206661636574206164647260408201527f657373206d757374206265206164647265737328302900000000000000000000606082015260800190565b60005b838110156118145781810151838201526020016117fc565b83811115610ac5575050600091015256fe4c69624469616d6f6e644375743a205f696e6974206164647265737320686173206e6f20636f64654c69624469616d6f6e644375743a204e657720666163657420686173206e6f20636f6465a264697066735822122054a3c3a118803545231f43700030cb5e290869be0182196a4a05e7d4a1b71d7e64736f6c634300070600334c69624469616d6f6e644375743a205f696e6974206164647265737320686173206e6f20636f64654c69624469616d6f6e644375743a204e657720666163657420686173206e6f20636f6465", + "deployedBytecode": "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", + "facets": [ + ["0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", ["0x1f931c1c"]], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": ["0xc76d202d", "0x839bb9a6", "0x8e756bb3"] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": ["0x9912dde8", "0x5a601668", "0x8a4f4f92"] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": ["0xce6e9f9f", "0x02bc2cdb", "0x0448a5c4"] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": ["0x2239f556", "0x46efd16c", "0x78b248e4"] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": ["0x71d78fbc", "0xf6376124", "0x33c72dfe"] + }, + { + "facetAddress": "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + "functionSelectors": ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + "functionSelectors": ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"], + "action": 0 + } + ], + "history": [ + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "5530229", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000020000020000008000000840000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000008000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000420000000000000000000000000000000000000000000000000000000000000008000", + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "args": ["0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0"], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "blockNumber": 25103807, + "cumulativeGasUsed": "5530229", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0x61460874a7196d6a22d1ee4922473664b3e95270" + }, + { + "sym": "ADAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "PCDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "YDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "WETH", + "addr": "0xd0a1e359811322d97991e03f863a0c30c2cf029c" + }, + { + "sym": "DAI", + "addr": "0x4f96fe3b7a6cf9725f59d353f723c1bdb64ca6aa" + }, + { + "sym": "USDC", + "addr": "0xb7a4f3e9097c08da09517b5ab877f7a917224ede" + }, + { + "sym": "LINK", + "addr": "0xa36085F69e2889c224210F603D836748e7dC0088" + } + ], + "cTokens": [ + "0xf0d0eb522cfa50b716b3b1604c4f0fa6f04376ad", + "0x4a92e71227d294f041bd82dd8f78591b75140d63", + "0x41b5844f4680a8c38fbb695b7f9cfd1f64474a72" + ], + "tellerNFT": "0x7360904A663B9Cb66baB538F406C04D8da86229d", + "loansEscrowBeacon": "0xAb59409415e28deEb6255ba64527E3271D057FED", + "collateralEscrowBeacon": "0x7cCb2ddB4f7a239CA9edF765edC0bb4e7e04Ef5F", + "tTokenBeacon": "0x18D45BC9319937d2099Dc8e0D0EdCEEe033fCf25", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanUserRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanConsensusResponse[]", + "name": "responses", + "type": "tuple[]" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanUserRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanConsensusResponse[]", + "name": "responses", + "type": "tuple[]" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x731e016ac0dea74d300588c8ee2b3c12914b86c01f3b041c572ef2041d3d70eb", + "receipt": { + "to": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "1557011", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000000000000000000000000040000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xa8615f71b8dc8b88fd926aaf7d23e6d3cf8e7dd2d59ef579ab8ab46d14ca38b0", + "transactionHash": "0x731e016ac0dea74d300588c8ee2b3c12914b86c01f3b041c572ef2041d3d70eb", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25347890, + "transactionHash": "0x731e016ac0dea74d300588c8ee2b3c12914b86c01f3b041c572ef2041d3d70eb", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014e000000000000000000000000000000000000000000000000000000000000000130000000000000000000000000000000000000000000000000000000000000260000000000000000000000000000000000000000000000000000000000000034000000000000000000000000000000000000000000000000000000000000004a000000000000000000000000000000000000000000000000000000000000005a000000000000000000000000000000000000000000000000000000000000006800000000000000000000000000000000000000000000000000000000000000780000000000000000000000000000000000000000000000000000000000000084000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000ae00000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000cc00000000000000000000000000000000000000000000000000000000000000e800000000000000000000000000000000000000000000000000000000000000f8000000000000000000000000000000000000000000000000000000000000010600000000000000000000000000000000000000000000000000000000000001160000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000012e000000000000000000000000000000000000000000000000000000000000013800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003ce6e9f9f0000000000000000000000000000000000000000000000000000000002bc2cdb000000000000000000000000000000000000000000000000000000000448a5c40000000000000000000000000000000000000000000000000000000000000000000000000000000003655add6798b6a8b9b2756e59486cea85e8ba2400000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000742f1181e000000000000000000000000000000000000000000000000000000006eade577000000000000000000000000000000000000000000000000000000004dc2304d00000000000000000000000000000000000000000000000000000000ad21879e000000000000000000000000000000000000000000000000000000001cf14f330000000000000000000000000000000000000000000000000000000070712939000000000000000000000000000000000000000000000000000000006e4d22c20000000000000000000000000000000000000000000000000000000000000000000000000000000031d88294e48f70233be242a524b0bebb0d155bc40000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000049dec88b900000000000000000000000000000000000000000000000000000000ce19912900000000000000000000000000000000000000000000000000000000d10a0aec0000000000000000000000000000000000000000000000000000000074b1d75d000000000000000000000000000000000000000000000000000000000000000000000000000000003f4e01c435433cff56cc7e6a054fe210efd06645000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003c76d202d00000000000000000000000000000000000000000000000000000000839bb9a6000000000000000000000000000000000000000000000000000000008e756bb30000000000000000000000000000000000000000000000000000000000000000000000000000000085fd223609f69b8ab88383f8c9fa6a37d38582cc000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004fee2792b00000000000000000000000000000000000000000000000000000000bf6d79ab00000000000000000000000000000000000000000000000000000000c1c52f8800000000000000000000000000000000000000000000000000000000ec1c2bb5000000000000000000000000000000000000000000000000000000000000000000000000000000001ac15086efefb7aa04a6a39f3f4b83608103d2fa000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002241b71bb00000000000000000000000000000000000000000000000000000000bb14516c00000000000000000000000000000000000000000000000000000000000000000000000000000000a6682e09318c47832d95f202b177edb397a8a34200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000235a7206d00000000000000000000000000000000000000000000000000000000c05b1ec30000000000000000000000000000000000000000000000000000000000000000000000000000000007b24e3192b05fe37842f5c71aeea7d726a3cad5000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004961113df0000000000000000000000000000000000000000000000000000000010d94006000000000000000000000000000000000000000000000000000000008fe2b41400000000000000000000000000000000000000000000000000000000020ce3a600000000000000000000000000000000000000000000000000000000000000000000000000000000ca79e8eeae776affc65f539d6cda998a76b250fe0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000039912dde8000000000000000000000000000000000000000000000000000000005a601668000000000000000000000000000000000000000000000000000000008a4f4f9200000000000000000000000000000000000000000000000000000000000000000000000000000000af60235bc891aa08776e59eb6c123fd21a38e75000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000513abaf0700000000000000000000000000000000000000000000000000000000ece1373200000000000000000000000000000000000000000000000000000000ed903f7a00000000000000000000000000000000000000000000000000000000010d573000000000000000000000000000000000000000000000000000000000767a7b0500000000000000000000000000000000000000000000000000000000000000000000000000000000868f7da9164a29801fa58ca0bb6b9c90f497b6ad000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002ea40e51a00000000000000000000000000000000000000000000000000000000461aebf400000000000000000000000000000000000000000000000000000000000000000000000000000000fc11f4ebe9f7c7399464c82825a0b8678fdc4cff00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000aeee8b7ff0000000000000000000000000000000000000000000000000000000072e1132700000000000000000000000000000000000000000000000000000000f4f015700000000000000000000000000000000000000000000000000000000046a384be00000000000000000000000000000000000000000000000000000000e949756100000000000000000000000000000000000000000000000000000000504006ca00000000000000000000000000000000000000000000000000000000c4c1662b00000000000000000000000000000000000000000000000000000000bddffdc4000000000000000000000000000000000000000000000000000000000634612f000000000000000000000000000000000000000000000000000000003b9293000000000000000000000000000000000000000000000000000000000000000000000000000000000028e2ce61ec8ded7f7bc9cba02a33573f7dd9f5f5000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b5300000000000000000000000000000000000000000000000000000000000000000000000000000000c3cb507553f192879c74879102fbb80286bcf12f0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000032239f5560000000000000000000000000000000000000000000000000000000046efd16c0000000000000000000000000000000000000000000000000000000078b248e4000000000000000000000000000000000000000000000000000000000000000000000000000000004cde0f1ba09de4b9fc6850412528d0756516d87a000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004a7baf6fc000000000000000000000000000000000000000000000000000000006f70d212000000000000000000000000000000000000000000000000000000000967aa82000000000000000000000000000000000000000000000000000000000f48a482000000000000000000000000000000000000000000000000000000000000000000000000000000002f7c91d53d4ff3ae6a2a2092776095dbc14bc6df00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000146e04a2f00000000000000000000000000000000000000000000000000000000000000000000000000000000fc7c599947dca76440dd3729a1292190c645eb9200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000371d78fbc00000000000000000000000000000000000000000000000000000000f63761240000000000000000000000000000000000000000000000000000000033c72dfe000000000000000000000000000000000000000000000000000000000000000000000000000000005b5481ad34b79d8e920b5f0f83d718ed225a7102000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000001262201b6000000000000000000000000000000000000000000000000000000000000000000000000000000002966b694d1642392cd759b8d8d316b55eae7aa690000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xa8615f71b8dc8b88fd926aaf7d23e6d3cf8e7dd2d59ef579ab8ab46d14ca38b0" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25347890, + "transactionHash": "0x731e016ac0dea74d300588c8ee2b3c12914b86c01f3b041c572ef2041d3d70eb", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014e000000000000000000000000000000000000000000000000000000000000000130000000000000000000000000000000000000000000000000000000000000260000000000000000000000000000000000000000000000000000000000000034000000000000000000000000000000000000000000000000000000000000004a000000000000000000000000000000000000000000000000000000000000005a000000000000000000000000000000000000000000000000000000000000006800000000000000000000000000000000000000000000000000000000000000780000000000000000000000000000000000000000000000000000000000000084000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000ae00000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000cc00000000000000000000000000000000000000000000000000000000000000e800000000000000000000000000000000000000000000000000000000000000f8000000000000000000000000000000000000000000000000000000000000010600000000000000000000000000000000000000000000000000000000000001160000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000012e000000000000000000000000000000000000000000000000000000000000013800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003ce6e9f9f0000000000000000000000000000000000000000000000000000000002bc2cdb000000000000000000000000000000000000000000000000000000000448a5c40000000000000000000000000000000000000000000000000000000000000000000000000000000003655add6798b6a8b9b2756e59486cea85e8ba2400000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000742f1181e000000000000000000000000000000000000000000000000000000006eade577000000000000000000000000000000000000000000000000000000004dc2304d00000000000000000000000000000000000000000000000000000000ad21879e000000000000000000000000000000000000000000000000000000001cf14f330000000000000000000000000000000000000000000000000000000070712939000000000000000000000000000000000000000000000000000000006e4d22c20000000000000000000000000000000000000000000000000000000000000000000000000000000031d88294e48f70233be242a524b0bebb0d155bc40000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000049dec88b900000000000000000000000000000000000000000000000000000000ce19912900000000000000000000000000000000000000000000000000000000d10a0aec0000000000000000000000000000000000000000000000000000000074b1d75d000000000000000000000000000000000000000000000000000000000000000000000000000000003f4e01c435433cff56cc7e6a054fe210efd06645000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003c76d202d00000000000000000000000000000000000000000000000000000000839bb9a6000000000000000000000000000000000000000000000000000000008e756bb30000000000000000000000000000000000000000000000000000000000000000000000000000000085fd223609f69b8ab88383f8c9fa6a37d38582cc000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004fee2792b00000000000000000000000000000000000000000000000000000000bf6d79ab00000000000000000000000000000000000000000000000000000000c1c52f8800000000000000000000000000000000000000000000000000000000ec1c2bb5000000000000000000000000000000000000000000000000000000000000000000000000000000001ac15086efefb7aa04a6a39f3f4b83608103d2fa000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002241b71bb00000000000000000000000000000000000000000000000000000000bb14516c00000000000000000000000000000000000000000000000000000000000000000000000000000000a6682e09318c47832d95f202b177edb397a8a34200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000235a7206d00000000000000000000000000000000000000000000000000000000c05b1ec30000000000000000000000000000000000000000000000000000000000000000000000000000000007b24e3192b05fe37842f5c71aeea7d726a3cad5000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004961113df0000000000000000000000000000000000000000000000000000000010d94006000000000000000000000000000000000000000000000000000000008fe2b41400000000000000000000000000000000000000000000000000000000020ce3a600000000000000000000000000000000000000000000000000000000000000000000000000000000ca79e8eeae776affc65f539d6cda998a76b250fe0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000039912dde8000000000000000000000000000000000000000000000000000000005a601668000000000000000000000000000000000000000000000000000000008a4f4f9200000000000000000000000000000000000000000000000000000000000000000000000000000000af60235bc891aa08776e59eb6c123fd21a38e75000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000513abaf0700000000000000000000000000000000000000000000000000000000ece1373200000000000000000000000000000000000000000000000000000000ed903f7a00000000000000000000000000000000000000000000000000000000010d573000000000000000000000000000000000000000000000000000000000767a7b0500000000000000000000000000000000000000000000000000000000000000000000000000000000868f7da9164a29801fa58ca0bb6b9c90f497b6ad000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002ea40e51a00000000000000000000000000000000000000000000000000000000461aebf400000000000000000000000000000000000000000000000000000000000000000000000000000000fc11f4ebe9f7c7399464c82825a0b8678fdc4cff00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000aeee8b7ff0000000000000000000000000000000000000000000000000000000072e1132700000000000000000000000000000000000000000000000000000000f4f015700000000000000000000000000000000000000000000000000000000046a384be00000000000000000000000000000000000000000000000000000000e949756100000000000000000000000000000000000000000000000000000000504006ca00000000000000000000000000000000000000000000000000000000c4c1662b00000000000000000000000000000000000000000000000000000000bddffdc4000000000000000000000000000000000000000000000000000000000634612f000000000000000000000000000000000000000000000000000000003b9293000000000000000000000000000000000000000000000000000000000000000000000000000000000028e2ce61ec8ded7f7bc9cba02a33573f7dd9f5f5000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b5300000000000000000000000000000000000000000000000000000000000000000000000000000000c3cb507553f192879c74879102fbb80286bcf12f0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000032239f5560000000000000000000000000000000000000000000000000000000046efd16c0000000000000000000000000000000000000000000000000000000078b248e4000000000000000000000000000000000000000000000000000000000000000000000000000000004cde0f1ba09de4b9fc6850412528d0756516d87a000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004a7baf6fc000000000000000000000000000000000000000000000000000000006f70d212000000000000000000000000000000000000000000000000000000000967aa82000000000000000000000000000000000000000000000000000000000f48a482000000000000000000000000000000000000000000000000000000000000000000000000000000002f7c91d53d4ff3ae6a2a2092776095dbc14bc6df00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000146e04a2f00000000000000000000000000000000000000000000000000000000000000000000000000000000fc7c599947dca76440dd3729a1292190c645eb9200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000371d78fbc00000000000000000000000000000000000000000000000000000000f63761240000000000000000000000000000000000000000000000000000000033c72dfe000000000000000000000000000000000000000000000000000000000000000000000000000000005b5481ad34b79d8e920b5f0f83d718ed225a7102000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000001262201b6000000000000000000000000000000000000000000000000000000000000000000000000000000002966b694d1642392cd759b8d8d316b55eae7aa690000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xa8615f71b8dc8b88fd926aaf7d23e6d3cf8e7dd2d59ef579ab8ab46d14ca38b0", + "args": [ + [ + [ + "0x0000000000000000000000000000000000000000", + 2, + ["0xce6e9f9f", "0x02bc2cdb", "0x0448a5c4"] + ], + [ + "0x03655Add6798b6a8B9b2756E59486Cea85e8ba24", + 1, + [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + ], + [ + "0x31D88294E48f70233bE242A524B0bebb0d155BC4", + 1, + ["0x9dec88b9", "0xce199129", "0xd10a0aec", "0x74b1d75d"] + ], + [ + "0x3F4e01c435433CfF56Cc7e6A054Fe210EFd06645", + 1, + ["0xc76d202d", "0x839bb9a6", "0x8e756bb3"] + ], + [ + "0x85FD223609f69b8aB88383F8c9FA6a37d38582CC", + 1, + ["0xfee2792b", "0xbf6d79ab", "0xc1c52f88", "0xec1c2bb5"] + ], + [ + "0x1Ac15086EFeFb7aa04A6a39f3F4b83608103D2fA", + 1, + ["0x241b71bb", "0xbb14516c"] + ], + [ + "0xa6682e09318c47832D95f202b177Edb397a8a342", + 1, + ["0x35a7206d", "0xc05b1ec3"] + ], + [ + "0x07B24e3192B05FE37842F5C71aEEa7d726a3caD5", + 1, + ["0x961113df", "0x10d94006", "0x8fe2b414", "0x020ce3a6"] + ], + [ + "0xcA79e8EEAe776AFfC65f539d6cdA998a76b250FE", + 1, + ["0x9912dde8", "0x5a601668", "0x8a4f4f92"] + ], + [ + "0xAf60235Bc891Aa08776E59Eb6c123fd21A38E750", + 1, + [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + ], + [ + "0x868f7DA9164a29801Fa58CA0BB6b9C90f497B6ad", + 0, + ["0xea40e51a", "0x461aebf4"] + ], + [ + "0xFC11f4ebe9f7c7399464c82825A0B8678fdc4cff", + 1, + [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + ], + [ + "0x28E2Ce61Ec8dEd7f7bC9CBa02a33573f7dd9f5F5", + 1, + ["0xe89ad656", "0x5ebc6334", "0xccdd9f5d", "0x8a700b53"] + ], + [ + "0xc3cB507553f192879c74879102fBB80286bcf12F", + 1, + ["0x2239f556", "0x46efd16c", "0x78b248e4"] + ], + [ + "0x4cDe0F1bA09DE4B9fC6850412528D0756516D87A", + 1, + ["0xa7baf6fc", "0x6f70d212", "0x0967aa82", "0x0f48a482"] + ], + [ + "0x2f7C91D53d4Ff3ae6a2a2092776095DBc14bc6dF", + 1, + ["0x46e04a2f"] + ], + [ + "0xFc7c599947DCa76440DD3729a1292190C645Eb92", + 1, + ["0x71d78fbc", "0xf6376124", "0x33c72dfe"] + ], + [ + "0x5B5481Ad34b79D8e920B5F0f83d718ED225A7102", + 1, + ["0x262201b6"] + ], + [ + "0x2966b694D1642392CD759B8d8D316B55eaE7aA69", + 1, + ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"] + ] + ], + "0x0000000000000000000000000000000000000000", + "0x" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 25347890, + "cumulativeGasUsed": "1557011", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + ["0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", ["0x1f931c1c"]], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x03655Add6798b6a8B9b2756E59486Cea85e8ba24", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0x31D88294E48f70233bE242A524B0bebb0d155BC4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3F4e01c435433CfF56Cc7e6A054Fe210EFd06645", + "functionSelectors": ["0xc76d202d", "0x839bb9a6", "0x8e756bb3"] + }, + { + "facetAddress": "0x85FD223609f69b8aB88383F8c9FA6a37d38582CC", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x1Ac15086EFeFb7aa04A6a39f3F4b83608103D2fA", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xa6682e09318c47832D95f202b177Edb397a8a342", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x07B24e3192B05FE37842F5C71aEEa7d726a3caD5", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xcA79e8EEAe776AFfC65f539d6cdA998a76b250FE", + "functionSelectors": ["0x9912dde8", "0x5a601668", "0x8a4f4f92"] + }, + { + "facetAddress": "0xAf60235Bc891Aa08776E59Eb6c123fd21A38E750", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x868f7DA9164a29801Fa58CA0BB6b9C90f497B6ad", + "functionSelectors": ["0xea40e51a", "0x461aebf4"] + }, + { + "facetAddress": "0xFC11f4ebe9f7c7399464c82825A0B8678fdc4cff", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0x28E2Ce61Ec8dEd7f7bC9CBa02a33573f7dd9f5F5", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0xc3cB507553f192879c74879102fBB80286bcf12F", + "functionSelectors": ["0x2239f556", "0x46efd16c", "0x78b248e4"] + }, + { + "facetAddress": "0x4cDe0F1bA09DE4B9fC6850412528D0756516D87A", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x2f7C91D53d4Ff3ae6a2a2092776095DBc14bc6dF", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xFc7c599947DCa76440DD3729a1292190C645Eb92", + "functionSelectors": ["0x71d78fbc", "0xf6376124", "0x33c72dfe"] + }, + { + "facetAddress": "0x5B5481Ad34b79D8e920B5F0f83d718ED225A7102", + "functionSelectors": ["0x262201b6"] + }, + { + "facetAddress": "0x2966b694D1642392CD759B8d8D316B55eaE7aA69", + "functionSelectors": ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"] + } + ], + "diamondCut": [ + { + "facetAddress": "0x0000000000000000000000000000000000000000", + "functionSelectors": ["0xce6e9f9f", "0x02bc2cdb", "0x0448a5c4"], + "action": 2 + }, + { + "facetAddress": "0x03655Add6798b6a8B9b2756E59486Cea85e8ba24", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 1 + }, + { + "facetAddress": "0x31D88294E48f70233bE242A524B0bebb0d155BC4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 1 + }, + { + "facetAddress": "0x3F4e01c435433CfF56Cc7e6A054Fe210EFd06645", + "functionSelectors": ["0xc76d202d", "0x839bb9a6", "0x8e756bb3"], + "action": 1 + }, + { + "facetAddress": "0x85FD223609f69b8aB88383F8c9FA6a37d38582CC", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 1 + }, + { + "facetAddress": "0x1Ac15086EFeFb7aa04A6a39f3F4b83608103D2fA", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 1 + }, + { + "facetAddress": "0xa6682e09318c47832D95f202b177Edb397a8a342", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 1 + }, + { + "facetAddress": "0x07B24e3192B05FE37842F5C71aEEa7d726a3caD5", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 1 + }, + { + "facetAddress": "0xcA79e8EEAe776AFfC65f539d6cdA998a76b250FE", + "functionSelectors": ["0x9912dde8", "0x5a601668", "0x8a4f4f92"], + "action": 1 + }, + { + "facetAddress": "0xAf60235Bc891Aa08776E59Eb6c123fd21A38E750", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 1 + }, + { + "facetAddress": "0x868f7DA9164a29801Fa58CA0BB6b9C90f497B6ad", + "functionSelectors": ["0xea40e51a", "0x461aebf4"], + "action": 0 + }, + { + "facetAddress": "0xFC11f4ebe9f7c7399464c82825A0B8678fdc4cff", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 1 + }, + { + "facetAddress": "0x28E2Ce61Ec8dEd7f7bC9CBa02a33573f7dd9f5F5", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 1 + }, + { + "facetAddress": "0xc3cB507553f192879c74879102fBB80286bcf12F", + "functionSelectors": ["0x2239f556", "0x46efd16c", "0x78b248e4"], + "action": 1 + }, + { + "facetAddress": "0x4cDe0F1bA09DE4B9fC6850412528D0756516D87A", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 1 + }, + { + "facetAddress": "0x2f7C91D53d4Ff3ae6a2a2092776095DBc14bc6dF", + "functionSelectors": ["0x46e04a2f"], + "action": 1 + }, + { + "facetAddress": "0xFc7c599947DCa76440DD3729a1292190C645Eb92", + "functionSelectors": ["0x71d78fbc", "0xf6376124", "0x33c72dfe"], + "action": 1 + }, + { + "facetAddress": "0x5B5481Ad34b79D8e920B5F0f83d718ED225A7102", + "functionSelectors": ["0x262201b6"], + "action": 1 + }, + { + "facetAddress": "0x2966b694D1642392CD759B8d8D316B55eaE7aA69", + "functionSelectors": ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"], + "action": 1 + } + ], + "history": [ + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "5530229", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000020000020000008000000840000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000008000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000420000000000000000000000000000000000000000000000000000000000000008000", + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "args": ["0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0"], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "blockNumber": 25103807, + "cumulativeGasUsed": "5530229", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "0x608060405260405162002d4538038062002d45833981016040819052620000269162000db2565b604080516000808252602082019092526200004e918491620000f560201b620000db1760201c565b620000688160000151620002b560201b6200027d1760201c565b60006200007f6200031760201b620003021760201c565b6301ffc9a760e01b600090815260039091016020526040808220805460ff1990811660019081179092556307e4c70760e21b845282842080548216831790556348e2b09360e01b845282842080548216831790556307f5828d60e41b845291909220805490911690911790555062001442915050565b60005b8351811015620002665760008482815181106200011157fe5b6020026020010151602001519050600060028111156200012d57fe5b8160028111156200013a57fe5b14156200018957620001838583815181106200015257fe5b6020026020010151600001518684815181106200016b57fe5b6020026020010151604001516200033b60201b60201c565b6200025c565b60018160028111156200019857fe5b1415620001e15762000183858381518110620001b057fe5b602002602001015160000151868481518110620001c957fe5b6020026020010151604001516200054e60201b60201c565b6002816002811115620001f057fe5b14156200023957620001838583815181106200020857fe5b6020026020010151600001518684815181106200022157fe5b6020026020010151604001516200077860201b60201c565b60405162461bcd60e51b815260040162000253906200117c565b60405180910390fd5b50600101620000f8565b507f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb6738383836040516200029c9392919062000f25565b60405180910390a1620002b082826200083f565b505050565b6000620002c162000317565b6004810180546001600160a01b038581166001600160a01b031983168117909355604051939450169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c90565b60008151116200035f5760405162461bcd60e51b81526004016200025390620010d4565b60006200036b62000317565b90506001600160a01b038316620003965760405162461bcd60e51b81526004016200025390620011c3565b6001600160a01b038316600090815260018201602052604090205461ffff81166200043c57620003e08460405180606001604052806024815260200162002d21602491396200097c565b6002820180546001600160a01b038616600081815260018087016020908152604083208201805461ffff191661ffff90961695909517909455845490810185559381529190912090910180546001600160a01b03191690911790555b60005b8351811015620005475760008482815181106200045857fe5b6020908102919091018101516001600160e01b031981166000908152918690526040909120549091506001600160a01b03168015620004ab5760405162461bcd60e51b81526004016200025390620012ba565b506001600160a01b0386166000818152600186810160209081526040808420805480850182559085528285206008820401805463ffffffff60079093166004026101000a928302191660e089901c929092029190911790556001600160e01b0319909516835287905292902080546001600160a01b03191690911761ffff60a01b1916600160a01b61ffff86160217905591820191016200043f565b5050505050565b6000815111620005725760405162461bcd60e51b81526004016200025390620010d4565b60006200057e62000317565b90506001600160a01b038316620005a95760405162461bcd60e51b81526004016200025390620011c3565b6001600160a01b038316600090815260018201602052604090205461ffff81166200064f57620005f38460405180606001604052806024815260200162002d21602491396200097c565b6002820180546001600160a01b038616600081815260018087016020908152604083208201805461ffff191661ffff90961695909517909455845490810185559381529190912090910180546001600160a01b03191690911790555b60005b8351811015620005475760008482815181106200066b57fe5b6020908102919091018101516001600160e01b031981166000908152918690526040909120549091506001600160a01b03908116908716811415620006c45760405162461bcd60e51b8152600401620002539062001317565b620006d08183620009a0565b506001600160e01b03198116600081815260208681526040808320805461ffff60a01b1916600160a01b61ffff8a16021781556001600160a01b038b168085526001808b018552928520805480850182559086528486206008820401805463ffffffff60079093166004026101000a928302191660e09990991c91909102979097179096559390925286905281546001600160a01b0319169092179055918201910162000652565b60008151116200079c5760405162461bcd60e51b81526004016200025390620010d4565b6000620007a862000317565b90506001600160a01b03831615620007d45760405162461bcd60e51b8152600401620002539062001374565b60005b825181101562000839576000838281518110620007f057fe5b6020908102919091018101516001600160e01b031981166000908152918590526040909120549091506001600160a01b03166200082e8183620009a0565b5050600101620007d7565b50505050565b6001600160a01b0382166200087657805115620008705760405162461bcd60e51b8152600401620002539062001031565b62000978565b60008151116200089a5760405162461bcd60e51b815260040162000253906200120f565b6001600160a01b0382163014620008d057620008d08260405180606001604052806028815260200162002cf9602891396200097c565b600080836001600160a01b031683604051620008ed919062000f07565b600060405180830381855af49150503d80600081146200092a576040519150601f19603f3d011682016040523d82523d6000602084013e6200092f565b606091505b50915091508162000839578051156200095e578060405162461bcd60e51b815260040162000253919062001015565b60405162461bcd60e51b815260040162000253906200108e565b5050565b813b8181620008395760405162461bcd60e51b815260040162000253919062001015565b6000620009ac62000317565b90506001600160a01b038316620009d75760405162461bcd60e51b815260040162000253906200111f565b6001600160a01b03831630141562000a035760405162461bcd60e51b815260040162000253906200126c565b6001600160e01b03198216600090815260208281526040808320546001600160a01b03871684526001850190925290912054600160a01b90910461ffff16906000190180821462000b27576001600160a01b0385166000908152600184016020526040812080548390811062000a7557fe5b600091825260208083206008830401546001600160a01b038a168452600188019091526040909220805460079092166004026101000a90920460e01b92508291908590811062000ac157fe5b600091825260208083206008830401805463ffffffff60079094166004026101000a938402191660e09590951c929092029390931790556001600160e01b031992909216825284905260409020805461ffff60a01b1916600160a01b61ffff8516021790555b6001600160a01b0385166000908152600184016020526040902080548062000b4b57fe5b60008281526020808220600860001990940193840401805463ffffffff600460078716026101000a0219169055919092556001600160e01b0319861682528490526040902080546001600160b01b031916905580620005475760028301546001600160a01b03861660009081526001858101602052604090912001546000199091019061ffff1680821462000c6357600085600201838154811062000bec57fe5b6000918252602090912001546002870180546001600160a01b03909216925082918490811062000c1857fe5b600091825260208083209190910180546001600160a01b0319166001600160a01b0394851617905592909116815260018781019092526040902001805461ffff191661ffff83161790555b8460020180548062000c7157fe5b60008281526020808220830160001990810180546001600160a01b03191690559092019092556001600160a01b03891682526001878101909152604090912001805461ffff1916905550505050505050565b80516001600160a01b038116811462000cdb57600080fd5b919050565b600082601f83011262000cf1578081fd5b8151602062000d0a62000d0483620013f5565b620013d1565b828152818101908583018385028701840188101562000d27578586fd5b855b8581101562000d5d5781516001600160e01b03198116811462000d4a578788fd5b8452928401929084019060010162000d29565b5090979650505050505050565b60006020828403121562000d7c578081fd5b604051602081016001600160401b038111828210171562000d9957fe5b60405290508062000daa8362000cc3565b905292915050565b6000806040838503121562000dc5578182fd5b82516001600160401b038082111562000ddc578384fd5b818501915085601f83011262000df0578384fd5b8151602062000e0362000d0483620013f5565b82815281810190858301885b8581101562000eaa57815188016060818e03601f1901121562000e30578a8bfd5b604051606081018181108a8211171562000e4657fe5b60405262000e5682880162000cc3565b815260408201516003811062000e6a578c8dfd5b8188015260608201518981111562000e80578c8dfd5b62000e908f898386010162000ce0565b604083015250855250928401929084019060010162000e0f565b5050809750505062000ebf8882890162000d6a565b9450505050509250929050565b6001600160a01b03169052565b6000815180845262000ef381602086016020860162001413565b601f01601f19169290920160200192915050565b6000825162000f1b81846020870162001413565b9190910192915050565b606080825284518282018190526000919060809081850190602080820287018401818b01875b8481101562000fe257898303607f19018652815180516001600160a01b0316845284810151898501906003811062000f7f57fe5b858701526040918201519185018a9052815190819052908501908a90898601905b8083101562000fcc5783516001600160e01b031916825292870192600192909201919087019062000fa0565b5097860197945050509083019060010162000f4b565b505062000ff28289018b62000ecc565b878103604089015262001006818a62000ed9565b9b9a5050505050505050505050565b6000602082526200102a602083018462000ed9565b9392505050565b6020808252603c908201527f4c69624469616d6f6e644375743a205f696e697420697320616464726573732860408201527f3029206275745f63616c6c64617461206973206e6f7420656d70747900000000606082015260800190565b60208082526026908201527f4c69624469616d6f6e644375743a205f696e69742066756e6374696f6e2072656040820152651d995c9d195960d21b606082015260800190565b6020808252602b908201527f4c69624469616d6f6e644375743a204e6f2073656c6563746f727320696e206660408201526a1858d95d081d1bc818dd5d60aa1b606082015260800190565b60208082526037908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f76652066756e6360408201527f74696f6e207468617420646f65736e2774206578697374000000000000000000606082015260800190565b60208082526027908201527f4c69624469616d6f6e644375743a20496e636f727265637420466163657443756040820152663a20b1ba34b7b760c91b606082015260800190565b6020808252602c908201527f4c69624469616d6f6e644375743a204164642066616365742063616e2774206260408201526b65206164647265737328302960a01b606082015260800190565b6020808252603d908201527f4c69624469616d6f6e644375743a205f63616c6c6461746120697320656d707460408201527f7920627574205f696e6974206973206e6f742061646472657373283029000000606082015260800190565b6020808252602e908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f766520696d6d7560408201526d3a30b1363290333ab731ba34b7b760911b606082015260800190565b60208082526035908201527f4c69624469616d6f6e644375743a2043616e2774206164642066756e6374696f60408201527f6e207468617420616c7265616479206578697374730000000000000000000000606082015260800190565b60208082526038908201527f4c69624469616d6f6e644375743a2043616e2774207265706c6163652066756e60408201527f6374696f6e20776974682073616d652066756e6374696f6e0000000000000000606082015260800190565b60208082526036908201527f4c69624469616d6f6e644375743a2052656d6f7665206661636574206164647260408201527f657373206d757374206265206164647265737328302900000000000000000000606082015260800190565b6040518181016001600160401b0381118282101715620013ed57fe5b604052919050565b60006001600160401b038211156200140957fe5b5060209081020190565b60005b838110156200143057818101518382015260200162001416565b83811115620008395750506000910152565b6118a780620014526000396000f3fe60806040523661000b57005b600080357fffffffff000000000000000000000000000000000000000000000000000000001681527fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c6020819052604090912054819073ffffffffffffffffffffffffffffffffffffffff16806100b7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906115f3565b60405180910390fd5b3660008037600080366000845af43d6000803e8080156100d6573d6000f35b3d6000fd5b60005b83518110156102325760008482815181106100f557fe5b60200260200101516020015190506000600281111561011057fe5b81600281111561011c57fe5b141561015f5761015a85838151811061013157fe5b60200260200101516000015186848151811061014957fe5b602002602001015160400151610326565b610229565b600181600281111561016d57fe5b14156101ab5761015a85838151811061018257fe5b60200260200101516000015186848151811061019a57fe5b60200260200101516040015161065e565b60028160028111156101b957fe5b14156101f75761015a8583815181106101ce57fe5b6020026020010151600001518684815181106101e657fe5b6020026020010151604001516109ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611539565b506001016100de565b507f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb67383838360405161026693929190611282565b60405180910390a16102788282610acb565b505050565b6000610287610302565b60048101805473ffffffffffffffffffffffffffffffffffffffff8581167fffffffffffffffffffffffff000000000000000000000000000000000000000083168117909355604051939450169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c90565b6000815111610361576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b600061036b610302565b905073ffffffffffffffffffffffffffffffffffffffff83166103ba576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166104ab5761040d8460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106104c557fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff168015610554576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906116e2565b5073ffffffffffffffffffffffffffffffffffffffff86166000818152600186810160209081526040808420805480850182559085528285206008820401805463ffffffff60079093166004026101000a928302191660e089901c929092029190911790557fffffffff00000000000000000000000000000000000000000000000000000000909516835287905292902080547fffffffffffffffffffffffff0000000000000000000000000000000000000000169091177fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff86160217905591820191016104ae565b5050505050565b6000815111610699576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006106a3610302565b905073ffffffffffffffffffffffffffffffffffffffff83166106f2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166107e3576107458460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106107fd57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff908116908716811415610892576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061173f565b61089c8183610cbc565b507fffffffff00000000000000000000000000000000000000000000000000000000811660008181526020868152604080832080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8a160217815573ffffffffffffffffffffffffffffffffffffffff8b168085526001808b018552928520805480850182559086528486206008820401805463ffffffff60079093166004026101000a928302191660e09990991c91909102979097179096559390925286905281547fffffffffffffffffffffffff000000000000000000000000000000000000000016909217905591820191016107e6565b60008151116109e6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006109f0610302565b905073ffffffffffffffffffffffffffffffffffffffff831615610a40576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061179c565b60005b8251811015610ac5576000838281518110610a5a57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529185905260409091205490915073ffffffffffffffffffffffffffffffffffffffff16610abb8183610cbc565b5050600101610a43565b50505050565b73ffffffffffffffffffffffffffffffffffffffff8216610b2457805115610b1f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906113c5565b610c7d565b6000815111610b5f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611628565b73ffffffffffffffffffffffffffffffffffffffff82163014610b9e57610b9e8260405180606001604052806028815260200161182660289139610c81565b6000808373ffffffffffffffffffffffffffffffffffffffff1683604051610bc69190611266565b600060405180830381855af49150503d8060008114610c01576040519150601f19603f3d011682016040523d82523d6000602084013e610c06565b606091505b509150915081610ac557805115610c4b57806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611422565b5050565b813b8181610ac5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6000610cc6610302565b905073ffffffffffffffffffffffffffffffffffffffff8316610d15576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906114dc565b73ffffffffffffffffffffffffffffffffffffffff8316301415610d65576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611685565b7fffffffff0000000000000000000000000000000000000000000000000000000082166000908152602082815260408083205473ffffffffffffffffffffffffffffffffffffffff8716845260018501909252909120547401000000000000000000000000000000000000000090910461ffff16907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01808214610f375773ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260408120805483908110610e3657fe5b6000918252602080832060088304015473ffffffffffffffffffffffffffffffffffffffff8a168452600188019091526040909220805460079092166004026101000a90920460e01b925082919085908110610e8e57fe5b600091825260208083206008830401805463ffffffff60079094166004026101000a938402191660e09590951c929092029390931790557fffffffff000000000000000000000000000000000000000000000000000000009290921682528490526040902080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8516021790555b73ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260409020805480610f6757fe5b6000828152602080822060087fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90940193840401805463ffffffff600460078716026101000a0219169055919092557fffffffff00000000000000000000000000000000000000000000000000000000861682528490526040902080547fffffffffffffffffffff000000000000000000000000000000000000000000001690558061065757600283015473ffffffffffffffffffffffffffffffffffffffff861660009081526001858101602052604090912001547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9091019061ffff1680821461114357600085600201838154811061107e57fe5b60009182526020909120015460028701805473ffffffffffffffffffffffffffffffffffffffff90921692508291849081106110b657fe5b600091825260208083209190910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff9485161790559290911681526001878101909252604090200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff83161790555b8460020180548061115057fe5b6000828152602080822083017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90810180547fffffffffffffffffffffffff000000000000000000000000000000000000000016905590920190925573ffffffffffffffffffffffffffffffffffffffff89168252600187810190915260409091200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000016905550505050505050565b73ffffffffffffffffffffffffffffffffffffffff169052565b600081518084526112348160208601602086016117f9565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b600082516112788184602087016117f9565b9190910192915050565b606080825284518282018190526000919060809081850190602080820287018401818b01875b8481101561137c577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff808a8403018652815188840173ffffffffffffffffffffffffffffffffffffffff8251168552858201516003811061130457fe5b858701526040918201519185018a9052815190819052908501908a90898601905b808310156113675783517fffffffff00000000000000000000000000000000000000000000000000000000168252928701926001929092019190870190611325565b509786019794505050908301906001016112a8565b505061138a8289018b611202565b878103604089015261139c818a61121c565b9b9a5050505050505050505050565b6000602082526113be602083018461121c565b9392505050565b6020808252603c908201527f4c69624469616d6f6e644375743a205f696e697420697320616464726573732860408201527f3029206275745f63616c6c64617461206973206e6f7420656d70747900000000606082015260800190565b60208082526026908201527f4c69624469616d6f6e644375743a205f696e69742066756e6374696f6e20726560408201527f7665727465640000000000000000000000000000000000000000000000000000606082015260800190565b6020808252602b908201527f4c69624469616d6f6e644375743a204e6f2073656c6563746f727320696e206660408201527f6163657420746f20637574000000000000000000000000000000000000000000606082015260800190565b60208082526037908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f76652066756e6360408201527f74696f6e207468617420646f65736e2774206578697374000000000000000000606082015260800190565b60208082526027908201527f4c69624469616d6f6e644375743a20496e636f7272656374204661636574437560408201527f74416374696f6e00000000000000000000000000000000000000000000000000606082015260800190565b6020808252602c908201527f4c69624469616d6f6e644375743a204164642066616365742063616e2774206260408201527f6520616464726573732830290000000000000000000000000000000000000000606082015260800190565b6020808252818101527f4469616d6f6e643a2046756e6374696f6e20646f6573206e6f74206578697374604082015260600190565b6020808252603d908201527f4c69624469616d6f6e644375743a205f63616c6c6461746120697320656d707460408201527f7920627574205f696e6974206973206e6f742061646472657373283029000000606082015260800190565b6020808252602e908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f766520696d6d7560408201527f7461626c652066756e6374696f6e000000000000000000000000000000000000606082015260800190565b60208082526035908201527f4c69624469616d6f6e644375743a2043616e2774206164642066756e6374696f60408201527f6e207468617420616c7265616479206578697374730000000000000000000000606082015260800190565b60208082526038908201527f4c69624469616d6f6e644375743a2043616e2774207265706c6163652066756e60408201527f6374696f6e20776974682073616d652066756e6374696f6e0000000000000000606082015260800190565b60208082526036908201527f4c69624469616d6f6e644375743a2052656d6f7665206661636574206164647260408201527f657373206d757374206265206164647265737328302900000000000000000000606082015260800190565b60005b838110156118145781810151838201526020016117fc565b83811115610ac5575050600091015256fe4c69624469616d6f6e644375743a205f696e6974206164647265737320686173206e6f20636f64654c69624469616d6f6e644375743a204e657720666163657420686173206e6f20636f6465a264697066735822122054a3c3a118803545231f43700030cb5e290869be0182196a4a05e7d4a1b71d7e64736f6c634300070600334c69624469616d6f6e644375743a205f696e6974206164647265737320686173206e6f20636f64654c69624469616d6f6e644375743a204e657720666163657420686173206e6f20636f6465", + "deployedBytecode": "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", + "facets": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0x61460874a7196d6a22d1ee4922473664b3e95270" + }, + { + "sym": "ADAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "PCDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "YDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "WETH", + "addr": "0xd0a1e359811322d97991e03f863a0c30c2cf029c" + }, + { + "sym": "DAI", + "addr": "0x4f96fe3b7a6cf9725f59d353f723c1bdb64ca6aa" + }, + { + "sym": "USDC", + "addr": "0xb7a4f3e9097c08da09517b5ab877f7a917224ede" + }, + { + "sym": "LINK", + "addr": "0xa36085F69e2889c224210F603D836748e7dC0088" + } + ], + "cTokens": [ + "0xf0d0eb522cfa50b716b3b1604c4f0fa6f04376ad", + "0x4a92e71227d294f041bd82dd8f78591b75140d63", + "0x41b5844f4680a8c38fbb695b7f9cfd1f64474a72" + ], + "tellerNFT": "0x7360904A663B9Cb66baB538F406C04D8da86229d", + "loansEscrowBeacon": "0xAb59409415e28deEb6255ba64527E3271D057FED", + "collateralEscrowBeacon": "0x7cCb2ddB4f7a239CA9edF765edC0bb4e7e04Ef5F", + "tTokenBeacon": "0x18D45BC9319937d2099Dc8e0D0EdCEEe033fCf25", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "receipt": { + "to": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "204539", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000000000000000000000000040000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb", + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25104070, + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000617bf3ec25f4b04ca986ae559ed37be7f68cccad0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25104070, + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000617bf3ec25f4b04ca986ae559ed37be7f68cccad0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb", + "args": [ + [ + [ + "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + 0, + ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"] + ] + ], + "0x0000000000000000000000000000000000000000", + "0x" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 25104070, + "cumulativeGasUsed": "204539", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + ["0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", ["0x1f931c1c"]], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ], + "action": 0 + } + ], + "history": [ + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "5530229", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000020000020000008000000840000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000008000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000420000000000000000000000000000000000000000000000000000000000000008000", + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "args": ["0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0"], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "blockNumber": 25103807, + "cumulativeGasUsed": "5530229", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0x61460874a7196d6a22d1ee4922473664b3e95270" + }, + { + "sym": "ADAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "PCDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "YDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "WETH", + "addr": "0xd0a1e359811322d97991e03f863a0c30c2cf029c" + }, + { + "sym": "DAI", + "addr": "0x4f96fe3b7a6cf9725f59d353f723c1bdb64ca6aa" + }, + { + "sym": "USDC", + "addr": "0xb7a4f3e9097c08da09517b5ab877f7a917224ede" + }, + { + "sym": "LINK", + "addr": "0xa36085F69e2889c224210F603D836748e7dC0088" + } + ], + "cTokens": [ + "0xf0d0eb522cfa50b716b3b1604c4f0fa6f04376ad", + "0x4a92e71227d294f041bd82dd8f78591b75140d63", + "0x41b5844f4680a8c38fbb695b7f9cfd1f64474a72" + ], + "tellerNFT": "0x7360904A663B9Cb66baB538F406C04D8da86229d", + "loansEscrowBeacon": "0xAb59409415e28deEb6255ba64527E3271D057FED", + "collateralEscrowBeacon": "0x7cCb2ddB4f7a239CA9edF765edC0bb4e7e04Ef5F", + "tTokenBeacon": "0x18D45BC9319937d2099Dc8e0D0EdCEEe033fCf25", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanUserRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanConsensusResponse[]", + "name": "responses", + "type": "tuple[]" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanUserRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanConsensusResponse[]", + "name": "responses", + "type": "tuple[]" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "internalType": "uint16[]", + "name": "nftIDs", + "type": "uint16[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "dictAddress", + "type": "address" + } + ], + "name": "setNFTDictionary", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x19c1048e8501295e71eff1c25c0dc86bc87084fded1c72a2a970f931c854a6e9", + "receipt": { + "to": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "315319", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000000000000000000000000040000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0x862f78bbd59152a5cf0ea9ca525131cdac10f8970eaf62ac6ac0955df3968ede", + "transactionHash": "0x19c1048e8501295e71eff1c25c0dc86bc87084fded1c72a2a970f931c854a6e9", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25370077, + "transactionHash": "0x19c1048e8501295e71eff1c25c0dc86bc87084fded1c72a2a970f931c854a6e9", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 0, + "blockHash": "0x862f78bbd59152a5cf0ea9ca525131cdac10f8970eaf62ac6ac0955df3968ede" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25370077, + "transactionHash": "0x19c1048e8501295e71eff1c25c0dc86bc87084fded1c72a2a970f931c854a6e9", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 0, + "blockHash": "0x862f78bbd59152a5cf0ea9ca525131cdac10f8970eaf62ac6ac0955df3968ede", + "args": [ + [ + [ + "0x0000000000000000000000000000000000000000", + 2, + ["0x0967aa82", "0x461aebf4"] + ], + [ + "0xb939B2c7861D718bbE32103906A92Cd626929134", + 1, + ["0xea40e51a"] + ], + [ + "0xb939B2c7861D718bbE32103906A92Cd626929134", + 0, + ["0xfe5d095b"] + ], + [ + "0xE1C9D9f11fc759b4c60e13b5D11502c0B27AF2b7", + 1, + ["0xe89ad656", "0x5ebc6334", "0xccdd9f5d", "0x8a700b53"] + ], + [ + "0x975BdA2061e3C7FC2435635794Ee7971D5406C3D", + 1, + ["0xa7baf6fc", "0x6f70d212", "0x0f48a482"] + ], + [ + "0x975BdA2061e3C7FC2435635794Ee7971D5406C3D", + 0, + ["0x987df220"] + ] + ], + "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "0x987df220000000000000000000000000f270070dc4aaf37823fa96c823e17cb291d8d57a" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 25370077, + "cumulativeGasUsed": "315319", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + ["0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", ["0x1f931c1c"]], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x03655Add6798b6a8B9b2756E59486Cea85e8ba24", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0x31D88294E48f70233bE242A524B0bebb0d155BC4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3F4e01c435433CfF56Cc7e6A054Fe210EFd06645", + "functionSelectors": ["0xc76d202d", "0x839bb9a6", "0x8e756bb3"] + }, + { + "facetAddress": "0x85FD223609f69b8aB88383F8c9FA6a37d38582CC", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x1Ac15086EFeFb7aa04A6a39f3F4b83608103D2fA", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xa6682e09318c47832D95f202b177Edb397a8a342", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x07B24e3192B05FE37842F5C71aEEa7d726a3caD5", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xcA79e8EEAe776AFfC65f539d6cdA998a76b250FE", + "functionSelectors": ["0x9912dde8", "0x5a601668", "0x8a4f4f92"] + }, + { + "facetAddress": "0xAf60235Bc891Aa08776E59Eb6c123fd21A38E750", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0xb939B2c7861D718bbE32103906A92Cd626929134", + "functionSelectors": ["0xea40e51a", "0xfe5d095b"] + }, + { + "facetAddress": "0xFC11f4ebe9f7c7399464c82825A0B8678fdc4cff", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xE1C9D9f11fc759b4c60e13b5D11502c0B27AF2b7", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0xc3cB507553f192879c74879102fBB80286bcf12F", + "functionSelectors": ["0x2239f556", "0x46efd16c", "0x78b248e4"] + }, + { + "facetAddress": "0x975BdA2061e3C7FC2435635794Ee7971D5406C3D", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x987df220", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x2f7C91D53d4Ff3ae6a2a2092776095DBc14bc6dF", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xFc7c599947DCa76440DD3729a1292190C645Eb92", + "functionSelectors": ["0x71d78fbc", "0xf6376124", "0x33c72dfe"] + }, + { + "facetAddress": "0x5B5481Ad34b79D8e920B5F0f83d718ED225A7102", + "functionSelectors": ["0x262201b6"] + }, + { + "facetAddress": "0x2966b694D1642392CD759B8d8D316B55eaE7aA69", + "functionSelectors": ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"] + } + ], + "diamondCut": [ + { + "facetAddress": "0x0000000000000000000000000000000000000000", + "functionSelectors": ["0x0967aa82", "0x461aebf4"], + "action": 2 + }, + { + "facetAddress": "0xb939B2c7861D718bbE32103906A92Cd626929134", + "functionSelectors": ["0xea40e51a"], + "action": 1 + }, + { + "facetAddress": "0xb939B2c7861D718bbE32103906A92Cd626929134", + "functionSelectors": ["0xfe5d095b"], + "action": 0 + }, + { + "facetAddress": "0xE1C9D9f11fc759b4c60e13b5D11502c0B27AF2b7", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 1 + }, + { + "facetAddress": "0x975BdA2061e3C7FC2435635794Ee7971D5406C3D", + "functionSelectors": ["0xa7baf6fc", "0x6f70d212", "0x0f48a482"], + "action": 1 + }, + { + "facetAddress": "0x975BdA2061e3C7FC2435635794Ee7971D5406C3D", + "functionSelectors": ["0x987df220"], + "action": 0 + } + ], + "execute": { + "methodName": "setNFTDictionary", + "args": ["0xF270070Dc4AAF37823Fa96c823e17cb291d8D57A"] + }, + "history": [ + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "5530229", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000020000020000008000000840000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000008000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000420000000000000000000000000000000000000000000000000000000000000008000", + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "args": ["0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0"], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "blockNumber": 25103807, + "cumulativeGasUsed": "5530229", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0x61460874a7196d6a22d1ee4922473664b3e95270" + }, + { + "sym": "ADAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "PCDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "YDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "WETH", + "addr": "0xd0a1e359811322d97991e03f863a0c30c2cf029c" + }, + { + "sym": "DAI", + "addr": "0x4f96fe3b7a6cf9725f59d353f723c1bdb64ca6aa" + }, + { + "sym": "USDC", + "addr": "0xb7a4f3e9097c08da09517b5ab877f7a917224ede" + }, + { + "sym": "LINK", + "addr": "0xa36085F69e2889c224210F603D836748e7dC0088" + } + ], + "cTokens": [ + "0xf0d0eb522cfa50b716b3b1604c4f0fa6f04376ad", + "0x4a92e71227d294f041bd82dd8f78591b75140d63", + "0x41b5844f4680a8c38fbb695b7f9cfd1f64474a72" + ], + "tellerNFT": "0x7360904A663B9Cb66baB538F406C04D8da86229d", + "loansEscrowBeacon": "0xAb59409415e28deEb6255ba64527E3271D057FED", + "collateralEscrowBeacon": "0x7cCb2ddB4f7a239CA9edF765edC0bb4e7e04Ef5F", + "tTokenBeacon": "0x18D45BC9319937d2099Dc8e0D0EdCEEe033fCf25", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "receipt": { + "to": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "204539", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000000000000000000000000040000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb", + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25104070, + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000617bf3ec25f4b04ca986ae559ed37be7f68cccad0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25104070, + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000617bf3ec25f4b04ca986ae559ed37be7f68cccad0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb", + "args": [ + [ + [ + "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + 0, + ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"] + ] + ], + "0x0000000000000000000000000000000000000000", + "0x" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 25104070, + "cumulativeGasUsed": "204539", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + ["0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", ["0x1f931c1c"]], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ], + "action": 0 + } + ], + "history": [ + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "5530229", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000020000020000008000000840000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000008000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000420000000000000000000000000000000000000000000000000000000000000008000", + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "args": ["0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0"], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "blockNumber": 25103807, + "cumulativeGasUsed": "5530229", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0x61460874a7196d6a22d1ee4922473664b3e95270" + }, + { + "sym": "ADAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "PCDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "YDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "WETH", + "addr": "0xd0a1e359811322d97991e03f863a0c30c2cf029c" + }, + { + "sym": "DAI", + "addr": "0x4f96fe3b7a6cf9725f59d353f723c1bdb64ca6aa" + }, + { + "sym": "USDC", + "addr": "0xb7a4f3e9097c08da09517b5ab877f7a917224ede" + }, + { + "sym": "LINK", + "addr": "0xa36085F69e2889c224210F603D836748e7dC0088" + } + ], + "cTokens": [ + "0xf0d0eb522cfa50b716b3b1604c4f0fa6f04376ad", + "0x4a92e71227d294f041bd82dd8f78591b75140d63", + "0x41b5844f4680a8c38fbb695b7f9cfd1f64474a72" + ], + "tellerNFT": "0x7360904A663B9Cb66baB538F406C04D8da86229d", + "loansEscrowBeacon": "0xAb59409415e28deEb6255ba64527E3271D057FED", + "collateralEscrowBeacon": "0x7cCb2ddB4f7a239CA9edF765edC0bb4e7e04Ef5F", + "tTokenBeacon": "0x18D45BC9319937d2099Dc8e0D0EdCEEe033fCf25", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanUserRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanConsensusResponse[]", + "name": "responses", + "type": "tuple[]" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanUserRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanConsensusResponse[]", + "name": "responses", + "type": "tuple[]" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x731e016ac0dea74d300588c8ee2b3c12914b86c01f3b041c572ef2041d3d70eb", + "receipt": { + "to": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "1557011", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000000000000000000000000040000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xa8615f71b8dc8b88fd926aaf7d23e6d3cf8e7dd2d59ef579ab8ab46d14ca38b0", + "transactionHash": "0x731e016ac0dea74d300588c8ee2b3c12914b86c01f3b041c572ef2041d3d70eb", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25347890, + "transactionHash": "0x731e016ac0dea74d300588c8ee2b3c12914b86c01f3b041c572ef2041d3d70eb", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014e000000000000000000000000000000000000000000000000000000000000000130000000000000000000000000000000000000000000000000000000000000260000000000000000000000000000000000000000000000000000000000000034000000000000000000000000000000000000000000000000000000000000004a000000000000000000000000000000000000000000000000000000000000005a000000000000000000000000000000000000000000000000000000000000006800000000000000000000000000000000000000000000000000000000000000780000000000000000000000000000000000000000000000000000000000000084000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000ae00000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000cc00000000000000000000000000000000000000000000000000000000000000e800000000000000000000000000000000000000000000000000000000000000f8000000000000000000000000000000000000000000000000000000000000010600000000000000000000000000000000000000000000000000000000000001160000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000012e000000000000000000000000000000000000000000000000000000000000013800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003ce6e9f9f0000000000000000000000000000000000000000000000000000000002bc2cdb000000000000000000000000000000000000000000000000000000000448a5c40000000000000000000000000000000000000000000000000000000000000000000000000000000003655add6798b6a8b9b2756e59486cea85e8ba2400000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000742f1181e000000000000000000000000000000000000000000000000000000006eade577000000000000000000000000000000000000000000000000000000004dc2304d00000000000000000000000000000000000000000000000000000000ad21879e000000000000000000000000000000000000000000000000000000001cf14f330000000000000000000000000000000000000000000000000000000070712939000000000000000000000000000000000000000000000000000000006e4d22c20000000000000000000000000000000000000000000000000000000000000000000000000000000031d88294e48f70233be242a524b0bebb0d155bc40000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000049dec88b900000000000000000000000000000000000000000000000000000000ce19912900000000000000000000000000000000000000000000000000000000d10a0aec0000000000000000000000000000000000000000000000000000000074b1d75d000000000000000000000000000000000000000000000000000000000000000000000000000000003f4e01c435433cff56cc7e6a054fe210efd06645000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003c76d202d00000000000000000000000000000000000000000000000000000000839bb9a6000000000000000000000000000000000000000000000000000000008e756bb30000000000000000000000000000000000000000000000000000000000000000000000000000000085fd223609f69b8ab88383f8c9fa6a37d38582cc000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004fee2792b00000000000000000000000000000000000000000000000000000000bf6d79ab00000000000000000000000000000000000000000000000000000000c1c52f8800000000000000000000000000000000000000000000000000000000ec1c2bb5000000000000000000000000000000000000000000000000000000000000000000000000000000001ac15086efefb7aa04a6a39f3f4b83608103d2fa000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002241b71bb00000000000000000000000000000000000000000000000000000000bb14516c00000000000000000000000000000000000000000000000000000000000000000000000000000000a6682e09318c47832d95f202b177edb397a8a34200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000235a7206d00000000000000000000000000000000000000000000000000000000c05b1ec30000000000000000000000000000000000000000000000000000000000000000000000000000000007b24e3192b05fe37842f5c71aeea7d726a3cad5000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004961113df0000000000000000000000000000000000000000000000000000000010d94006000000000000000000000000000000000000000000000000000000008fe2b41400000000000000000000000000000000000000000000000000000000020ce3a600000000000000000000000000000000000000000000000000000000000000000000000000000000ca79e8eeae776affc65f539d6cda998a76b250fe0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000039912dde8000000000000000000000000000000000000000000000000000000005a601668000000000000000000000000000000000000000000000000000000008a4f4f9200000000000000000000000000000000000000000000000000000000000000000000000000000000af60235bc891aa08776e59eb6c123fd21a38e75000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000513abaf0700000000000000000000000000000000000000000000000000000000ece1373200000000000000000000000000000000000000000000000000000000ed903f7a00000000000000000000000000000000000000000000000000000000010d573000000000000000000000000000000000000000000000000000000000767a7b0500000000000000000000000000000000000000000000000000000000000000000000000000000000868f7da9164a29801fa58ca0bb6b9c90f497b6ad000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002ea40e51a00000000000000000000000000000000000000000000000000000000461aebf400000000000000000000000000000000000000000000000000000000000000000000000000000000fc11f4ebe9f7c7399464c82825a0b8678fdc4cff00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000aeee8b7ff0000000000000000000000000000000000000000000000000000000072e1132700000000000000000000000000000000000000000000000000000000f4f015700000000000000000000000000000000000000000000000000000000046a384be00000000000000000000000000000000000000000000000000000000e949756100000000000000000000000000000000000000000000000000000000504006ca00000000000000000000000000000000000000000000000000000000c4c1662b00000000000000000000000000000000000000000000000000000000bddffdc4000000000000000000000000000000000000000000000000000000000634612f000000000000000000000000000000000000000000000000000000003b9293000000000000000000000000000000000000000000000000000000000000000000000000000000000028e2ce61ec8ded7f7bc9cba02a33573f7dd9f5f5000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b5300000000000000000000000000000000000000000000000000000000000000000000000000000000c3cb507553f192879c74879102fbb80286bcf12f0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000032239f5560000000000000000000000000000000000000000000000000000000046efd16c0000000000000000000000000000000000000000000000000000000078b248e4000000000000000000000000000000000000000000000000000000000000000000000000000000004cde0f1ba09de4b9fc6850412528d0756516d87a000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004a7baf6fc000000000000000000000000000000000000000000000000000000006f70d212000000000000000000000000000000000000000000000000000000000967aa82000000000000000000000000000000000000000000000000000000000f48a482000000000000000000000000000000000000000000000000000000000000000000000000000000002f7c91d53d4ff3ae6a2a2092776095dbc14bc6df00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000146e04a2f00000000000000000000000000000000000000000000000000000000000000000000000000000000fc7c599947dca76440dd3729a1292190c645eb9200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000371d78fbc00000000000000000000000000000000000000000000000000000000f63761240000000000000000000000000000000000000000000000000000000033c72dfe000000000000000000000000000000000000000000000000000000000000000000000000000000005b5481ad34b79d8e920b5f0f83d718ed225a7102000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000001262201b6000000000000000000000000000000000000000000000000000000000000000000000000000000002966b694d1642392cd759b8d8d316b55eae7aa690000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xa8615f71b8dc8b88fd926aaf7d23e6d3cf8e7dd2d59ef579ab8ab46d14ca38b0" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25347890, + "transactionHash": "0x731e016ac0dea74d300588c8ee2b3c12914b86c01f3b041c572ef2041d3d70eb", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014e000000000000000000000000000000000000000000000000000000000000000130000000000000000000000000000000000000000000000000000000000000260000000000000000000000000000000000000000000000000000000000000034000000000000000000000000000000000000000000000000000000000000004a000000000000000000000000000000000000000000000000000000000000005a000000000000000000000000000000000000000000000000000000000000006800000000000000000000000000000000000000000000000000000000000000780000000000000000000000000000000000000000000000000000000000000084000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000ae00000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000cc00000000000000000000000000000000000000000000000000000000000000e800000000000000000000000000000000000000000000000000000000000000f8000000000000000000000000000000000000000000000000000000000000010600000000000000000000000000000000000000000000000000000000000001160000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000012e000000000000000000000000000000000000000000000000000000000000013800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003ce6e9f9f0000000000000000000000000000000000000000000000000000000002bc2cdb000000000000000000000000000000000000000000000000000000000448a5c40000000000000000000000000000000000000000000000000000000000000000000000000000000003655add6798b6a8b9b2756e59486cea85e8ba2400000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000742f1181e000000000000000000000000000000000000000000000000000000006eade577000000000000000000000000000000000000000000000000000000004dc2304d00000000000000000000000000000000000000000000000000000000ad21879e000000000000000000000000000000000000000000000000000000001cf14f330000000000000000000000000000000000000000000000000000000070712939000000000000000000000000000000000000000000000000000000006e4d22c20000000000000000000000000000000000000000000000000000000000000000000000000000000031d88294e48f70233be242a524b0bebb0d155bc40000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000049dec88b900000000000000000000000000000000000000000000000000000000ce19912900000000000000000000000000000000000000000000000000000000d10a0aec0000000000000000000000000000000000000000000000000000000074b1d75d000000000000000000000000000000000000000000000000000000000000000000000000000000003f4e01c435433cff56cc7e6a054fe210efd06645000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003c76d202d00000000000000000000000000000000000000000000000000000000839bb9a6000000000000000000000000000000000000000000000000000000008e756bb30000000000000000000000000000000000000000000000000000000000000000000000000000000085fd223609f69b8ab88383f8c9fa6a37d38582cc000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004fee2792b00000000000000000000000000000000000000000000000000000000bf6d79ab00000000000000000000000000000000000000000000000000000000c1c52f8800000000000000000000000000000000000000000000000000000000ec1c2bb5000000000000000000000000000000000000000000000000000000000000000000000000000000001ac15086efefb7aa04a6a39f3f4b83608103d2fa000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002241b71bb00000000000000000000000000000000000000000000000000000000bb14516c00000000000000000000000000000000000000000000000000000000000000000000000000000000a6682e09318c47832d95f202b177edb397a8a34200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000235a7206d00000000000000000000000000000000000000000000000000000000c05b1ec30000000000000000000000000000000000000000000000000000000000000000000000000000000007b24e3192b05fe37842f5c71aeea7d726a3cad5000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004961113df0000000000000000000000000000000000000000000000000000000010d94006000000000000000000000000000000000000000000000000000000008fe2b41400000000000000000000000000000000000000000000000000000000020ce3a600000000000000000000000000000000000000000000000000000000000000000000000000000000ca79e8eeae776affc65f539d6cda998a76b250fe0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000039912dde8000000000000000000000000000000000000000000000000000000005a601668000000000000000000000000000000000000000000000000000000008a4f4f9200000000000000000000000000000000000000000000000000000000000000000000000000000000af60235bc891aa08776e59eb6c123fd21a38e75000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000513abaf0700000000000000000000000000000000000000000000000000000000ece1373200000000000000000000000000000000000000000000000000000000ed903f7a00000000000000000000000000000000000000000000000000000000010d573000000000000000000000000000000000000000000000000000000000767a7b0500000000000000000000000000000000000000000000000000000000000000000000000000000000868f7da9164a29801fa58ca0bb6b9c90f497b6ad000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002ea40e51a00000000000000000000000000000000000000000000000000000000461aebf400000000000000000000000000000000000000000000000000000000000000000000000000000000fc11f4ebe9f7c7399464c82825a0b8678fdc4cff00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000aeee8b7ff0000000000000000000000000000000000000000000000000000000072e1132700000000000000000000000000000000000000000000000000000000f4f015700000000000000000000000000000000000000000000000000000000046a384be00000000000000000000000000000000000000000000000000000000e949756100000000000000000000000000000000000000000000000000000000504006ca00000000000000000000000000000000000000000000000000000000c4c1662b00000000000000000000000000000000000000000000000000000000bddffdc4000000000000000000000000000000000000000000000000000000000634612f000000000000000000000000000000000000000000000000000000003b9293000000000000000000000000000000000000000000000000000000000000000000000000000000000028e2ce61ec8ded7f7bc9cba02a33573f7dd9f5f5000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b5300000000000000000000000000000000000000000000000000000000000000000000000000000000c3cb507553f192879c74879102fbb80286bcf12f0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000032239f5560000000000000000000000000000000000000000000000000000000046efd16c0000000000000000000000000000000000000000000000000000000078b248e4000000000000000000000000000000000000000000000000000000000000000000000000000000004cde0f1ba09de4b9fc6850412528d0756516d87a000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004a7baf6fc000000000000000000000000000000000000000000000000000000006f70d212000000000000000000000000000000000000000000000000000000000967aa82000000000000000000000000000000000000000000000000000000000f48a482000000000000000000000000000000000000000000000000000000000000000000000000000000002f7c91d53d4ff3ae6a2a2092776095dbc14bc6df00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000146e04a2f00000000000000000000000000000000000000000000000000000000000000000000000000000000fc7c599947dca76440dd3729a1292190c645eb9200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000371d78fbc00000000000000000000000000000000000000000000000000000000f63761240000000000000000000000000000000000000000000000000000000033c72dfe000000000000000000000000000000000000000000000000000000000000000000000000000000005b5481ad34b79d8e920b5f0f83d718ed225a7102000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000001262201b6000000000000000000000000000000000000000000000000000000000000000000000000000000002966b694d1642392cd759b8d8d316b55eae7aa690000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xa8615f71b8dc8b88fd926aaf7d23e6d3cf8e7dd2d59ef579ab8ab46d14ca38b0", + "args": [ + [ + [ + "0x0000000000000000000000000000000000000000", + 2, + ["0xce6e9f9f", "0x02bc2cdb", "0x0448a5c4"] + ], + [ + "0x03655Add6798b6a8B9b2756E59486Cea85e8ba24", + 1, + [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + ], + [ + "0x31D88294E48f70233bE242A524B0bebb0d155BC4", + 1, + [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + ], + [ + "0x3F4e01c435433CfF56Cc7e6A054Fe210EFd06645", + 1, + ["0xc76d202d", "0x839bb9a6", "0x8e756bb3"] + ], + [ + "0x85FD223609f69b8aB88383F8c9FA6a37d38582CC", + 1, + [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + ], + [ + "0x1Ac15086EFeFb7aa04A6a39f3F4b83608103D2fA", + 1, + ["0x241b71bb", "0xbb14516c"] + ], + [ + "0xa6682e09318c47832D95f202b177Edb397a8a342", + 1, + ["0x35a7206d", "0xc05b1ec3"] + ], + [ + "0x07B24e3192B05FE37842F5C71aEEa7d726a3caD5", + 1, + [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + ], + [ + "0xcA79e8EEAe776AFfC65f539d6cdA998a76b250FE", + 1, + ["0x9912dde8", "0x5a601668", "0x8a4f4f92"] + ], + [ + "0xAf60235Bc891Aa08776E59Eb6c123fd21A38E750", + 1, + [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + ], + [ + "0x868f7DA9164a29801Fa58CA0BB6b9C90f497B6ad", + 0, + ["0xea40e51a", "0x461aebf4"] + ], + [ + "0xFC11f4ebe9f7c7399464c82825A0B8678fdc4cff", + 1, + [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + ], + [ + "0x28E2Ce61Ec8dEd7f7bC9CBa02a33573f7dd9f5F5", + 1, + [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + ], + [ + "0xc3cB507553f192879c74879102fBB80286bcf12F", + 1, + ["0x2239f556", "0x46efd16c", "0x78b248e4"] + ], + [ + "0x4cDe0F1bA09DE4B9fC6850412528D0756516D87A", + 1, + [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + ], + [ + "0x2f7C91D53d4Ff3ae6a2a2092776095DBc14bc6dF", + 1, + ["0x46e04a2f"] + ], + [ + "0xFc7c599947DCa76440DD3729a1292190C645Eb92", + 1, + ["0x71d78fbc", "0xf6376124", "0x33c72dfe"] + ], + [ + "0x5B5481Ad34b79D8e920B5F0f83d718ED225A7102", + 1, + ["0x262201b6"] + ], + [ + "0x2966b694D1642392CD759B8d8D316B55eaE7aA69", + 1, + ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"] + ] + ], + "0x0000000000000000000000000000000000000000", + "0x" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 25347890, + "cumulativeGasUsed": "1557011", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + ["0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", ["0x1f931c1c"]], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x03655Add6798b6a8B9b2756E59486Cea85e8ba24", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0x31D88294E48f70233bE242A524B0bebb0d155BC4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3F4e01c435433CfF56Cc7e6A054Fe210EFd06645", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x85FD223609f69b8aB88383F8c9FA6a37d38582CC", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x1Ac15086EFeFb7aa04A6a39f3F4b83608103D2fA", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xa6682e09318c47832D95f202b177Edb397a8a342", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x07B24e3192B05FE37842F5C71aEEa7d726a3caD5", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xcA79e8EEAe776AFfC65f539d6cdA998a76b250FE", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0xAf60235Bc891Aa08776E59Eb6c123fd21A38E750", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x868f7DA9164a29801Fa58CA0BB6b9C90f497B6ad", + "functionSelectors": ["0xea40e51a", "0x461aebf4"] + }, + { + "facetAddress": "0xFC11f4ebe9f7c7399464c82825A0B8678fdc4cff", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0x28E2Ce61Ec8dEd7f7bC9CBa02a33573f7dd9f5F5", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0xc3cB507553f192879c74879102fBB80286bcf12F", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x4cDe0F1bA09DE4B9fC6850412528D0756516D87A", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x2f7C91D53d4Ff3ae6a2a2092776095DBc14bc6dF", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xFc7c599947DCa76440DD3729a1292190C645Eb92", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x5B5481Ad34b79D8e920B5F0f83d718ED225A7102", + "functionSelectors": ["0x262201b6"] + }, + { + "facetAddress": "0x2966b694D1642392CD759B8d8D316B55eaE7aA69", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ] + } + ], + "diamondCut": [ + { + "facetAddress": "0x0000000000000000000000000000000000000000", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 2 + }, + { + "facetAddress": "0x03655Add6798b6a8B9b2756E59486Cea85e8ba24", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 1 + }, + { + "facetAddress": "0x31D88294E48f70233bE242A524B0bebb0d155BC4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 1 + }, + { + "facetAddress": "0x3F4e01c435433CfF56Cc7e6A054Fe210EFd06645", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 1 + }, + { + "facetAddress": "0x85FD223609f69b8aB88383F8c9FA6a37d38582CC", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 1 + }, + { + "facetAddress": "0x1Ac15086EFeFb7aa04A6a39f3F4b83608103D2fA", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 1 + }, + { + "facetAddress": "0xa6682e09318c47832D95f202b177Edb397a8a342", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 1 + }, + { + "facetAddress": "0x07B24e3192B05FE37842F5C71aEEa7d726a3caD5", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 1 + }, + { + "facetAddress": "0xcA79e8EEAe776AFfC65f539d6cdA998a76b250FE", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 1 + }, + { + "facetAddress": "0xAf60235Bc891Aa08776E59Eb6c123fd21A38E750", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 1 + }, + { + "facetAddress": "0x868f7DA9164a29801Fa58CA0BB6b9C90f497B6ad", + "functionSelectors": ["0xea40e51a", "0x461aebf4"], + "action": 0 + }, + { + "facetAddress": "0xFC11f4ebe9f7c7399464c82825A0B8678fdc4cff", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 1 + }, + { + "facetAddress": "0x28E2Ce61Ec8dEd7f7bC9CBa02a33573f7dd9f5F5", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 1 + }, + { + "facetAddress": "0xc3cB507553f192879c74879102fBB80286bcf12F", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 1 + }, + { + "facetAddress": "0x4cDe0F1bA09DE4B9fC6850412528D0756516D87A", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 1 + }, + { + "facetAddress": "0x2f7C91D53d4Ff3ae6a2a2092776095DBc14bc6dF", + "functionSelectors": ["0x46e04a2f"], + "action": 1 + }, + { + "facetAddress": "0xFc7c599947DCa76440DD3729a1292190C645Eb92", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 1 + }, + { + "facetAddress": "0x5B5481Ad34b79D8e920B5F0f83d718ED225A7102", + "functionSelectors": ["0x262201b6"], + "action": 1 + }, + { + "facetAddress": "0x2966b694D1642392CD759B8d8D316B55eaE7aA69", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ], + "action": 1 + } + ], + "history": [ + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "5530229", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000020000020000008000000840000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000008000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000420000000000000000000000000000000000000000000000000000000000000008000", + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "args": ["0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0"], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea00000000000000000000000000000000000000000000000000000000000001300000000000000000000000000000000000000000000000000000000000000001100000000000000000000000000000000000000000000000000000000000002200000000000000000000000000000000000000000000000000000000000000380000000000000000000000000000000000000000000000000000000000000048000000000000000000000000000000000000000000000000000000000000005600000000000000000000000000000000000000000000000000000000000000660000000000000000000000000000000000000000000000000000000000000072000000000000000000000000000000000000000000000000000000000000007e000000000000000000000000000000000000000000000000000000000000008e000000000000000000000000000000000000000000000000000000000000009c00000000000000000000000000000000000000000000000000000000000000ae00000000000000000000000000000000000000000000000000000000000000bc00000000000000000000000000000000000000000000000000000000000000d800000000000000000000000000000000000000000000000000000000000000e800000000000000000000000000000000000000000000000000000000000000f600000000000000000000000000000000000000000000000000000000000001060000000000000000000000000000000000000000000000000000000000000110000000000000000000000000000000000000000000000000000000000000011e0000000000000000000000000d326456fa02a0976a6304152248cdd576302471a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000742f1181e000000000000000000000000000000000000000000000000000000006eade577000000000000000000000000000000000000000000000000000000004dc2304d00000000000000000000000000000000000000000000000000000000ad21879e000000000000000000000000000000000000000000000000000000001cf14f330000000000000000000000000000000000000000000000000000000070712939000000000000000000000000000000000000000000000000000000006e4d22c200000000000000000000000000000000000000000000000000000000000000000000000000000000bb25ad0cb256f9cb457856b30c36756859a536570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000049dec88b900000000000000000000000000000000000000000000000000000000ce19912900000000000000000000000000000000000000000000000000000000d10a0aec0000000000000000000000000000000000000000000000000000000074b1d75d000000000000000000000000000000000000000000000000000000000000000000000000000000003b34fbafa24db8c5c6c88bb9996703a31bd0e97b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003c76d202d00000000000000000000000000000000000000000000000000000000839bb9a6000000000000000000000000000000000000000000000000000000008e756bb30000000000000000000000000000000000000000000000000000000000000000000000000000000042b98ea041d660ee5696ac64e0e684040f84bc5f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004fee2792b00000000000000000000000000000000000000000000000000000000bf6d79ab00000000000000000000000000000000000000000000000000000000c1c52f8800000000000000000000000000000000000000000000000000000000ec1c2bb5000000000000000000000000000000000000000000000000000000000000000000000000000000006de843c33e610cc76ab7d53675a19275b75d5442000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002241b71bb00000000000000000000000000000000000000000000000000000000bb14516c00000000000000000000000000000000000000000000000000000000000000000000000000000000e387aac3e2c1f690a21dc6dceb0ee8d903f068de00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000235a7206d00000000000000000000000000000000000000000000000000000000c05b1ec3000000000000000000000000000000000000000000000000000000000000000000000000000000007f05e46146f9d3cf2086633e43c1302116f7190d000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004961113df0000000000000000000000000000000000000000000000000000000010d94006000000000000000000000000000000000000000000000000000000008fe2b41400000000000000000000000000000000000000000000000000000000020ce3a6000000000000000000000000000000000000000000000000000000000000000000000000000000002ca57d87f6be51515ace674f8d520fa3abe8f5bb0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000039912dde8000000000000000000000000000000000000000000000000000000005a601668000000000000000000000000000000000000000000000000000000008a4f4f9200000000000000000000000000000000000000000000000000000000000000000000000000000000172caf420c79ee756020792d99c77db2c77db8e800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000513abaf0700000000000000000000000000000000000000000000000000000000ece1373200000000000000000000000000000000000000000000000000000000ed903f7a00000000000000000000000000000000000000000000000000000000010d573000000000000000000000000000000000000000000000000000000000767a7b0500000000000000000000000000000000000000000000000000000000000000000000000000000000355161f7da9da53ca4ab44fcd0372ce3b22fef29000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003ce6e9f9f0000000000000000000000000000000000000000000000000000000002bc2cdb000000000000000000000000000000000000000000000000000000000448a5c400000000000000000000000000000000000000000000000000000000000000000000000000000000be09acf7a2257aa063697d31f3b3e55bd524252e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000aeee8b7ff0000000000000000000000000000000000000000000000000000000072e1132700000000000000000000000000000000000000000000000000000000f4f015700000000000000000000000000000000000000000000000000000000046a384be00000000000000000000000000000000000000000000000000000000e949756100000000000000000000000000000000000000000000000000000000504006ca00000000000000000000000000000000000000000000000000000000c4c1662b00000000000000000000000000000000000000000000000000000000bddffdc4000000000000000000000000000000000000000000000000000000000634612f000000000000000000000000000000000000000000000000000000003b92930000000000000000000000000000000000000000000000000000000000000000000000000000000000d99dfbd7ee2cc714debff8390c33f0dbb1502ed2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b53000000000000000000000000000000000000000000000000000000000000000000000000000000005503066a836df524f8871cbb84c4290f7d65bb600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000032239f5560000000000000000000000000000000000000000000000000000000046efd16c0000000000000000000000000000000000000000000000000000000078b248e40000000000000000000000000000000000000000000000000000000000000000000000000000000028a91ecd8c1637bb102bca987084aec35b7f5853000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004a7baf6fc000000000000000000000000000000000000000000000000000000006f70d212000000000000000000000000000000000000000000000000000000000967aa82000000000000000000000000000000000000000000000000000000000f48a4820000000000000000000000000000000000000000000000000000000000000000000000000000000058af9da008a886558f6ddedaa38137b2711bd50000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000146e04a2f00000000000000000000000000000000000000000000000000000000000000000000000000000000a4b93723c4543eb67fefaee124101f044778ee2d00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000371d78fbc00000000000000000000000000000000000000000000000000000000f63761240000000000000000000000000000000000000000000000000000000033c72dfe00000000000000000000000000000000000000000000000000000000000000000000000000000000001595e532b83a43f193902f418c6365205242f9000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000001262201b60000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006c41cf14f330000000000000000000000000000000000000000000000000000000000000020000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000006200000000000000000000000007360904a663b9cb66bab538f406c04d8da86229d000000000000000000000000ab59409415e28deeb6255ba64527e3271d057fed0000000000000000000000007ccb2ddb4f7a239ca9edf765edc0bb4e7e04ef5f00000000000000000000000018d45bc9319937d2099dc8e0d0edceee033fcf2500000000000000000000000095143890162bd671d77ae9b771881a1cb76c29a4000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000180000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002800000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000480000000000000000000000000000000000000000000000000000000000000004000000000000000000000000061460874a7196d6a22d1ee4922473664b3e952700000000000000000000000000000000000000000000000000000000000000004434f4d50000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044144414900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005504344414900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000459444149000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000d0a1e359811322d97991e03f863a0c30c2cf029c0000000000000000000000000000000000000000000000000000000000000004574554480000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000004f96fe3b7a6cf9725f59d353f723c1bdb64ca6aa000000000000000000000000000000000000000000000000000000000000000344414900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000b7a4f3e9097c08da09517b5ab877f7a917224ede000000000000000000000000000000000000000000000000000000000000000455534443000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000a36085f69e2889c224210f603d836748e7dc008800000000000000000000000000000000000000000000000000000000000000044c494e4b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003000000000000000000000000f0d0eb522cfa50b716b3b1604c4f0fa6f04376ad0000000000000000000000004a92e71227d294f041bd82dd8f78591b75140d6300000000000000000000000041b5844f4680a8c38fbb695b7f9cfd1f64474a7200000000000000000000000000000000000000000000000000000000", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "blockNumber": 25103807, + "cumulativeGasUsed": "5530229", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "0x608060405260405162002d4538038062002d45833981016040819052620000269162000db2565b604080516000808252602082019092526200004e918491620000f560201b620000db1760201c565b620000688160000151620002b560201b6200027d1760201c565b60006200007f6200031760201b620003021760201c565b6301ffc9a760e01b600090815260039091016020526040808220805460ff1990811660019081179092556307e4c70760e21b845282842080548216831790556348e2b09360e01b845282842080548216831790556307f5828d60e41b845291909220805490911690911790555062001442915050565b60005b8351811015620002665760008482815181106200011157fe5b6020026020010151602001519050600060028111156200012d57fe5b8160028111156200013a57fe5b14156200018957620001838583815181106200015257fe5b6020026020010151600001518684815181106200016b57fe5b6020026020010151604001516200033b60201b60201c565b6200025c565b60018160028111156200019857fe5b1415620001e15762000183858381518110620001b057fe5b602002602001015160000151868481518110620001c957fe5b6020026020010151604001516200054e60201b60201c565b6002816002811115620001f057fe5b14156200023957620001838583815181106200020857fe5b6020026020010151600001518684815181106200022157fe5b6020026020010151604001516200077860201b60201c565b60405162461bcd60e51b815260040162000253906200117c565b60405180910390fd5b50600101620000f8565b507f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb6738383836040516200029c9392919062000f25565b60405180910390a1620002b082826200083f565b505050565b6000620002c162000317565b6004810180546001600160a01b038581166001600160a01b031983168117909355604051939450169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c90565b60008151116200035f5760405162461bcd60e51b81526004016200025390620010d4565b60006200036b62000317565b90506001600160a01b038316620003965760405162461bcd60e51b81526004016200025390620011c3565b6001600160a01b038316600090815260018201602052604090205461ffff81166200043c57620003e08460405180606001604052806024815260200162002d21602491396200097c565b6002820180546001600160a01b038616600081815260018087016020908152604083208201805461ffff191661ffff90961695909517909455845490810185559381529190912090910180546001600160a01b03191690911790555b60005b8351811015620005475760008482815181106200045857fe5b6020908102919091018101516001600160e01b031981166000908152918690526040909120549091506001600160a01b03168015620004ab5760405162461bcd60e51b81526004016200025390620012ba565b506001600160a01b0386166000818152600186810160209081526040808420805480850182559085528285206008820401805463ffffffff60079093166004026101000a928302191660e089901c929092029190911790556001600160e01b0319909516835287905292902080546001600160a01b03191690911761ffff60a01b1916600160a01b61ffff86160217905591820191016200043f565b5050505050565b6000815111620005725760405162461bcd60e51b81526004016200025390620010d4565b60006200057e62000317565b90506001600160a01b038316620005a95760405162461bcd60e51b81526004016200025390620011c3565b6001600160a01b038316600090815260018201602052604090205461ffff81166200064f57620005f38460405180606001604052806024815260200162002d21602491396200097c565b6002820180546001600160a01b038616600081815260018087016020908152604083208201805461ffff191661ffff90961695909517909455845490810185559381529190912090910180546001600160a01b03191690911790555b60005b8351811015620005475760008482815181106200066b57fe5b6020908102919091018101516001600160e01b031981166000908152918690526040909120549091506001600160a01b03908116908716811415620006c45760405162461bcd60e51b8152600401620002539062001317565b620006d08183620009a0565b506001600160e01b03198116600081815260208681526040808320805461ffff60a01b1916600160a01b61ffff8a16021781556001600160a01b038b168085526001808b018552928520805480850182559086528486206008820401805463ffffffff60079093166004026101000a928302191660e09990991c91909102979097179096559390925286905281546001600160a01b0319169092179055918201910162000652565b60008151116200079c5760405162461bcd60e51b81526004016200025390620010d4565b6000620007a862000317565b90506001600160a01b03831615620007d45760405162461bcd60e51b8152600401620002539062001374565b60005b825181101562000839576000838281518110620007f057fe5b6020908102919091018101516001600160e01b031981166000908152918590526040909120549091506001600160a01b03166200082e8183620009a0565b5050600101620007d7565b50505050565b6001600160a01b0382166200087657805115620008705760405162461bcd60e51b8152600401620002539062001031565b62000978565b60008151116200089a5760405162461bcd60e51b815260040162000253906200120f565b6001600160a01b0382163014620008d057620008d08260405180606001604052806028815260200162002cf9602891396200097c565b600080836001600160a01b031683604051620008ed919062000f07565b600060405180830381855af49150503d80600081146200092a576040519150601f19603f3d011682016040523d82523d6000602084013e6200092f565b606091505b50915091508162000839578051156200095e578060405162461bcd60e51b815260040162000253919062001015565b60405162461bcd60e51b815260040162000253906200108e565b5050565b813b8181620008395760405162461bcd60e51b815260040162000253919062001015565b6000620009ac62000317565b90506001600160a01b038316620009d75760405162461bcd60e51b815260040162000253906200111f565b6001600160a01b03831630141562000a035760405162461bcd60e51b815260040162000253906200126c565b6001600160e01b03198216600090815260208281526040808320546001600160a01b03871684526001850190925290912054600160a01b90910461ffff16906000190180821462000b27576001600160a01b0385166000908152600184016020526040812080548390811062000a7557fe5b600091825260208083206008830401546001600160a01b038a168452600188019091526040909220805460079092166004026101000a90920460e01b92508291908590811062000ac157fe5b600091825260208083206008830401805463ffffffff60079094166004026101000a938402191660e09590951c929092029390931790556001600160e01b031992909216825284905260409020805461ffff60a01b1916600160a01b61ffff8516021790555b6001600160a01b0385166000908152600184016020526040902080548062000b4b57fe5b60008281526020808220600860001990940193840401805463ffffffff600460078716026101000a0219169055919092556001600160e01b0319861682528490526040902080546001600160b01b031916905580620005475760028301546001600160a01b03861660009081526001858101602052604090912001546000199091019061ffff1680821462000c6357600085600201838154811062000bec57fe5b6000918252602090912001546002870180546001600160a01b03909216925082918490811062000c1857fe5b600091825260208083209190910180546001600160a01b0319166001600160a01b0394851617905592909116815260018781019092526040902001805461ffff191661ffff83161790555b8460020180548062000c7157fe5b60008281526020808220830160001990810180546001600160a01b03191690559092019092556001600160a01b03891682526001878101909152604090912001805461ffff1916905550505050505050565b80516001600160a01b038116811462000cdb57600080fd5b919050565b600082601f83011262000cf1578081fd5b8151602062000d0a62000d0483620013f5565b620013d1565b828152818101908583018385028701840188101562000d27578586fd5b855b8581101562000d5d5781516001600160e01b03198116811462000d4a578788fd5b8452928401929084019060010162000d29565b5090979650505050505050565b60006020828403121562000d7c578081fd5b604051602081016001600160401b038111828210171562000d9957fe5b60405290508062000daa8362000cc3565b905292915050565b6000806040838503121562000dc5578182fd5b82516001600160401b038082111562000ddc578384fd5b818501915085601f83011262000df0578384fd5b8151602062000e0362000d0483620013f5565b82815281810190858301885b8581101562000eaa57815188016060818e03601f1901121562000e30578a8bfd5b604051606081018181108a8211171562000e4657fe5b60405262000e5682880162000cc3565b815260408201516003811062000e6a578c8dfd5b8188015260608201518981111562000e80578c8dfd5b62000e908f898386010162000ce0565b604083015250855250928401929084019060010162000e0f565b5050809750505062000ebf8882890162000d6a565b9450505050509250929050565b6001600160a01b03169052565b6000815180845262000ef381602086016020860162001413565b601f01601f19169290920160200192915050565b6000825162000f1b81846020870162001413565b9190910192915050565b606080825284518282018190526000919060809081850190602080820287018401818b01875b8481101562000fe257898303607f19018652815180516001600160a01b0316845284810151898501906003811062000f7f57fe5b858701526040918201519185018a9052815190819052908501908a90898601905b8083101562000fcc5783516001600160e01b031916825292870192600192909201919087019062000fa0565b5097860197945050509083019060010162000f4b565b505062000ff28289018b62000ecc565b878103604089015262001006818a62000ed9565b9b9a5050505050505050505050565b6000602082526200102a602083018462000ed9565b9392505050565b6020808252603c908201527f4c69624469616d6f6e644375743a205f696e697420697320616464726573732860408201527f3029206275745f63616c6c64617461206973206e6f7420656d70747900000000606082015260800190565b60208082526026908201527f4c69624469616d6f6e644375743a205f696e69742066756e6374696f6e2072656040820152651d995c9d195960d21b606082015260800190565b6020808252602b908201527f4c69624469616d6f6e644375743a204e6f2073656c6563746f727320696e206660408201526a1858d95d081d1bc818dd5d60aa1b606082015260800190565b60208082526037908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f76652066756e6360408201527f74696f6e207468617420646f65736e2774206578697374000000000000000000606082015260800190565b60208082526027908201527f4c69624469616d6f6e644375743a20496e636f727265637420466163657443756040820152663a20b1ba34b7b760c91b606082015260800190565b6020808252602c908201527f4c69624469616d6f6e644375743a204164642066616365742063616e2774206260408201526b65206164647265737328302960a01b606082015260800190565b6020808252603d908201527f4c69624469616d6f6e644375743a205f63616c6c6461746120697320656d707460408201527f7920627574205f696e6974206973206e6f742061646472657373283029000000606082015260800190565b6020808252602e908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f766520696d6d7560408201526d3a30b1363290333ab731ba34b7b760911b606082015260800190565b60208082526035908201527f4c69624469616d6f6e644375743a2043616e2774206164642066756e6374696f60408201527f6e207468617420616c7265616479206578697374730000000000000000000000606082015260800190565b60208082526038908201527f4c69624469616d6f6e644375743a2043616e2774207265706c6163652066756e60408201527f6374696f6e20776974682073616d652066756e6374696f6e0000000000000000606082015260800190565b60208082526036908201527f4c69624469616d6f6e644375743a2052656d6f7665206661636574206164647260408201527f657373206d757374206265206164647265737328302900000000000000000000606082015260800190565b6040518181016001600160401b0381118282101715620013ed57fe5b604052919050565b60006001600160401b038211156200140957fe5b5060209081020190565b60005b838110156200143057818101518382015260200162001416565b83811115620008395750506000910152565b6118a780620014526000396000f3fe60806040523661000b57005b600080357fffffffff000000000000000000000000000000000000000000000000000000001681527fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c6020819052604090912054819073ffffffffffffffffffffffffffffffffffffffff16806100b7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906115f3565b60405180910390fd5b3660008037600080366000845af43d6000803e8080156100d6573d6000f35b3d6000fd5b60005b83518110156102325760008482815181106100f557fe5b60200260200101516020015190506000600281111561011057fe5b81600281111561011c57fe5b141561015f5761015a85838151811061013157fe5b60200260200101516000015186848151811061014957fe5b602002602001015160400151610326565b610229565b600181600281111561016d57fe5b14156101ab5761015a85838151811061018257fe5b60200260200101516000015186848151811061019a57fe5b60200260200101516040015161065e565b60028160028111156101b957fe5b14156101f75761015a8583815181106101ce57fe5b6020026020010151600001518684815181106101e657fe5b6020026020010151604001516109ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611539565b506001016100de565b507f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb67383838360405161026693929190611282565b60405180910390a16102788282610acb565b505050565b6000610287610302565b60048101805473ffffffffffffffffffffffffffffffffffffffff8581167fffffffffffffffffffffffff000000000000000000000000000000000000000083168117909355604051939450169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c90565b6000815111610361576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b600061036b610302565b905073ffffffffffffffffffffffffffffffffffffffff83166103ba576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166104ab5761040d8460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106104c557fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff168015610554576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906116e2565b5073ffffffffffffffffffffffffffffffffffffffff86166000818152600186810160209081526040808420805480850182559085528285206008820401805463ffffffff60079093166004026101000a928302191660e089901c929092029190911790557fffffffff00000000000000000000000000000000000000000000000000000000909516835287905292902080547fffffffffffffffffffffffff0000000000000000000000000000000000000000169091177fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff86160217905591820191016104ae565b5050505050565b6000815111610699576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006106a3610302565b905073ffffffffffffffffffffffffffffffffffffffff83166106f2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166107e3576107458460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106107fd57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff908116908716811415610892576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061173f565b61089c8183610cbc565b507fffffffff00000000000000000000000000000000000000000000000000000000811660008181526020868152604080832080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8a160217815573ffffffffffffffffffffffffffffffffffffffff8b168085526001808b018552928520805480850182559086528486206008820401805463ffffffff60079093166004026101000a928302191660e09990991c91909102979097179096559390925286905281547fffffffffffffffffffffffff000000000000000000000000000000000000000016909217905591820191016107e6565b60008151116109e6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006109f0610302565b905073ffffffffffffffffffffffffffffffffffffffff831615610a40576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061179c565b60005b8251811015610ac5576000838281518110610a5a57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529185905260409091205490915073ffffffffffffffffffffffffffffffffffffffff16610abb8183610cbc565b5050600101610a43565b50505050565b73ffffffffffffffffffffffffffffffffffffffff8216610b2457805115610b1f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906113c5565b610c7d565b6000815111610b5f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611628565b73ffffffffffffffffffffffffffffffffffffffff82163014610b9e57610b9e8260405180606001604052806028815260200161182660289139610c81565b6000808373ffffffffffffffffffffffffffffffffffffffff1683604051610bc69190611266565b600060405180830381855af49150503d8060008114610c01576040519150601f19603f3d011682016040523d82523d6000602084013e610c06565b606091505b509150915081610ac557805115610c4b57806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611422565b5050565b813b8181610ac5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6000610cc6610302565b905073ffffffffffffffffffffffffffffffffffffffff8316610d15576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906114dc565b73ffffffffffffffffffffffffffffffffffffffff8316301415610d65576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611685565b7fffffffff0000000000000000000000000000000000000000000000000000000082166000908152602082815260408083205473ffffffffffffffffffffffffffffffffffffffff8716845260018501909252909120547401000000000000000000000000000000000000000090910461ffff16907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01808214610f375773ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260408120805483908110610e3657fe5b6000918252602080832060088304015473ffffffffffffffffffffffffffffffffffffffff8a168452600188019091526040909220805460079092166004026101000a90920460e01b925082919085908110610e8e57fe5b600091825260208083206008830401805463ffffffff60079094166004026101000a938402191660e09590951c929092029390931790557fffffffff000000000000000000000000000000000000000000000000000000009290921682528490526040902080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8516021790555b73ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260409020805480610f6757fe5b6000828152602080822060087fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90940193840401805463ffffffff600460078716026101000a0219169055919092557fffffffff00000000000000000000000000000000000000000000000000000000861682528490526040902080547fffffffffffffffffffff000000000000000000000000000000000000000000001690558061065757600283015473ffffffffffffffffffffffffffffffffffffffff861660009081526001858101602052604090912001547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9091019061ffff1680821461114357600085600201838154811061107e57fe5b60009182526020909120015460028701805473ffffffffffffffffffffffffffffffffffffffff90921692508291849081106110b657fe5b600091825260208083209190910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff9485161790559290911681526001878101909252604090200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff83161790555b8460020180548061115057fe5b6000828152602080822083017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90810180547fffffffffffffffffffffffff000000000000000000000000000000000000000016905590920190925573ffffffffffffffffffffffffffffffffffffffff89168252600187810190915260409091200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000016905550505050505050565b73ffffffffffffffffffffffffffffffffffffffff169052565b600081518084526112348160208601602086016117f9565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b600082516112788184602087016117f9565b9190910192915050565b606080825284518282018190526000919060809081850190602080820287018401818b01875b8481101561137c577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff808a8403018652815188840173ffffffffffffffffffffffffffffffffffffffff8251168552858201516003811061130457fe5b858701526040918201519185018a9052815190819052908501908a90898601905b808310156113675783517fffffffff00000000000000000000000000000000000000000000000000000000168252928701926001929092019190870190611325565b509786019794505050908301906001016112a8565b505061138a8289018b611202565b878103604089015261139c818a61121c565b9b9a5050505050505050505050565b6000602082526113be602083018461121c565b9392505050565b6020808252603c908201527f4c69624469616d6f6e644375743a205f696e697420697320616464726573732860408201527f3029206275745f63616c6c64617461206973206e6f7420656d70747900000000606082015260800190565b60208082526026908201527f4c69624469616d6f6e644375743a205f696e69742066756e6374696f6e20726560408201527f7665727465640000000000000000000000000000000000000000000000000000606082015260800190565b6020808252602b908201527f4c69624469616d6f6e644375743a204e6f2073656c6563746f727320696e206660408201527f6163657420746f20637574000000000000000000000000000000000000000000606082015260800190565b60208082526037908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f76652066756e6360408201527f74696f6e207468617420646f65736e2774206578697374000000000000000000606082015260800190565b60208082526027908201527f4c69624469616d6f6e644375743a20496e636f7272656374204661636574437560408201527f74416374696f6e00000000000000000000000000000000000000000000000000606082015260800190565b6020808252602c908201527f4c69624469616d6f6e644375743a204164642066616365742063616e2774206260408201527f6520616464726573732830290000000000000000000000000000000000000000606082015260800190565b6020808252818101527f4469616d6f6e643a2046756e6374696f6e20646f6573206e6f74206578697374604082015260600190565b6020808252603d908201527f4c69624469616d6f6e644375743a205f63616c6c6461746120697320656d707460408201527f7920627574205f696e6974206973206e6f742061646472657373283029000000606082015260800190565b6020808252602e908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f766520696d6d7560408201527f7461626c652066756e6374696f6e000000000000000000000000000000000000606082015260800190565b60208082526035908201527f4c69624469616d6f6e644375743a2043616e2774206164642066756e6374696f60408201527f6e207468617420616c7265616479206578697374730000000000000000000000606082015260800190565b60208082526038908201527f4c69624469616d6f6e644375743a2043616e2774207265706c6163652066756e60408201527f6374696f6e20776974682073616d652066756e6374696f6e0000000000000000606082015260800190565b60208082526036908201527f4c69624469616d6f6e644375743a2052656d6f7665206661636574206164647260408201527f657373206d757374206265206164647265737328302900000000000000000000606082015260800190565b60005b838110156118145781810151838201526020016117fc565b83811115610ac5575050600091015256fe4c69624469616d6f6e644375743a205f696e6974206164647265737320686173206e6f20636f64654c69624469616d6f6e644375743a204e657720666163657420686173206e6f20636f6465a264697066735822122054a3c3a118803545231f43700030cb5e290869be0182196a4a05e7d4a1b71d7e64736f6c634300070600334c69624469616d6f6e644375743a205f696e6974206164647265737320686173206e6f20636f64654c69624469616d6f6e644375743a204e657720666163657420686173206e6f20636f6465", + "deployedBytecode": "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", + "facets": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0x61460874a7196d6a22d1ee4922473664b3e95270" + }, + { + "sym": "ADAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "PCDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "YDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "WETH", + "addr": "0xd0a1e359811322d97991e03f863a0c30c2cf029c" + }, + { + "sym": "DAI", + "addr": "0x4f96fe3b7a6cf9725f59d353f723c1bdb64ca6aa" + }, + { + "sym": "USDC", + "addr": "0xb7a4f3e9097c08da09517b5ab877f7a917224ede" + }, + { + "sym": "LINK", + "addr": "0xa36085F69e2889c224210F603D836748e7dC0088" + } + ], + "cTokens": [ + "0xf0d0eb522cfa50b716b3b1604c4f0fa6f04376ad", + "0x4a92e71227d294f041bd82dd8f78591b75140d63", + "0x41b5844f4680a8c38fbb695b7f9cfd1f64474a72" + ], + "tellerNFT": "0x7360904A663B9Cb66baB538F406C04D8da86229d", + "loansEscrowBeacon": "0xAb59409415e28deEb6255ba64527E3271D057FED", + "collateralEscrowBeacon": "0x7cCb2ddB4f7a239CA9edF765edC0bb4e7e04Ef5F", + "tTokenBeacon": "0x18D45BC9319937d2099Dc8e0D0EdCEEe033fCf25", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "receipt": { + "to": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "204539", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000000000000000000000000040000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb", + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25104070, + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000617bf3ec25f4b04ca986ae559ed37be7f68cccad0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25104070, + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000617bf3ec25f4b04ca986ae559ed37be7f68cccad0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb", + "args": [ + [ + [ + "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + 0, + ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"] + ] + ], + "0x0000000000000000000000000000000000000000", + "0x" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 25104070, + "cumulativeGasUsed": "204539", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + [ + "0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", + ["0x1f931c1c"] + ], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ], + "action": 0 + } + ], + "history": [ + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "5530229", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000020000020000008000000840000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000008000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000420000000000000000000000000000000000000000000000000000000000000008000", + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "args": [ + "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0" + ], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "blockNumber": 25103807, + "cumulativeGasUsed": "5530229", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0x61460874a7196d6a22d1ee4922473664b3e95270" + }, + { + "sym": "ADAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "PCDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "YDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "WETH", + "addr": "0xd0a1e359811322d97991e03f863a0c30c2cf029c" + }, + { + "sym": "DAI", + "addr": "0x4f96fe3b7a6cf9725f59d353f723c1bdb64ca6aa" + }, + { + "sym": "USDC", + "addr": "0xb7a4f3e9097c08da09517b5ab877f7a917224ede" + }, + { + "sym": "LINK", + "addr": "0xa36085F69e2889c224210F603D836748e7dC0088" + } + ], + "cTokens": [ + "0xf0d0eb522cfa50b716b3b1604c4f0fa6f04376ad", + "0x4a92e71227d294f041bd82dd8f78591b75140d63", + "0x41b5844f4680a8c38fbb695b7f9cfd1f64474a72" + ], + "tellerNFT": "0x7360904A663B9Cb66baB538F406C04D8da86229d", + "loansEscrowBeacon": "0xAb59409415e28deEb6255ba64527E3271D057FED", + "collateralEscrowBeacon": "0x7cCb2ddB4f7a239CA9edF765edC0bb4e7e04Ef5F", + "tTokenBeacon": "0x18D45BC9319937d2099Dc8e0D0EdCEEe033fCf25", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanUserRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanConsensusResponse[]", + "name": "responses", + "type": "tuple[]" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanUserRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanConsensusResponse[]", + "name": "responses", + "type": "tuple[]" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "internalType": "uint16[]", + "name": "nftIDs", + "type": "uint16[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "dictAddress", + "type": "address" + } + ], + "name": "setNFTDictionary", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0xcfb06a8fa9f110f013a2294a3504a64365a04031b5a9c8219a12fb21e22944fd", + "receipt": { + "to": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "117091", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000000000000000000000000040000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0x0e5190b15a12821c9cdcad41292ac9b07c5cf51745bdbf29987a90c165e3bb1a", + "transactionHash": "0xcfb06a8fa9f110f013a2294a3504a64365a04031b5a9c8219a12fb21e22944fd", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25503818, + "transactionHash": "0xcfb06a8fa9f110f013a2294a3504a64365a04031b5a9c8219a12fb21e22944fd", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea000000000000000000000000000000000000000000000000000000000000001600000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002000000000000000000000000037a2a7c578f8f8e84d51623294f088811c8dfeea000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002ea40e51a00000000000000000000000000000000000000000000000000000000fe5d095b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024987df220000000000000000000000000f270070dc4aaf37823fa96c823e17cb291d8d57a00000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x0e5190b15a12821c9cdcad41292ac9b07c5cf51745bdbf29987a90c165e3bb1a" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25503818, + "transactionHash": "0xcfb06a8fa9f110f013a2294a3504a64365a04031b5a9c8219a12fb21e22944fd", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea000000000000000000000000000000000000000000000000000000000000001600000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002000000000000000000000000037a2a7c578f8f8e84d51623294f088811c8dfeea000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002ea40e51a00000000000000000000000000000000000000000000000000000000fe5d095b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024987df220000000000000000000000000f270070dc4aaf37823fa96c823e17cb291d8d57a00000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x0e5190b15a12821c9cdcad41292ac9b07c5cf51745bdbf29987a90c165e3bb1a", + "args": [ + [ + [ + "0x37A2a7c578F8F8E84d51623294f088811c8DFeea", + 1, + ["0xea40e51a", "0xfe5d095b"] + ] + ], + "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "0x987df220000000000000000000000000f270070dc4aaf37823fa96c823e17cb291d8d57a" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 25503818, + "cumulativeGasUsed": "117091", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + ["0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", ["0x1f931c1c"]], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x03655Add6798b6a8B9b2756E59486Cea85e8ba24", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0x31D88294E48f70233bE242A524B0bebb0d155BC4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3F4e01c435433CfF56Cc7e6A054Fe210EFd06645", + "functionSelectors": ["0xc76d202d", "0x839bb9a6", "0x8e756bb3"] + }, + { + "facetAddress": "0x85FD223609f69b8aB88383F8c9FA6a37d38582CC", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0xa6682e09318c47832D95f202b177Edb397a8a342", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x1Ac15086EFeFb7aa04A6a39f3F4b83608103D2fA", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xcA79e8EEAe776AFfC65f539d6cdA998a76b250FE", + "functionSelectors": ["0x9912dde8", "0x5a601668", "0x8a4f4f92"] + }, + { + "facetAddress": "0x07B24e3192B05FE37842F5C71aEEa7d726a3caD5", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xAf60235Bc891Aa08776E59Eb6c123fd21A38E750", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0xFC11f4ebe9f7c7399464c82825A0B8678fdc4cff", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xE1C9D9f11fc759b4c60e13b5D11502c0B27AF2b7", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x975BdA2061e3C7FC2435635794Ee7971D5406C3D", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x987df220", + "0x0f48a482" + ] + }, + { + "facetAddress": "0xc3cB507553f192879c74879102fBB80286bcf12F", + "functionSelectors": ["0x2239f556", "0x46efd16c", "0x78b248e4"] + }, + { + "facetAddress": "0x2f7C91D53d4Ff3ae6a2a2092776095DBc14bc6dF", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xFc7c599947DCa76440DD3729a1292190C645Eb92", + "functionSelectors": ["0x71d78fbc", "0xf6376124", "0x33c72dfe"] + }, + { + "facetAddress": "0x2966b694D1642392CD759B8d8D316B55eaE7aA69", + "functionSelectors": ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"] + }, + { + "facetAddress": "0x5B5481Ad34b79D8e920B5F0f83d718ED225A7102", + "functionSelectors": ["0x262201b6"] + }, + { + "facetAddress": "0x37A2a7c578F8F8E84d51623294f088811c8DFeea", + "functionSelectors": ["0xea40e51a", "0xfe5d095b"] + } + ], + "diamondCut": [ + { + "facetAddress": "0x37A2a7c578F8F8E84d51623294f088811c8DFeea", + "functionSelectors": ["0xea40e51a", "0xfe5d095b"], + "action": 1 + } + ], + "execute": { + "methodName": "setNFTDictionary", + "args": ["0xF270070Dc4AAF37823Fa96c823e17cb291d8D57A"] + }, + "history": [ + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "5530229", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000020000020000008000000840000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000008000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000420000000000000000000000000000000000000000000000000000000000000008000", + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "args": ["0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0"], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "blockNumber": 25103807, + "cumulativeGasUsed": "5530229", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0x61460874a7196d6a22d1ee4922473664b3e95270" + }, + { + "sym": "ADAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "PCDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "YDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "WETH", + "addr": "0xd0a1e359811322d97991e03f863a0c30c2cf029c" + }, + { + "sym": "DAI", + "addr": "0x4f96fe3b7a6cf9725f59d353f723c1bdb64ca6aa" + }, + { + "sym": "USDC", + "addr": "0xb7a4f3e9097c08da09517b5ab877f7a917224ede" + }, + { + "sym": "LINK", + "addr": "0xa36085F69e2889c224210F603D836748e7dC0088" + } + ], + "cTokens": [ + "0xf0d0eb522cfa50b716b3b1604c4f0fa6f04376ad", + "0x4a92e71227d294f041bd82dd8f78591b75140d63", + "0x41b5844f4680a8c38fbb695b7f9cfd1f64474a72" + ], + "tellerNFT": "0x7360904A663B9Cb66baB538F406C04D8da86229d", + "loansEscrowBeacon": "0xAb59409415e28deEb6255ba64527E3271D057FED", + "collateralEscrowBeacon": "0x7cCb2ddB4f7a239CA9edF765edC0bb4e7e04Ef5F", + "tTokenBeacon": "0x18D45BC9319937d2099Dc8e0D0EdCEEe033fCf25", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "receipt": { + "to": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "204539", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000000000000000000000000040000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb", + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25104070, + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000617bf3ec25f4b04ca986ae559ed37be7f68cccad0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25104070, + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000617bf3ec25f4b04ca986ae559ed37be7f68cccad0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb", + "args": [ + [ + [ + "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + 0, + ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"] + ] + ], + "0x0000000000000000000000000000000000000000", + "0x" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 25104070, + "cumulativeGasUsed": "204539", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + ["0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", ["0x1f931c1c"]], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ], + "action": 0 + } + ], + "history": [ + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "5530229", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000020000020000008000000840000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000008000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000420000000000000000000000000000000000000000000000000000000000000008000", + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "args": ["0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0"], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "blockNumber": 25103807, + "cumulativeGasUsed": "5530229", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0x61460874a7196d6a22d1ee4922473664b3e95270" + }, + { + "sym": "ADAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "PCDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "YDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "WETH", + "addr": "0xd0a1e359811322d97991e03f863a0c30c2cf029c" + }, + { + "sym": "DAI", + "addr": "0x4f96fe3b7a6cf9725f59d353f723c1bdb64ca6aa" + }, + { + "sym": "USDC", + "addr": "0xb7a4f3e9097c08da09517b5ab877f7a917224ede" + }, + { + "sym": "LINK", + "addr": "0xa36085F69e2889c224210F603D836748e7dC0088" + } + ], + "cTokens": [ + "0xf0d0eb522cfa50b716b3b1604c4f0fa6f04376ad", + "0x4a92e71227d294f041bd82dd8f78591b75140d63", + "0x41b5844f4680a8c38fbb695b7f9cfd1f64474a72" + ], + "tellerNFT": "0x7360904A663B9Cb66baB538F406C04D8da86229d", + "loansEscrowBeacon": "0xAb59409415e28deEb6255ba64527E3271D057FED", + "collateralEscrowBeacon": "0x7cCb2ddB4f7a239CA9edF765edC0bb4e7e04Ef5F", + "tTokenBeacon": "0x18D45BC9319937d2099Dc8e0D0EdCEEe033fCf25", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanUserRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanConsensusResponse[]", + "name": "responses", + "type": "tuple[]" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanUserRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanConsensusResponse[]", + "name": "responses", + "type": "tuple[]" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x731e016ac0dea74d300588c8ee2b3c12914b86c01f3b041c572ef2041d3d70eb", + "receipt": { + "to": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "1557011", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000000000000000000000000040000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xa8615f71b8dc8b88fd926aaf7d23e6d3cf8e7dd2d59ef579ab8ab46d14ca38b0", + "transactionHash": "0x731e016ac0dea74d300588c8ee2b3c12914b86c01f3b041c572ef2041d3d70eb", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25347890, + "transactionHash": "0x731e016ac0dea74d300588c8ee2b3c12914b86c01f3b041c572ef2041d3d70eb", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014e000000000000000000000000000000000000000000000000000000000000000130000000000000000000000000000000000000000000000000000000000000260000000000000000000000000000000000000000000000000000000000000034000000000000000000000000000000000000000000000000000000000000004a000000000000000000000000000000000000000000000000000000000000005a000000000000000000000000000000000000000000000000000000000000006800000000000000000000000000000000000000000000000000000000000000780000000000000000000000000000000000000000000000000000000000000084000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000ae00000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000cc00000000000000000000000000000000000000000000000000000000000000e800000000000000000000000000000000000000000000000000000000000000f8000000000000000000000000000000000000000000000000000000000000010600000000000000000000000000000000000000000000000000000000000001160000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000012e000000000000000000000000000000000000000000000000000000000000013800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003ce6e9f9f0000000000000000000000000000000000000000000000000000000002bc2cdb000000000000000000000000000000000000000000000000000000000448a5c40000000000000000000000000000000000000000000000000000000000000000000000000000000003655add6798b6a8b9b2756e59486cea85e8ba2400000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000742f1181e000000000000000000000000000000000000000000000000000000006eade577000000000000000000000000000000000000000000000000000000004dc2304d00000000000000000000000000000000000000000000000000000000ad21879e000000000000000000000000000000000000000000000000000000001cf14f330000000000000000000000000000000000000000000000000000000070712939000000000000000000000000000000000000000000000000000000006e4d22c20000000000000000000000000000000000000000000000000000000000000000000000000000000031d88294e48f70233be242a524b0bebb0d155bc40000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000049dec88b900000000000000000000000000000000000000000000000000000000ce19912900000000000000000000000000000000000000000000000000000000d10a0aec0000000000000000000000000000000000000000000000000000000074b1d75d000000000000000000000000000000000000000000000000000000000000000000000000000000003f4e01c435433cff56cc7e6a054fe210efd06645000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003c76d202d00000000000000000000000000000000000000000000000000000000839bb9a6000000000000000000000000000000000000000000000000000000008e756bb30000000000000000000000000000000000000000000000000000000000000000000000000000000085fd223609f69b8ab88383f8c9fa6a37d38582cc000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004fee2792b00000000000000000000000000000000000000000000000000000000bf6d79ab00000000000000000000000000000000000000000000000000000000c1c52f8800000000000000000000000000000000000000000000000000000000ec1c2bb5000000000000000000000000000000000000000000000000000000000000000000000000000000001ac15086efefb7aa04a6a39f3f4b83608103d2fa000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002241b71bb00000000000000000000000000000000000000000000000000000000bb14516c00000000000000000000000000000000000000000000000000000000000000000000000000000000a6682e09318c47832d95f202b177edb397a8a34200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000235a7206d00000000000000000000000000000000000000000000000000000000c05b1ec30000000000000000000000000000000000000000000000000000000000000000000000000000000007b24e3192b05fe37842f5c71aeea7d726a3cad5000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004961113df0000000000000000000000000000000000000000000000000000000010d94006000000000000000000000000000000000000000000000000000000008fe2b41400000000000000000000000000000000000000000000000000000000020ce3a600000000000000000000000000000000000000000000000000000000000000000000000000000000ca79e8eeae776affc65f539d6cda998a76b250fe0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000039912dde8000000000000000000000000000000000000000000000000000000005a601668000000000000000000000000000000000000000000000000000000008a4f4f9200000000000000000000000000000000000000000000000000000000000000000000000000000000af60235bc891aa08776e59eb6c123fd21a38e75000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000513abaf0700000000000000000000000000000000000000000000000000000000ece1373200000000000000000000000000000000000000000000000000000000ed903f7a00000000000000000000000000000000000000000000000000000000010d573000000000000000000000000000000000000000000000000000000000767a7b0500000000000000000000000000000000000000000000000000000000000000000000000000000000868f7da9164a29801fa58ca0bb6b9c90f497b6ad000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002ea40e51a00000000000000000000000000000000000000000000000000000000461aebf400000000000000000000000000000000000000000000000000000000000000000000000000000000fc11f4ebe9f7c7399464c82825a0b8678fdc4cff00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000aeee8b7ff0000000000000000000000000000000000000000000000000000000072e1132700000000000000000000000000000000000000000000000000000000f4f015700000000000000000000000000000000000000000000000000000000046a384be00000000000000000000000000000000000000000000000000000000e949756100000000000000000000000000000000000000000000000000000000504006ca00000000000000000000000000000000000000000000000000000000c4c1662b00000000000000000000000000000000000000000000000000000000bddffdc4000000000000000000000000000000000000000000000000000000000634612f000000000000000000000000000000000000000000000000000000003b9293000000000000000000000000000000000000000000000000000000000000000000000000000000000028e2ce61ec8ded7f7bc9cba02a33573f7dd9f5f5000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b5300000000000000000000000000000000000000000000000000000000000000000000000000000000c3cb507553f192879c74879102fbb80286bcf12f0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000032239f5560000000000000000000000000000000000000000000000000000000046efd16c0000000000000000000000000000000000000000000000000000000078b248e4000000000000000000000000000000000000000000000000000000000000000000000000000000004cde0f1ba09de4b9fc6850412528d0756516d87a000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004a7baf6fc000000000000000000000000000000000000000000000000000000006f70d212000000000000000000000000000000000000000000000000000000000967aa82000000000000000000000000000000000000000000000000000000000f48a482000000000000000000000000000000000000000000000000000000000000000000000000000000002f7c91d53d4ff3ae6a2a2092776095dbc14bc6df00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000146e04a2f00000000000000000000000000000000000000000000000000000000000000000000000000000000fc7c599947dca76440dd3729a1292190c645eb9200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000371d78fbc00000000000000000000000000000000000000000000000000000000f63761240000000000000000000000000000000000000000000000000000000033c72dfe000000000000000000000000000000000000000000000000000000000000000000000000000000005b5481ad34b79d8e920b5f0f83d718ed225a7102000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000001262201b6000000000000000000000000000000000000000000000000000000000000000000000000000000002966b694d1642392cd759b8d8d316b55eae7aa690000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xa8615f71b8dc8b88fd926aaf7d23e6d3cf8e7dd2d59ef579ab8ab46d14ca38b0" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25347890, + "transactionHash": "0x731e016ac0dea74d300588c8ee2b3c12914b86c01f3b041c572ef2041d3d70eb", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014e000000000000000000000000000000000000000000000000000000000000000130000000000000000000000000000000000000000000000000000000000000260000000000000000000000000000000000000000000000000000000000000034000000000000000000000000000000000000000000000000000000000000004a000000000000000000000000000000000000000000000000000000000000005a000000000000000000000000000000000000000000000000000000000000006800000000000000000000000000000000000000000000000000000000000000780000000000000000000000000000000000000000000000000000000000000084000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000ae00000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000cc00000000000000000000000000000000000000000000000000000000000000e800000000000000000000000000000000000000000000000000000000000000f8000000000000000000000000000000000000000000000000000000000000010600000000000000000000000000000000000000000000000000000000000001160000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000012e000000000000000000000000000000000000000000000000000000000000013800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003ce6e9f9f0000000000000000000000000000000000000000000000000000000002bc2cdb000000000000000000000000000000000000000000000000000000000448a5c40000000000000000000000000000000000000000000000000000000000000000000000000000000003655add6798b6a8b9b2756e59486cea85e8ba2400000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000742f1181e000000000000000000000000000000000000000000000000000000006eade577000000000000000000000000000000000000000000000000000000004dc2304d00000000000000000000000000000000000000000000000000000000ad21879e000000000000000000000000000000000000000000000000000000001cf14f330000000000000000000000000000000000000000000000000000000070712939000000000000000000000000000000000000000000000000000000006e4d22c20000000000000000000000000000000000000000000000000000000000000000000000000000000031d88294e48f70233be242a524b0bebb0d155bc40000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000049dec88b900000000000000000000000000000000000000000000000000000000ce19912900000000000000000000000000000000000000000000000000000000d10a0aec0000000000000000000000000000000000000000000000000000000074b1d75d000000000000000000000000000000000000000000000000000000000000000000000000000000003f4e01c435433cff56cc7e6a054fe210efd06645000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003c76d202d00000000000000000000000000000000000000000000000000000000839bb9a6000000000000000000000000000000000000000000000000000000008e756bb30000000000000000000000000000000000000000000000000000000000000000000000000000000085fd223609f69b8ab88383f8c9fa6a37d38582cc000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004fee2792b00000000000000000000000000000000000000000000000000000000bf6d79ab00000000000000000000000000000000000000000000000000000000c1c52f8800000000000000000000000000000000000000000000000000000000ec1c2bb5000000000000000000000000000000000000000000000000000000000000000000000000000000001ac15086efefb7aa04a6a39f3f4b83608103d2fa000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002241b71bb00000000000000000000000000000000000000000000000000000000bb14516c00000000000000000000000000000000000000000000000000000000000000000000000000000000a6682e09318c47832d95f202b177edb397a8a34200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000235a7206d00000000000000000000000000000000000000000000000000000000c05b1ec30000000000000000000000000000000000000000000000000000000000000000000000000000000007b24e3192b05fe37842f5c71aeea7d726a3cad5000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004961113df0000000000000000000000000000000000000000000000000000000010d94006000000000000000000000000000000000000000000000000000000008fe2b41400000000000000000000000000000000000000000000000000000000020ce3a600000000000000000000000000000000000000000000000000000000000000000000000000000000ca79e8eeae776affc65f539d6cda998a76b250fe0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000039912dde8000000000000000000000000000000000000000000000000000000005a601668000000000000000000000000000000000000000000000000000000008a4f4f9200000000000000000000000000000000000000000000000000000000000000000000000000000000af60235bc891aa08776e59eb6c123fd21a38e75000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000513abaf0700000000000000000000000000000000000000000000000000000000ece1373200000000000000000000000000000000000000000000000000000000ed903f7a00000000000000000000000000000000000000000000000000000000010d573000000000000000000000000000000000000000000000000000000000767a7b0500000000000000000000000000000000000000000000000000000000000000000000000000000000868f7da9164a29801fa58ca0bb6b9c90f497b6ad000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002ea40e51a00000000000000000000000000000000000000000000000000000000461aebf400000000000000000000000000000000000000000000000000000000000000000000000000000000fc11f4ebe9f7c7399464c82825a0b8678fdc4cff00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000aeee8b7ff0000000000000000000000000000000000000000000000000000000072e1132700000000000000000000000000000000000000000000000000000000f4f015700000000000000000000000000000000000000000000000000000000046a384be00000000000000000000000000000000000000000000000000000000e949756100000000000000000000000000000000000000000000000000000000504006ca00000000000000000000000000000000000000000000000000000000c4c1662b00000000000000000000000000000000000000000000000000000000bddffdc4000000000000000000000000000000000000000000000000000000000634612f000000000000000000000000000000000000000000000000000000003b9293000000000000000000000000000000000000000000000000000000000000000000000000000000000028e2ce61ec8ded7f7bc9cba02a33573f7dd9f5f5000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b5300000000000000000000000000000000000000000000000000000000000000000000000000000000c3cb507553f192879c74879102fbb80286bcf12f0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000032239f5560000000000000000000000000000000000000000000000000000000046efd16c0000000000000000000000000000000000000000000000000000000078b248e4000000000000000000000000000000000000000000000000000000000000000000000000000000004cde0f1ba09de4b9fc6850412528d0756516d87a000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004a7baf6fc000000000000000000000000000000000000000000000000000000006f70d212000000000000000000000000000000000000000000000000000000000967aa82000000000000000000000000000000000000000000000000000000000f48a482000000000000000000000000000000000000000000000000000000000000000000000000000000002f7c91d53d4ff3ae6a2a2092776095dbc14bc6df00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000146e04a2f00000000000000000000000000000000000000000000000000000000000000000000000000000000fc7c599947dca76440dd3729a1292190c645eb9200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000371d78fbc00000000000000000000000000000000000000000000000000000000f63761240000000000000000000000000000000000000000000000000000000033c72dfe000000000000000000000000000000000000000000000000000000000000000000000000000000005b5481ad34b79d8e920b5f0f83d718ed225a7102000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000001262201b6000000000000000000000000000000000000000000000000000000000000000000000000000000002966b694d1642392cd759b8d8d316b55eae7aa690000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xa8615f71b8dc8b88fd926aaf7d23e6d3cf8e7dd2d59ef579ab8ab46d14ca38b0", + "args": [ + [ + [ + "0x0000000000000000000000000000000000000000", + 2, + ["0xce6e9f9f", "0x02bc2cdb", "0x0448a5c4"] + ], + [ + "0x03655Add6798b6a8B9b2756E59486Cea85e8ba24", + 1, + [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + ], + [ + "0x31D88294E48f70233bE242A524B0bebb0d155BC4", + 1, + [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + ], + [ + "0x3F4e01c435433CfF56Cc7e6A054Fe210EFd06645", + 1, + ["0xc76d202d", "0x839bb9a6", "0x8e756bb3"] + ], + [ + "0x85FD223609f69b8aB88383F8c9FA6a37d38582CC", + 1, + [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + ], + [ + "0x1Ac15086EFeFb7aa04A6a39f3F4b83608103D2fA", + 1, + ["0x241b71bb", "0xbb14516c"] + ], + [ + "0xa6682e09318c47832D95f202b177Edb397a8a342", + 1, + ["0x35a7206d", "0xc05b1ec3"] + ], + [ + "0x07B24e3192B05FE37842F5C71aEEa7d726a3caD5", + 1, + [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + ], + [ + "0xcA79e8EEAe776AFfC65f539d6cdA998a76b250FE", + 1, + ["0x9912dde8", "0x5a601668", "0x8a4f4f92"] + ], + [ + "0xAf60235Bc891Aa08776E59Eb6c123fd21A38E750", + 1, + [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + ], + [ + "0x868f7DA9164a29801Fa58CA0BB6b9C90f497B6ad", + 0, + ["0xea40e51a", "0x461aebf4"] + ], + [ + "0xFC11f4ebe9f7c7399464c82825A0B8678fdc4cff", + 1, + [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + ], + [ + "0x28E2Ce61Ec8dEd7f7bC9CBa02a33573f7dd9f5F5", + 1, + [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + ], + [ + "0xc3cB507553f192879c74879102fBB80286bcf12F", + 1, + ["0x2239f556", "0x46efd16c", "0x78b248e4"] + ], + [ + "0x4cDe0F1bA09DE4B9fC6850412528D0756516D87A", + 1, + [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + ], + [ + "0x2f7C91D53d4Ff3ae6a2a2092776095DBc14bc6dF", + 1, + ["0x46e04a2f"] + ], + [ + "0xFc7c599947DCa76440DD3729a1292190C645Eb92", + 1, + ["0x71d78fbc", "0xf6376124", "0x33c72dfe"] + ], + [ + "0x5B5481Ad34b79D8e920B5F0f83d718ED225A7102", + 1, + ["0x262201b6"] + ], + [ + "0x2966b694D1642392CD759B8d8D316B55eaE7aA69", + 1, + ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"] + ] + ], + "0x0000000000000000000000000000000000000000", + "0x" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 25347890, + "cumulativeGasUsed": "1557011", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + ["0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", ["0x1f931c1c"]], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x03655Add6798b6a8B9b2756E59486Cea85e8ba24", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0x31D88294E48f70233bE242A524B0bebb0d155BC4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3F4e01c435433CfF56Cc7e6A054Fe210EFd06645", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x85FD223609f69b8aB88383F8c9FA6a37d38582CC", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x1Ac15086EFeFb7aa04A6a39f3F4b83608103D2fA", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xa6682e09318c47832D95f202b177Edb397a8a342", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x07B24e3192B05FE37842F5C71aEEa7d726a3caD5", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xcA79e8EEAe776AFfC65f539d6cdA998a76b250FE", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0xAf60235Bc891Aa08776E59Eb6c123fd21A38E750", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x868f7DA9164a29801Fa58CA0BB6b9C90f497B6ad", + "functionSelectors": ["0xea40e51a", "0x461aebf4"] + }, + { + "facetAddress": "0xFC11f4ebe9f7c7399464c82825A0B8678fdc4cff", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0x28E2Ce61Ec8dEd7f7bC9CBa02a33573f7dd9f5F5", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0xc3cB507553f192879c74879102fBB80286bcf12F", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x4cDe0F1bA09DE4B9fC6850412528D0756516D87A", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x2f7C91D53d4Ff3ae6a2a2092776095DBc14bc6dF", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xFc7c599947DCa76440DD3729a1292190C645Eb92", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x5B5481Ad34b79D8e920B5F0f83d718ED225A7102", + "functionSelectors": ["0x262201b6"] + }, + { + "facetAddress": "0x2966b694D1642392CD759B8d8D316B55eaE7aA69", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ] + } + ], + "diamondCut": [ + { + "facetAddress": "0x0000000000000000000000000000000000000000", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 2 + }, + { + "facetAddress": "0x03655Add6798b6a8B9b2756E59486Cea85e8ba24", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 1 + }, + { + "facetAddress": "0x31D88294E48f70233bE242A524B0bebb0d155BC4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 1 + }, + { + "facetAddress": "0x3F4e01c435433CfF56Cc7e6A054Fe210EFd06645", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 1 + }, + { + "facetAddress": "0x85FD223609f69b8aB88383F8c9FA6a37d38582CC", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 1 + }, + { + "facetAddress": "0x1Ac15086EFeFb7aa04A6a39f3F4b83608103D2fA", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 1 + }, + { + "facetAddress": "0xa6682e09318c47832D95f202b177Edb397a8a342", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 1 + }, + { + "facetAddress": "0x07B24e3192B05FE37842F5C71aEEa7d726a3caD5", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 1 + }, + { + "facetAddress": "0xcA79e8EEAe776AFfC65f539d6cdA998a76b250FE", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 1 + }, + { + "facetAddress": "0xAf60235Bc891Aa08776E59Eb6c123fd21A38E750", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 1 + }, + { + "facetAddress": "0x868f7DA9164a29801Fa58CA0BB6b9C90f497B6ad", + "functionSelectors": ["0xea40e51a", "0x461aebf4"], + "action": 0 + }, + { + "facetAddress": "0xFC11f4ebe9f7c7399464c82825A0B8678fdc4cff", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 1 + }, + { + "facetAddress": "0x28E2Ce61Ec8dEd7f7bC9CBa02a33573f7dd9f5F5", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 1 + }, + { + "facetAddress": "0xc3cB507553f192879c74879102fBB80286bcf12F", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 1 + }, + { + "facetAddress": "0x4cDe0F1bA09DE4B9fC6850412528D0756516D87A", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 1 + }, + { + "facetAddress": "0x2f7C91D53d4Ff3ae6a2a2092776095DBc14bc6dF", + "functionSelectors": ["0x46e04a2f"], + "action": 1 + }, + { + "facetAddress": "0xFc7c599947DCa76440DD3729a1292190C645Eb92", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 1 + }, + { + "facetAddress": "0x5B5481Ad34b79D8e920B5F0f83d718ED225A7102", + "functionSelectors": ["0x262201b6"], + "action": 1 + }, + { + "facetAddress": "0x2966b694D1642392CD759B8d8D316B55eaE7aA69", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ], + "action": 1 + } + ], + "history": [ + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "5530229", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000020000020000008000000840000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000008000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000420000000000000000000000000000000000000000000000000000000000000008000", + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "args": ["0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0"], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "blockNumber": 25103807, + "cumulativeGasUsed": "5530229", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "0x60806040523661000b57005b600080357fffffffff000000000000000000000000000000000000000000000000000000001681527fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c6020819052604090912054819073ffffffffffffffffffffffffffffffffffffffff16806100b7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906115f3565b60405180910390fd5b3660008037600080366000845af43d6000803e8080156100d6573d6000f35b3d6000fd5b60005b83518110156102325760008482815181106100f557fe5b60200260200101516020015190506000600281111561011057fe5b81600281111561011c57fe5b141561015f5761015a85838151811061013157fe5b60200260200101516000015186848151811061014957fe5b602002602001015160400151610326565b610229565b600181600281111561016d57fe5b14156101ab5761015a85838151811061018257fe5b60200260200101516000015186848151811061019a57fe5b60200260200101516040015161065e565b60028160028111156101b957fe5b14156101f75761015a8583815181106101ce57fe5b6020026020010151600001518684815181106101e657fe5b6020026020010151604001516109ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611539565b506001016100de565b507f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb67383838360405161026693929190611282565b60405180910390a16102788282610acb565b505050565b6000610287610302565b60048101805473ffffffffffffffffffffffffffffffffffffffff8581167fffffffffffffffffffffffff000000000000000000000000000000000000000083168117909355604051939450169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c90565b6000815111610361576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b600061036b610302565b905073ffffffffffffffffffffffffffffffffffffffff83166103ba576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166104ab5761040d8460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106104c557fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff168015610554576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906116e2565b5073ffffffffffffffffffffffffffffffffffffffff86166000818152600186810160209081526040808420805480850182559085528285206008820401805463ffffffff60079093166004026101000a928302191660e089901c929092029190911790557fffffffff00000000000000000000000000000000000000000000000000000000909516835287905292902080547fffffffffffffffffffffffff0000000000000000000000000000000000000000169091177fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff86160217905591820191016104ae565b5050505050565b6000815111610699576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006106a3610302565b905073ffffffffffffffffffffffffffffffffffffffff83166106f2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166107e3576107458460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106107fd57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff908116908716811415610892576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061173f565b61089c8183610cbc565b507fffffffff00000000000000000000000000000000000000000000000000000000811660008181526020868152604080832080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8a160217815573ffffffffffffffffffffffffffffffffffffffff8b168085526001808b018552928520805480850182559086528486206008820401805463ffffffff60079093166004026101000a928302191660e09990991c91909102979097179096559390925286905281547fffffffffffffffffffffffff000000000000000000000000000000000000000016909217905591820191016107e6565b60008151116109e6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006109f0610302565b905073ffffffffffffffffffffffffffffffffffffffff831615610a40576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061179c565b60005b8251811015610ac5576000838281518110610a5a57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529185905260409091205490915073ffffffffffffffffffffffffffffffffffffffff16610abb8183610cbc565b5050600101610a43565b50505050565b73ffffffffffffffffffffffffffffffffffffffff8216610b2457805115610b1f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906113c5565b610c7d565b6000815111610b5f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611628565b73ffffffffffffffffffffffffffffffffffffffff82163014610b9e57610b9e8260405180606001604052806028815260200161182660289139610c81565b6000808373ffffffffffffffffffffffffffffffffffffffff1683604051610bc69190611266565b600060405180830381855af49150503d8060008114610c01576040519150601f19603f3d011682016040523d82523d6000602084013e610c06565b606091505b509150915081610ac557805115610c4b57806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611422565b5050565b813b8181610ac5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6000610cc6610302565b905073ffffffffffffffffffffffffffffffffffffffff8316610d15576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906114dc565b73ffffffffffffffffffffffffffffffffffffffff8316301415610d65576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611685565b7fffffffff0000000000000000000000000000000000000000000000000000000082166000908152602082815260408083205473ffffffffffffffffffffffffffffffffffffffff8716845260018501909252909120547401000000000000000000000000000000000000000090910461ffff16907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01808214610f375773ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260408120805483908110610e3657fe5b6000918252602080832060088304015473ffffffffffffffffffffffffffffffffffffffff8a168452600188019091526040909220805460079092166004026101000a90920460e01b925082919085908110610e8e57fe5b600091825260208083206008830401805463ffffffff60079094166004026101000a938402191660e09590951c929092029390931790557fffffffff000000000000000000000000000000000000000000000000000000009290921682528490526040902080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8516021790555b73ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260409020805480610f6757fe5b6000828152602080822060087fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90940193840401805463ffffffff600460078716026101000a0219169055919092557fffffffff00000000000000000000000000000000000000000000000000000000861682528490526040902080547fffffffffffffffffffff000000000000000000000000000000000000000000001690558061065757600283015473ffffffffffffffffffffffffffffffffffffffff861660009081526001858101602052604090912001547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9091019061ffff1680821461114357600085600201838154811061107e57fe5b60009182526020909120015460028701805473ffffffffffffffffffffffffffffffffffffffff90921692508291849081106110b657fe5b600091825260208083209190910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff9485161790559290911681526001878101909252604090200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff83161790555b8460020180548061115057fe5b6000828152602080822083017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90810180547fffffffffffffffffffffffff000000000000000000000000000000000000000016905590920190925573ffffffffffffffffffffffffffffffffffffffff89168252600187810190915260409091200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000016905550505050505050565b73ffffffffffffffffffffffffffffffffffffffff169052565b600081518084526112348160208601602086016117f9565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b600082516112788184602087016117f9565b9190910192915050565b606080825284518282018190526000919060809081850190602080820287018401818b01875b8481101561137c577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff808a8403018652815188840173ffffffffffffffffffffffffffffffffffffffff8251168552858201516003811061130457fe5b858701526040918201519185018a9052815190819052908501908a90898601905b808310156113675783517fffffffff00000000000000000000000000000000000000000000000000000000168252928701926001929092019190870190611325565b509786019794505050908301906001016112a8565b505061138a8289018b611202565b878103604089015261139c818a61121c565b9b9a5050505050505050505050565b6000602082526113be602083018461121c565b9392505050565b6020808252603c908201527f4c69624469616d6f6e644375743a205f696e697420697320616464726573732860408201527f3029206275745f63616c6c64617461206973206e6f7420656d70747900000000606082015260800190565b60208082526026908201527f4c69624469616d6f6e644375743a205f696e69742066756e6374696f6e20726560408201527f7665727465640000000000000000000000000000000000000000000000000000606082015260800190565b6020808252602b908201527f4c69624469616d6f6e644375743a204e6f2073656c6563746f727320696e206660408201527f6163657420746f20637574000000000000000000000000000000000000000000606082015260800190565b60208082526037908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f76652066756e6360408201527f74696f6e207468617420646f65736e2774206578697374000000000000000000606082015260800190565b60208082526027908201527f4c69624469616d6f6e644375743a20496e636f7272656374204661636574437560408201527f74416374696f6e00000000000000000000000000000000000000000000000000606082015260800190565b6020808252602c908201527f4c69624469616d6f6e644375743a204164642066616365742063616e2774206260408201527f6520616464726573732830290000000000000000000000000000000000000000606082015260800190565b6020808252818101527f4469616d6f6e643a2046756e6374696f6e20646f6573206e6f74206578697374604082015260600190565b6020808252603d908201527f4c69624469616d6f6e644375743a205f63616c6c6461746120697320656d707460408201527f7920627574205f696e6974206973206e6f742061646472657373283029000000606082015260800190565b6020808252602e908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f766520696d6d7560408201527f7461626c652066756e6374696f6e000000000000000000000000000000000000606082015260800190565b60208082526035908201527f4c69624469616d6f6e644375743a2043616e2774206164642066756e6374696f60408201527f6e207468617420616c7265616479206578697374730000000000000000000000606082015260800190565b60208082526038908201527f4c69624469616d6f6e644375743a2043616e2774207265706c6163652066756e60408201527f6374696f6e20776974682073616d652066756e6374696f6e0000000000000000606082015260800190565b60208082526036908201527f4c69624469616d6f6e644375743a2052656d6f7665206661636574206164647260408201527f657373206d757374206265206164647265737328302900000000000000000000606082015260800190565b60005b838110156118145781810151838201526020016117fc565b83811115610ac5575050600091015256fe4c69624469616d6f6e644375743a205f696e6974206164647265737320686173206e6f20636f64654c69624469616d6f6e644375743a204e657720666163657420686173206e6f20636f6465a264697066735822122054a3c3a118803545231f43700030cb5e290869be0182196a4a05e7d4a1b71d7e64736f6c63430007060033", + "facets": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0x61460874a7196d6a22d1ee4922473664b3e95270" + }, + { + "sym": "ADAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "PCDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "YDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "WETH", + "addr": "0xd0a1e359811322d97991e03f863a0c30c2cf029c" + }, + { + "sym": "DAI", + "addr": "0x4f96fe3b7a6cf9725f59d353f723c1bdb64ca6aa" + }, + { + "sym": "USDC", + "addr": "0xb7a4f3e9097c08da09517b5ab877f7a917224ede" + }, + { + "sym": "LINK", + "addr": "0xa36085F69e2889c224210F603D836748e7dC0088" + } + ], + "cTokens": [ + "0xf0d0eb522cfa50b716b3b1604c4f0fa6f04376ad", + "0x4a92e71227d294f041bd82dd8f78591b75140d63", + "0x41b5844f4680a8c38fbb695b7f9cfd1f64474a72" + ], + "tellerNFT": "0x7360904A663B9Cb66baB538F406C04D8da86229d", + "loansEscrowBeacon": "0xAb59409415e28deEb6255ba64527E3271D057FED", + "collateralEscrowBeacon": "0x7cCb2ddB4f7a239CA9edF765edC0bb4e7e04Ef5F", + "tTokenBeacon": "0x18D45BC9319937d2099Dc8e0D0EdCEEe033fCf25", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "receipt": { + "to": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "204539", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000000000000000000000000040000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb", + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25104070, + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000617bf3ec25f4b04ca986ae559ed37be7f68cccad0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25104070, + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000617bf3ec25f4b04ca986ae559ed37be7f68cccad0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb", + "args": [ + [ + [ + "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + 0, + ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"] + ] + ], + "0x0000000000000000000000000000000000000000", + "0x" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 25104070, + "cumulativeGasUsed": "204539", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "0x60806040523661000b57005b600080357fffffffff000000000000000000000000000000000000000000000000000000001681527fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c6020819052604090912054819073ffffffffffffffffffffffffffffffffffffffff16806100b7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906115f3565b60405180910390fd5b3660008037600080366000845af43d6000803e8080156100d6573d6000f35b3d6000fd5b60005b83518110156102325760008482815181106100f557fe5b60200260200101516020015190506000600281111561011057fe5b81600281111561011c57fe5b141561015f5761015a85838151811061013157fe5b60200260200101516000015186848151811061014957fe5b602002602001015160400151610326565b610229565b600181600281111561016d57fe5b14156101ab5761015a85838151811061018257fe5b60200260200101516000015186848151811061019a57fe5b60200260200101516040015161065e565b60028160028111156101b957fe5b14156101f75761015a8583815181106101ce57fe5b6020026020010151600001518684815181106101e657fe5b6020026020010151604001516109ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611539565b506001016100de565b507f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb67383838360405161026693929190611282565b60405180910390a16102788282610acb565b505050565b6000610287610302565b60048101805473ffffffffffffffffffffffffffffffffffffffff8581167fffffffffffffffffffffffff000000000000000000000000000000000000000083168117909355604051939450169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c90565b6000815111610361576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b600061036b610302565b905073ffffffffffffffffffffffffffffffffffffffff83166103ba576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166104ab5761040d8460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106104c557fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff168015610554576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906116e2565b5073ffffffffffffffffffffffffffffffffffffffff86166000818152600186810160209081526040808420805480850182559085528285206008820401805463ffffffff60079093166004026101000a928302191660e089901c929092029190911790557fffffffff00000000000000000000000000000000000000000000000000000000909516835287905292902080547fffffffffffffffffffffffff0000000000000000000000000000000000000000169091177fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff86160217905591820191016104ae565b5050505050565b6000815111610699576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006106a3610302565b905073ffffffffffffffffffffffffffffffffffffffff83166106f2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166107e3576107458460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106107fd57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff908116908716811415610892576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061173f565b61089c8183610cbc565b507fffffffff00000000000000000000000000000000000000000000000000000000811660008181526020868152604080832080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8a160217815573ffffffffffffffffffffffffffffffffffffffff8b168085526001808b018552928520805480850182559086528486206008820401805463ffffffff60079093166004026101000a928302191660e09990991c91909102979097179096559390925286905281547fffffffffffffffffffffffff000000000000000000000000000000000000000016909217905591820191016107e6565b60008151116109e6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006109f0610302565b905073ffffffffffffffffffffffffffffffffffffffff831615610a40576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061179c565b60005b8251811015610ac5576000838281518110610a5a57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529185905260409091205490915073ffffffffffffffffffffffffffffffffffffffff16610abb8183610cbc565b5050600101610a43565b50505050565b73ffffffffffffffffffffffffffffffffffffffff8216610b2457805115610b1f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906113c5565b610c7d565b6000815111610b5f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611628565b73ffffffffffffffffffffffffffffffffffffffff82163014610b9e57610b9e8260405180606001604052806028815260200161182660289139610c81565b6000808373ffffffffffffffffffffffffffffffffffffffff1683604051610bc69190611266565b600060405180830381855af49150503d8060008114610c01576040519150601f19603f3d011682016040523d82523d6000602084013e610c06565b606091505b509150915081610ac557805115610c4b57806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611422565b5050565b813b8181610ac5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6000610cc6610302565b905073ffffffffffffffffffffffffffffffffffffffff8316610d15576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906114dc565b73ffffffffffffffffffffffffffffffffffffffff8316301415610d65576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611685565b7fffffffff0000000000000000000000000000000000000000000000000000000082166000908152602082815260408083205473ffffffffffffffffffffffffffffffffffffffff8716845260018501909252909120547401000000000000000000000000000000000000000090910461ffff16907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01808214610f375773ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260408120805483908110610e3657fe5b6000918252602080832060088304015473ffffffffffffffffffffffffffffffffffffffff8a168452600188019091526040909220805460079092166004026101000a90920460e01b925082919085908110610e8e57fe5b600091825260208083206008830401805463ffffffff60079094166004026101000a938402191660e09590951c929092029390931790557fffffffff000000000000000000000000000000000000000000000000000000009290921682528490526040902080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8516021790555b73ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260409020805480610f6757fe5b6000828152602080822060087fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90940193840401805463ffffffff600460078716026101000a0219169055919092557fffffffff00000000000000000000000000000000000000000000000000000000861682528490526040902080547fffffffffffffffffffff000000000000000000000000000000000000000000001690558061065757600283015473ffffffffffffffffffffffffffffffffffffffff861660009081526001858101602052604090912001547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9091019061ffff1680821461114357600085600201838154811061107e57fe5b60009182526020909120015460028701805473ffffffffffffffffffffffffffffffffffffffff90921692508291849081106110b657fe5b600091825260208083209190910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff9485161790559290911681526001878101909252604090200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff83161790555b8460020180548061115057fe5b6000828152602080822083017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90810180547fffffffffffffffffffffffff000000000000000000000000000000000000000016905590920190925573ffffffffffffffffffffffffffffffffffffffff89168252600187810190915260409091200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000016905550505050505050565b73ffffffffffffffffffffffffffffffffffffffff169052565b600081518084526112348160208601602086016117f9565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b600082516112788184602087016117f9565b9190910192915050565b606080825284518282018190526000919060809081850190602080820287018401818b01875b8481101561137c577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff808a8403018652815188840173ffffffffffffffffffffffffffffffffffffffff8251168552858201516003811061130457fe5b858701526040918201519185018a9052815190819052908501908a90898601905b808310156113675783517fffffffff00000000000000000000000000000000000000000000000000000000168252928701926001929092019190870190611325565b509786019794505050908301906001016112a8565b505061138a8289018b611202565b878103604089015261139c818a61121c565b9b9a5050505050505050505050565b6000602082526113be602083018461121c565b9392505050565b6020808252603c908201527f4c69624469616d6f6e644375743a205f696e697420697320616464726573732860408201527f3029206275745f63616c6c64617461206973206e6f7420656d70747900000000606082015260800190565b60208082526026908201527f4c69624469616d6f6e644375743a205f696e69742066756e6374696f6e20726560408201527f7665727465640000000000000000000000000000000000000000000000000000606082015260800190565b6020808252602b908201527f4c69624469616d6f6e644375743a204e6f2073656c6563746f727320696e206660408201527f6163657420746f20637574000000000000000000000000000000000000000000606082015260800190565b60208082526037908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f76652066756e6360408201527f74696f6e207468617420646f65736e2774206578697374000000000000000000606082015260800190565b60208082526027908201527f4c69624469616d6f6e644375743a20496e636f7272656374204661636574437560408201527f74416374696f6e00000000000000000000000000000000000000000000000000606082015260800190565b6020808252602c908201527f4c69624469616d6f6e644375743a204164642066616365742063616e2774206260408201527f6520616464726573732830290000000000000000000000000000000000000000606082015260800190565b6020808252818101527f4469616d6f6e643a2046756e6374696f6e20646f6573206e6f74206578697374604082015260600190565b6020808252603d908201527f4c69624469616d6f6e644375743a205f63616c6c6461746120697320656d707460408201527f7920627574205f696e6974206973206e6f742061646472657373283029000000606082015260800190565b6020808252602e908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f766520696d6d7560408201527f7461626c652066756e6374696f6e000000000000000000000000000000000000606082015260800190565b60208082526035908201527f4c69624469616d6f6e644375743a2043616e2774206164642066756e6374696f60408201527f6e207468617420616c7265616479206578697374730000000000000000000000606082015260800190565b60208082526038908201527f4c69624469616d6f6e644375743a2043616e2774207265706c6163652066756e60408201527f6374696f6e20776974682073616d652066756e6374696f6e0000000000000000606082015260800190565b60208082526036908201527f4c69624469616d6f6e644375743a2052656d6f7665206661636574206164647260408201527f657373206d757374206265206164647265737328302900000000000000000000606082015260800190565b60005b838110156118145781810151838201526020016117fc565b83811115610ac5575050600091015256fe4c69624469616d6f6e644375743a205f696e6974206164647265737320686173206e6f20636f64654c69624469616d6f6e644375743a204e657720666163657420686173206e6f20636f6465a264697066735822122054a3c3a118803545231f43700030cb5e290869be0182196a4a05e7d4a1b71d7e64736f6c63430007060033", + "facets": [ + [ + "0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", + ["0x1f931c1c"] + ], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ], + "action": 0 + } + ], + "history": [ + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "5530229", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000020000020000008000000840000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000008000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000420000000000000000000000000000000000000000000000000000000000000008000", + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "args": [ + "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0" + ], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "blockNumber": 25103807, + "cumulativeGasUsed": "5530229", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "0x60806040523661000b57005b600080357fffffffff000000000000000000000000000000000000000000000000000000001681527fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c6020819052604090912054819073ffffffffffffffffffffffffffffffffffffffff16806100b7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906115f3565b60405180910390fd5b3660008037600080366000845af43d6000803e8080156100d6573d6000f35b3d6000fd5b60005b83518110156102325760008482815181106100f557fe5b60200260200101516020015190506000600281111561011057fe5b81600281111561011c57fe5b141561015f5761015a85838151811061013157fe5b60200260200101516000015186848151811061014957fe5b602002602001015160400151610326565b610229565b600181600281111561016d57fe5b14156101ab5761015a85838151811061018257fe5b60200260200101516000015186848151811061019a57fe5b60200260200101516040015161065e565b60028160028111156101b957fe5b14156101f75761015a8583815181106101ce57fe5b6020026020010151600001518684815181106101e657fe5b6020026020010151604001516109ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611539565b506001016100de565b507f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb67383838360405161026693929190611282565b60405180910390a16102788282610acb565b505050565b6000610287610302565b60048101805473ffffffffffffffffffffffffffffffffffffffff8581167fffffffffffffffffffffffff000000000000000000000000000000000000000083168117909355604051939450169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c90565b6000815111610361576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b600061036b610302565b905073ffffffffffffffffffffffffffffffffffffffff83166103ba576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166104ab5761040d8460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106104c557fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff168015610554576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906116e2565b5073ffffffffffffffffffffffffffffffffffffffff86166000818152600186810160209081526040808420805480850182559085528285206008820401805463ffffffff60079093166004026101000a928302191660e089901c929092029190911790557fffffffff00000000000000000000000000000000000000000000000000000000909516835287905292902080547fffffffffffffffffffffffff0000000000000000000000000000000000000000169091177fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff86160217905591820191016104ae565b5050505050565b6000815111610699576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006106a3610302565b905073ffffffffffffffffffffffffffffffffffffffff83166106f2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166107e3576107458460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106107fd57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff908116908716811415610892576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061173f565b61089c8183610cbc565b507fffffffff00000000000000000000000000000000000000000000000000000000811660008181526020868152604080832080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8a160217815573ffffffffffffffffffffffffffffffffffffffff8b168085526001808b018552928520805480850182559086528486206008820401805463ffffffff60079093166004026101000a928302191660e09990991c91909102979097179096559390925286905281547fffffffffffffffffffffffff000000000000000000000000000000000000000016909217905591820191016107e6565b60008151116109e6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006109f0610302565b905073ffffffffffffffffffffffffffffffffffffffff831615610a40576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061179c565b60005b8251811015610ac5576000838281518110610a5a57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529185905260409091205490915073ffffffffffffffffffffffffffffffffffffffff16610abb8183610cbc565b5050600101610a43565b50505050565b73ffffffffffffffffffffffffffffffffffffffff8216610b2457805115610b1f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906113c5565b610c7d565b6000815111610b5f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611628565b73ffffffffffffffffffffffffffffffffffffffff82163014610b9e57610b9e8260405180606001604052806028815260200161182660289139610c81565b6000808373ffffffffffffffffffffffffffffffffffffffff1683604051610bc69190611266565b600060405180830381855af49150503d8060008114610c01576040519150601f19603f3d011682016040523d82523d6000602084013e610c06565b606091505b509150915081610ac557805115610c4b57806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611422565b5050565b813b8181610ac5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6000610cc6610302565b905073ffffffffffffffffffffffffffffffffffffffff8316610d15576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906114dc565b73ffffffffffffffffffffffffffffffffffffffff8316301415610d65576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611685565b7fffffffff0000000000000000000000000000000000000000000000000000000082166000908152602082815260408083205473ffffffffffffffffffffffffffffffffffffffff8716845260018501909252909120547401000000000000000000000000000000000000000090910461ffff16907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01808214610f375773ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260408120805483908110610e3657fe5b6000918252602080832060088304015473ffffffffffffffffffffffffffffffffffffffff8a168452600188019091526040909220805460079092166004026101000a90920460e01b925082919085908110610e8e57fe5b600091825260208083206008830401805463ffffffff60079094166004026101000a938402191660e09590951c929092029390931790557fffffffff000000000000000000000000000000000000000000000000000000009290921682528490526040902080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8516021790555b73ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260409020805480610f6757fe5b6000828152602080822060087fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90940193840401805463ffffffff600460078716026101000a0219169055919092557fffffffff00000000000000000000000000000000000000000000000000000000861682528490526040902080547fffffffffffffffffffff000000000000000000000000000000000000000000001690558061065757600283015473ffffffffffffffffffffffffffffffffffffffff861660009081526001858101602052604090912001547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9091019061ffff1680821461114357600085600201838154811061107e57fe5b60009182526020909120015460028701805473ffffffffffffffffffffffffffffffffffffffff90921692508291849081106110b657fe5b600091825260208083209190910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff9485161790559290911681526001878101909252604090200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff83161790555b8460020180548061115057fe5b6000828152602080822083017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90810180547fffffffffffffffffffffffff000000000000000000000000000000000000000016905590920190925573ffffffffffffffffffffffffffffffffffffffff89168252600187810190915260409091200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000016905550505050505050565b73ffffffffffffffffffffffffffffffffffffffff169052565b600081518084526112348160208601602086016117f9565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b600082516112788184602087016117f9565b9190910192915050565b606080825284518282018190526000919060809081850190602080820287018401818b01875b8481101561137c577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff808a8403018652815188840173ffffffffffffffffffffffffffffffffffffffff8251168552858201516003811061130457fe5b858701526040918201519185018a9052815190819052908501908a90898601905b808310156113675783517fffffffff00000000000000000000000000000000000000000000000000000000168252928701926001929092019190870190611325565b509786019794505050908301906001016112a8565b505061138a8289018b611202565b878103604089015261139c818a61121c565b9b9a5050505050505050505050565b6000602082526113be602083018461121c565b9392505050565b6020808252603c908201527f4c69624469616d6f6e644375743a205f696e697420697320616464726573732860408201527f3029206275745f63616c6c64617461206973206e6f7420656d70747900000000606082015260800190565b60208082526026908201527f4c69624469616d6f6e644375743a205f696e69742066756e6374696f6e20726560408201527f7665727465640000000000000000000000000000000000000000000000000000606082015260800190565b6020808252602b908201527f4c69624469616d6f6e644375743a204e6f2073656c6563746f727320696e206660408201527f6163657420746f20637574000000000000000000000000000000000000000000606082015260800190565b60208082526037908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f76652066756e6360408201527f74696f6e207468617420646f65736e2774206578697374000000000000000000606082015260800190565b60208082526027908201527f4c69624469616d6f6e644375743a20496e636f7272656374204661636574437560408201527f74416374696f6e00000000000000000000000000000000000000000000000000606082015260800190565b6020808252602c908201527f4c69624469616d6f6e644375743a204164642066616365742063616e2774206260408201527f6520616464726573732830290000000000000000000000000000000000000000606082015260800190565b6020808252818101527f4469616d6f6e643a2046756e6374696f6e20646f6573206e6f74206578697374604082015260600190565b6020808252603d908201527f4c69624469616d6f6e644375743a205f63616c6c6461746120697320656d707460408201527f7920627574205f696e6974206973206e6f742061646472657373283029000000606082015260800190565b6020808252602e908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f766520696d6d7560408201527f7461626c652066756e6374696f6e000000000000000000000000000000000000606082015260800190565b60208082526035908201527f4c69624469616d6f6e644375743a2043616e2774206164642066756e6374696f60408201527f6e207468617420616c7265616479206578697374730000000000000000000000606082015260800190565b60208082526038908201527f4c69624469616d6f6e644375743a2043616e2774207265706c6163652066756e60408201527f6374696f6e20776974682073616d652066756e6374696f6e0000000000000000606082015260800190565b60208082526036908201527f4c69624469616d6f6e644375743a2052656d6f7665206661636574206164647260408201527f657373206d757374206265206164647265737328302900000000000000000000606082015260800190565b60005b838110156118145781810151838201526020016117fc565b83811115610ac5575050600091015256fe4c69624469616d6f6e644375743a205f696e6974206164647265737320686173206e6f20636f64654c69624469616d6f6e644375743a204e657720666163657420686173206e6f20636f6465a264697066735822122054a3c3a118803545231f43700030cb5e290869be0182196a4a05e7d4a1b71d7e64736f6c63430007060033", + "facets": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0x61460874a7196d6a22d1ee4922473664b3e95270" + }, + { + "sym": "ADAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "PCDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "YDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "WETH", + "addr": "0xd0a1e359811322d97991e03f863a0c30c2cf029c" + }, + { + "sym": "DAI", + "addr": "0x4f96fe3b7a6cf9725f59d353f723c1bdb64ca6aa" + }, + { + "sym": "USDC", + "addr": "0xb7a4f3e9097c08da09517b5ab877f7a917224ede" + }, + { + "sym": "LINK", + "addr": "0xa36085F69e2889c224210F603D836748e7dC0088" + } + ], + "cTokens": [ + "0xf0d0eb522cfa50b716b3b1604c4f0fa6f04376ad", + "0x4a92e71227d294f041bd82dd8f78591b75140d63", + "0x41b5844f4680a8c38fbb695b7f9cfd1f64474a72" + ], + "tellerNFT": "0x7360904A663B9Cb66baB538F406C04D8da86229d", + "loansEscrowBeacon": "0xAb59409415e28deEb6255ba64527E3271D057FED", + "collateralEscrowBeacon": "0x7cCb2ddB4f7a239CA9edF765edC0bb4e7e04Ef5F", + "tTokenBeacon": "0x18D45BC9319937d2099Dc8e0D0EdCEEe033fCf25", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanUserRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanConsensusResponse[]", + "name": "responses", + "type": "tuple[]" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanUserRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanConsensusResponse[]", + "name": "responses", + "type": "tuple[]" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "internalType": "uint16[]", + "name": "nftIDs", + "type": "uint16[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "dictAddress", + "type": "address" + } + ], + "name": "setNFTDictionary", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x19c1048e8501295e71eff1c25c0dc86bc87084fded1c72a2a970f931c854a6e9", + "receipt": { + "to": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "315319", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000000000000000000000000040000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0x862f78bbd59152a5cf0ea9ca525131cdac10f8970eaf62ac6ac0955df3968ede", + "transactionHash": "0x19c1048e8501295e71eff1c25c0dc86bc87084fded1c72a2a970f931c854a6e9", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25370077, + "transactionHash": "0x19c1048e8501295e71eff1c25c0dc86bc87084fded1c72a2a970f931c854a6e9", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea000000000000000000000000000000000000000000000000000000000000005c0000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000180000000000000000000000000000000000000000000000000000000000000022000000000000000000000000000000000000000000000000000000000000002c000000000000000000000000000000000000000000000000000000000000003c000000000000000000000000000000000000000000000000000000000000004a000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000020967aa8200000000000000000000000000000000000000000000000000000000461aebf400000000000000000000000000000000000000000000000000000000000000000000000000000000b939b2c7861d718bbe32103906a92cd626929134000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000001ea40e51a00000000000000000000000000000000000000000000000000000000000000000000000000000000b939b2c7861d718bbe32103906a92cd626929134000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000001fe5d095b00000000000000000000000000000000000000000000000000000000000000000000000000000000e1c9d9f11fc759b4c60e13b5d11502c0b27af2b7000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b5300000000000000000000000000000000000000000000000000000000000000000000000000000000975bda2061e3c7fc2435635794ee7971d5406c3d000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003a7baf6fc000000000000000000000000000000000000000000000000000000006f70d212000000000000000000000000000000000000000000000000000000000f48a48200000000000000000000000000000000000000000000000000000000000000000000000000000000975bda2061e3c7fc2435635794ee7971d5406c3d000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000001987df220000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024987df220000000000000000000000000f270070dc4aaf37823fa96c823e17cb291d8d57a00000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x862f78bbd59152a5cf0ea9ca525131cdac10f8970eaf62ac6ac0955df3968ede" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25370077, + "transactionHash": "0x19c1048e8501295e71eff1c25c0dc86bc87084fded1c72a2a970f931c854a6e9", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 0, + "blockHash": "0x862f78bbd59152a5cf0ea9ca525131cdac10f8970eaf62ac6ac0955df3968ede", + "args": [ + [ + [ + "0x0000000000000000000000000000000000000000", + 2, + ["0x0967aa82", "0x461aebf4"] + ], + [ + "0xb939B2c7861D718bbE32103906A92Cd626929134", + 1, + ["0xea40e51a"] + ], + [ + "0xb939B2c7861D718bbE32103906A92Cd626929134", + 0, + ["0xfe5d095b"] + ], + [ + "0xE1C9D9f11fc759b4c60e13b5D11502c0B27AF2b7", + 1, + [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + ], + [ + "0x975BdA2061e3C7FC2435635794Ee7971D5406C3D", + 1, + ["0xa7baf6fc", "0x6f70d212", "0x0f48a482"] + ], + [ + "0x975BdA2061e3C7FC2435635794Ee7971D5406C3D", + 0, + ["0x987df220"] + ] + ], + "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "0x987df220000000000000000000000000f270070dc4aaf37823fa96c823e17cb291d8d57a" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 25370077, + "cumulativeGasUsed": "315319", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + ["0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", ["0x1f931c1c"]], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x03655Add6798b6a8B9b2756E59486Cea85e8ba24", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0x31D88294E48f70233bE242A524B0bebb0d155BC4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3F4e01c435433CfF56Cc7e6A054Fe210EFd06645", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x85FD223609f69b8aB88383F8c9FA6a37d38582CC", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x1Ac15086EFeFb7aa04A6a39f3F4b83608103D2fA", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xa6682e09318c47832D95f202b177Edb397a8a342", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x07B24e3192B05FE37842F5C71aEEa7d726a3caD5", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xcA79e8EEAe776AFfC65f539d6cdA998a76b250FE", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0xAf60235Bc891Aa08776E59Eb6c123fd21A38E750", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0xb939B2c7861D718bbE32103906A92Cd626929134", + "functionSelectors": ["0xea40e51a", "0xfe5d095b"] + }, + { + "facetAddress": "0xFC11f4ebe9f7c7399464c82825A0B8678fdc4cff", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xE1C9D9f11fc759b4c60e13b5D11502c0B27AF2b7", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0xc3cB507553f192879c74879102fBB80286bcf12F", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x975BdA2061e3C7FC2435635794Ee7971D5406C3D", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x987df220", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x2f7C91D53d4Ff3ae6a2a2092776095DBc14bc6dF", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xFc7c599947DCa76440DD3729a1292190C645Eb92", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x5B5481Ad34b79D8e920B5F0f83d718ED225A7102", + "functionSelectors": ["0x262201b6"] + }, + { + "facetAddress": "0x2966b694D1642392CD759B8d8D316B55eaE7aA69", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ] + } + ], + "diamondCut": [ + { + "facetAddress": "0x0000000000000000000000000000000000000000", + "functionSelectors": ["0x0967aa82", "0x461aebf4"], + "action": 2 + }, + { + "facetAddress": "0xb939B2c7861D718bbE32103906A92Cd626929134", + "functionSelectors": ["0xea40e51a"], + "action": 1 + }, + { + "facetAddress": "0xb939B2c7861D718bbE32103906A92Cd626929134", + "functionSelectors": ["0xfe5d095b"], + "action": 0 + }, + { + "facetAddress": "0xE1C9D9f11fc759b4c60e13b5D11502c0B27AF2b7", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 1 + }, + { + "facetAddress": "0x975BdA2061e3C7FC2435635794Ee7971D5406C3D", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0f48a482" + ], + "action": 1 + }, + { + "facetAddress": "0x975BdA2061e3C7FC2435635794Ee7971D5406C3D", + "functionSelectors": ["0x987df220"], + "action": 0 + } + ], + "execute": { + "methodName": "setNFTDictionary", + "args": ["0xF270070Dc4AAF37823Fa96c823e17cb291d8D57A"] + }, + "history": [ + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "5530229", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000020000020000008000000840000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000008000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000420000000000000000000000000000000000000000000000000000000000000008000", + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "args": ["0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0"], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea00000000000000000000000000000000000000000000000000000000000001300000000000000000000000000000000000000000000000000000000000000001100000000000000000000000000000000000000000000000000000000000002200000000000000000000000000000000000000000000000000000000000000380000000000000000000000000000000000000000000000000000000000000048000000000000000000000000000000000000000000000000000000000000005600000000000000000000000000000000000000000000000000000000000000660000000000000000000000000000000000000000000000000000000000000072000000000000000000000000000000000000000000000000000000000000007e000000000000000000000000000000000000000000000000000000000000008e000000000000000000000000000000000000000000000000000000000000009c00000000000000000000000000000000000000000000000000000000000000ae00000000000000000000000000000000000000000000000000000000000000bc00000000000000000000000000000000000000000000000000000000000000d800000000000000000000000000000000000000000000000000000000000000e800000000000000000000000000000000000000000000000000000000000000f600000000000000000000000000000000000000000000000000000000000001060000000000000000000000000000000000000000000000000000000000000110000000000000000000000000000000000000000000000000000000000000011e0000000000000000000000000d326456fa02a0976a6304152248cdd576302471a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000742f1181e000000000000000000000000000000000000000000000000000000006eade577000000000000000000000000000000000000000000000000000000004dc2304d00000000000000000000000000000000000000000000000000000000ad21879e000000000000000000000000000000000000000000000000000000001cf14f330000000000000000000000000000000000000000000000000000000070712939000000000000000000000000000000000000000000000000000000006e4d22c200000000000000000000000000000000000000000000000000000000000000000000000000000000bb25ad0cb256f9cb457856b30c36756859a536570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000049dec88b900000000000000000000000000000000000000000000000000000000ce19912900000000000000000000000000000000000000000000000000000000d10a0aec0000000000000000000000000000000000000000000000000000000074b1d75d000000000000000000000000000000000000000000000000000000000000000000000000000000003b34fbafa24db8c5c6c88bb9996703a31bd0e97b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003c76d202d00000000000000000000000000000000000000000000000000000000839bb9a6000000000000000000000000000000000000000000000000000000008e756bb30000000000000000000000000000000000000000000000000000000000000000000000000000000042b98ea041d660ee5696ac64e0e684040f84bc5f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004fee2792b00000000000000000000000000000000000000000000000000000000bf6d79ab00000000000000000000000000000000000000000000000000000000c1c52f8800000000000000000000000000000000000000000000000000000000ec1c2bb5000000000000000000000000000000000000000000000000000000000000000000000000000000006de843c33e610cc76ab7d53675a19275b75d5442000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002241b71bb00000000000000000000000000000000000000000000000000000000bb14516c00000000000000000000000000000000000000000000000000000000000000000000000000000000e387aac3e2c1f690a21dc6dceb0ee8d903f068de00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000235a7206d00000000000000000000000000000000000000000000000000000000c05b1ec3000000000000000000000000000000000000000000000000000000000000000000000000000000007f05e46146f9d3cf2086633e43c1302116f7190d000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004961113df0000000000000000000000000000000000000000000000000000000010d94006000000000000000000000000000000000000000000000000000000008fe2b41400000000000000000000000000000000000000000000000000000000020ce3a6000000000000000000000000000000000000000000000000000000000000000000000000000000002ca57d87f6be51515ace674f8d520fa3abe8f5bb0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000039912dde8000000000000000000000000000000000000000000000000000000005a601668000000000000000000000000000000000000000000000000000000008a4f4f9200000000000000000000000000000000000000000000000000000000000000000000000000000000172caf420c79ee756020792d99c77db2c77db8e800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000513abaf0700000000000000000000000000000000000000000000000000000000ece1373200000000000000000000000000000000000000000000000000000000ed903f7a00000000000000000000000000000000000000000000000000000000010d573000000000000000000000000000000000000000000000000000000000767a7b0500000000000000000000000000000000000000000000000000000000000000000000000000000000355161f7da9da53ca4ab44fcd0372ce3b22fef29000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003ce6e9f9f0000000000000000000000000000000000000000000000000000000002bc2cdb000000000000000000000000000000000000000000000000000000000448a5c400000000000000000000000000000000000000000000000000000000000000000000000000000000be09acf7a2257aa063697d31f3b3e55bd524252e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000aeee8b7ff0000000000000000000000000000000000000000000000000000000072e1132700000000000000000000000000000000000000000000000000000000f4f015700000000000000000000000000000000000000000000000000000000046a384be00000000000000000000000000000000000000000000000000000000e949756100000000000000000000000000000000000000000000000000000000504006ca00000000000000000000000000000000000000000000000000000000c4c1662b00000000000000000000000000000000000000000000000000000000bddffdc4000000000000000000000000000000000000000000000000000000000634612f000000000000000000000000000000000000000000000000000000003b92930000000000000000000000000000000000000000000000000000000000000000000000000000000000d99dfbd7ee2cc714debff8390c33f0dbb1502ed2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b53000000000000000000000000000000000000000000000000000000000000000000000000000000005503066a836df524f8871cbb84c4290f7d65bb600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000032239f5560000000000000000000000000000000000000000000000000000000046efd16c0000000000000000000000000000000000000000000000000000000078b248e40000000000000000000000000000000000000000000000000000000000000000000000000000000028a91ecd8c1637bb102bca987084aec35b7f5853000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004a7baf6fc000000000000000000000000000000000000000000000000000000006f70d212000000000000000000000000000000000000000000000000000000000967aa82000000000000000000000000000000000000000000000000000000000f48a4820000000000000000000000000000000000000000000000000000000000000000000000000000000058af9da008a886558f6ddedaa38137b2711bd50000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000146e04a2f00000000000000000000000000000000000000000000000000000000000000000000000000000000a4b93723c4543eb67fefaee124101f044778ee2d00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000371d78fbc00000000000000000000000000000000000000000000000000000000f63761240000000000000000000000000000000000000000000000000000000033c72dfe00000000000000000000000000000000000000000000000000000000000000000000000000000000001595e532b83a43f193902f418c6365205242f9000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000001262201b60000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006c41cf14f330000000000000000000000000000000000000000000000000000000000000020000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000006200000000000000000000000007360904a663b9cb66bab538f406c04d8da86229d000000000000000000000000ab59409415e28deeb6255ba64527e3271d057fed0000000000000000000000007ccb2ddb4f7a239ca9edf765edc0bb4e7e04ef5f00000000000000000000000018d45bc9319937d2099dc8e0d0edceee033fcf2500000000000000000000000095143890162bd671d77ae9b771881a1cb76c29a4000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000180000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002800000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000480000000000000000000000000000000000000000000000000000000000000004000000000000000000000000061460874a7196d6a22d1ee4922473664b3e952700000000000000000000000000000000000000000000000000000000000000004434f4d50000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044144414900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005504344414900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000459444149000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000d0a1e359811322d97991e03f863a0c30c2cf029c0000000000000000000000000000000000000000000000000000000000000004574554480000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000004f96fe3b7a6cf9725f59d353f723c1bdb64ca6aa000000000000000000000000000000000000000000000000000000000000000344414900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000b7a4f3e9097c08da09517b5ab877f7a917224ede000000000000000000000000000000000000000000000000000000000000000455534443000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000a36085f69e2889c224210f603d836748e7dc008800000000000000000000000000000000000000000000000000000000000000044c494e4b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003000000000000000000000000f0d0eb522cfa50b716b3b1604c4f0fa6f04376ad0000000000000000000000004a92e71227d294f041bd82dd8f78591b75140d6300000000000000000000000041b5844f4680a8c38fbb695b7f9cfd1f64474a7200000000000000000000000000000000000000000000000000000000", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "blockNumber": 25103807, + "cumulativeGasUsed": "5530229", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0x61460874a7196d6a22d1ee4922473664b3e95270" + }, + { + "sym": "ADAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "PCDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "YDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "WETH", + "addr": "0xd0a1e359811322d97991e03f863a0c30c2cf029c" + }, + { + "sym": "DAI", + "addr": "0x4f96fe3b7a6cf9725f59d353f723c1bdb64ca6aa" + }, + { + "sym": "USDC", + "addr": "0xb7a4f3e9097c08da09517b5ab877f7a917224ede" + }, + { + "sym": "LINK", + "addr": "0xa36085F69e2889c224210F603D836748e7dC0088" + } + ], + "cTokens": [ + "0xf0d0eb522cfa50b716b3b1604c4f0fa6f04376ad", + "0x4a92e71227d294f041bd82dd8f78591b75140d63", + "0x41b5844f4680a8c38fbb695b7f9cfd1f64474a72" + ], + "tellerNFT": "0x7360904A663B9Cb66baB538F406C04D8da86229d", + "loansEscrowBeacon": "0xAb59409415e28deEb6255ba64527E3271D057FED", + "collateralEscrowBeacon": "0x7cCb2ddB4f7a239CA9edF765edC0bb4e7e04Ef5F", + "tTokenBeacon": "0x18D45BC9319937d2099Dc8e0D0EdCEEe033fCf25", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "receipt": { + "to": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "204539", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000000000000000000000000040000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb", + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25104070, + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000617bf3ec25f4b04ca986ae559ed37be7f68cccad0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25104070, + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000617bf3ec25f4b04ca986ae559ed37be7f68cccad0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb", + "args": [ + [ + [ + "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + 0, + ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"] + ] + ], + "0x0000000000000000000000000000000000000000", + "0x" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 25104070, + "cumulativeGasUsed": "204539", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "0x60806040523661000b57005b600080357fffffffff000000000000000000000000000000000000000000000000000000001681527fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c6020819052604090912054819073ffffffffffffffffffffffffffffffffffffffff16806100b7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906115f3565b60405180910390fd5b3660008037600080366000845af43d6000803e8080156100d6573d6000f35b3d6000fd5b60005b83518110156102325760008482815181106100f557fe5b60200260200101516020015190506000600281111561011057fe5b81600281111561011c57fe5b141561015f5761015a85838151811061013157fe5b60200260200101516000015186848151811061014957fe5b602002602001015160400151610326565b610229565b600181600281111561016d57fe5b14156101ab5761015a85838151811061018257fe5b60200260200101516000015186848151811061019a57fe5b60200260200101516040015161065e565b60028160028111156101b957fe5b14156101f75761015a8583815181106101ce57fe5b6020026020010151600001518684815181106101e657fe5b6020026020010151604001516109ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611539565b506001016100de565b507f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb67383838360405161026693929190611282565b60405180910390a16102788282610acb565b505050565b6000610287610302565b60048101805473ffffffffffffffffffffffffffffffffffffffff8581167fffffffffffffffffffffffff000000000000000000000000000000000000000083168117909355604051939450169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c90565b6000815111610361576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b600061036b610302565b905073ffffffffffffffffffffffffffffffffffffffff83166103ba576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166104ab5761040d8460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106104c557fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff168015610554576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906116e2565b5073ffffffffffffffffffffffffffffffffffffffff86166000818152600186810160209081526040808420805480850182559085528285206008820401805463ffffffff60079093166004026101000a928302191660e089901c929092029190911790557fffffffff00000000000000000000000000000000000000000000000000000000909516835287905292902080547fffffffffffffffffffffffff0000000000000000000000000000000000000000169091177fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff86160217905591820191016104ae565b5050505050565b6000815111610699576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006106a3610302565b905073ffffffffffffffffffffffffffffffffffffffff83166106f2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166107e3576107458460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106107fd57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff908116908716811415610892576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061173f565b61089c8183610cbc565b507fffffffff00000000000000000000000000000000000000000000000000000000811660008181526020868152604080832080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8a160217815573ffffffffffffffffffffffffffffffffffffffff8b168085526001808b018552928520805480850182559086528486206008820401805463ffffffff60079093166004026101000a928302191660e09990991c91909102979097179096559390925286905281547fffffffffffffffffffffffff000000000000000000000000000000000000000016909217905591820191016107e6565b60008151116109e6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006109f0610302565b905073ffffffffffffffffffffffffffffffffffffffff831615610a40576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061179c565b60005b8251811015610ac5576000838281518110610a5a57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529185905260409091205490915073ffffffffffffffffffffffffffffffffffffffff16610abb8183610cbc565b5050600101610a43565b50505050565b73ffffffffffffffffffffffffffffffffffffffff8216610b2457805115610b1f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906113c5565b610c7d565b6000815111610b5f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611628565b73ffffffffffffffffffffffffffffffffffffffff82163014610b9e57610b9e8260405180606001604052806028815260200161182660289139610c81565b6000808373ffffffffffffffffffffffffffffffffffffffff1683604051610bc69190611266565b600060405180830381855af49150503d8060008114610c01576040519150601f19603f3d011682016040523d82523d6000602084013e610c06565b606091505b509150915081610ac557805115610c4b57806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611422565b5050565b813b8181610ac5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6000610cc6610302565b905073ffffffffffffffffffffffffffffffffffffffff8316610d15576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906114dc565b73ffffffffffffffffffffffffffffffffffffffff8316301415610d65576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611685565b7fffffffff0000000000000000000000000000000000000000000000000000000082166000908152602082815260408083205473ffffffffffffffffffffffffffffffffffffffff8716845260018501909252909120547401000000000000000000000000000000000000000090910461ffff16907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01808214610f375773ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260408120805483908110610e3657fe5b6000918252602080832060088304015473ffffffffffffffffffffffffffffffffffffffff8a168452600188019091526040909220805460079092166004026101000a90920460e01b925082919085908110610e8e57fe5b600091825260208083206008830401805463ffffffff60079094166004026101000a938402191660e09590951c929092029390931790557fffffffff000000000000000000000000000000000000000000000000000000009290921682528490526040902080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8516021790555b73ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260409020805480610f6757fe5b6000828152602080822060087fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90940193840401805463ffffffff600460078716026101000a0219169055919092557fffffffff00000000000000000000000000000000000000000000000000000000861682528490526040902080547fffffffffffffffffffff000000000000000000000000000000000000000000001690558061065757600283015473ffffffffffffffffffffffffffffffffffffffff861660009081526001858101602052604090912001547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9091019061ffff1680821461114357600085600201838154811061107e57fe5b60009182526020909120015460028701805473ffffffffffffffffffffffffffffffffffffffff90921692508291849081106110b657fe5b600091825260208083209190910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff9485161790559290911681526001878101909252604090200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff83161790555b8460020180548061115057fe5b6000828152602080822083017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90810180547fffffffffffffffffffffffff000000000000000000000000000000000000000016905590920190925573ffffffffffffffffffffffffffffffffffffffff89168252600187810190915260409091200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000016905550505050505050565b73ffffffffffffffffffffffffffffffffffffffff169052565b600081518084526112348160208601602086016117f9565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b600082516112788184602087016117f9565b9190910192915050565b606080825284518282018190526000919060809081850190602080820287018401818b01875b8481101561137c577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff808a8403018652815188840173ffffffffffffffffffffffffffffffffffffffff8251168552858201516003811061130457fe5b858701526040918201519185018a9052815190819052908501908a90898601905b808310156113675783517fffffffff00000000000000000000000000000000000000000000000000000000168252928701926001929092019190870190611325565b509786019794505050908301906001016112a8565b505061138a8289018b611202565b878103604089015261139c818a61121c565b9b9a5050505050505050505050565b6000602082526113be602083018461121c565b9392505050565b6020808252603c908201527f4c69624469616d6f6e644375743a205f696e697420697320616464726573732860408201527f3029206275745f63616c6c64617461206973206e6f7420656d70747900000000606082015260800190565b60208082526026908201527f4c69624469616d6f6e644375743a205f696e69742066756e6374696f6e20726560408201527f7665727465640000000000000000000000000000000000000000000000000000606082015260800190565b6020808252602b908201527f4c69624469616d6f6e644375743a204e6f2073656c6563746f727320696e206660408201527f6163657420746f20637574000000000000000000000000000000000000000000606082015260800190565b60208082526037908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f76652066756e6360408201527f74696f6e207468617420646f65736e2774206578697374000000000000000000606082015260800190565b60208082526027908201527f4c69624469616d6f6e644375743a20496e636f7272656374204661636574437560408201527f74416374696f6e00000000000000000000000000000000000000000000000000606082015260800190565b6020808252602c908201527f4c69624469616d6f6e644375743a204164642066616365742063616e2774206260408201527f6520616464726573732830290000000000000000000000000000000000000000606082015260800190565b6020808252818101527f4469616d6f6e643a2046756e6374696f6e20646f6573206e6f74206578697374604082015260600190565b6020808252603d908201527f4c69624469616d6f6e644375743a205f63616c6c6461746120697320656d707460408201527f7920627574205f696e6974206973206e6f742061646472657373283029000000606082015260800190565b6020808252602e908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f766520696d6d7560408201527f7461626c652066756e6374696f6e000000000000000000000000000000000000606082015260800190565b60208082526035908201527f4c69624469616d6f6e644375743a2043616e2774206164642066756e6374696f60408201527f6e207468617420616c7265616479206578697374730000000000000000000000606082015260800190565b60208082526038908201527f4c69624469616d6f6e644375743a2043616e2774207265706c6163652066756e60408201527f6374696f6e20776974682073616d652066756e6374696f6e0000000000000000606082015260800190565b60208082526036908201527f4c69624469616d6f6e644375743a2052656d6f7665206661636574206164647260408201527f657373206d757374206265206164647265737328302900000000000000000000606082015260800190565b60005b838110156118145781810151838201526020016117fc565b83811115610ac5575050600091015256fe4c69624469616d6f6e644375743a205f696e6974206164647265737320686173206e6f20636f64654c69624469616d6f6e644375743a204e657720666163657420686173206e6f20636f6465a264697066735822122054a3c3a118803545231f43700030cb5e290869be0182196a4a05e7d4a1b71d7e64736f6c63430007060033", + "facets": [ + [ + "0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", + ["0x1f931c1c"] + ], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ], + "action": 0 + } + ], + "history": [ + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "5530229", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000020000020000008000000840000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000008000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000420000000000000000000000000000000000000000000000000000000000000008000", + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "args": [ + "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0" + ], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea00000000000000000000000000000000000000000000000000000000000001300000000000000000000000000000000000000000000000000000000000000001100000000000000000000000000000000000000000000000000000000000002200000000000000000000000000000000000000000000000000000000000000380000000000000000000000000000000000000000000000000000000000000048000000000000000000000000000000000000000000000000000000000000005600000000000000000000000000000000000000000000000000000000000000660000000000000000000000000000000000000000000000000000000000000072000000000000000000000000000000000000000000000000000000000000007e000000000000000000000000000000000000000000000000000000000000008e000000000000000000000000000000000000000000000000000000000000009c00000000000000000000000000000000000000000000000000000000000000ae00000000000000000000000000000000000000000000000000000000000000bc00000000000000000000000000000000000000000000000000000000000000d800000000000000000000000000000000000000000000000000000000000000e800000000000000000000000000000000000000000000000000000000000000f600000000000000000000000000000000000000000000000000000000000001060000000000000000000000000000000000000000000000000000000000000110000000000000000000000000000000000000000000000000000000000000011e0000000000000000000000000d326456fa02a0976a6304152248cdd576302471a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000742f1181e000000000000000000000000000000000000000000000000000000006eade577000000000000000000000000000000000000000000000000000000004dc2304d00000000000000000000000000000000000000000000000000000000ad21879e000000000000000000000000000000000000000000000000000000001cf14f330000000000000000000000000000000000000000000000000000000070712939000000000000000000000000000000000000000000000000000000006e4d22c200000000000000000000000000000000000000000000000000000000000000000000000000000000bb25ad0cb256f9cb457856b30c36756859a536570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000049dec88b900000000000000000000000000000000000000000000000000000000ce19912900000000000000000000000000000000000000000000000000000000d10a0aec0000000000000000000000000000000000000000000000000000000074b1d75d000000000000000000000000000000000000000000000000000000000000000000000000000000003b34fbafa24db8c5c6c88bb9996703a31bd0e97b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003c76d202d00000000000000000000000000000000000000000000000000000000839bb9a6000000000000000000000000000000000000000000000000000000008e756bb30000000000000000000000000000000000000000000000000000000000000000000000000000000042b98ea041d660ee5696ac64e0e684040f84bc5f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004fee2792b00000000000000000000000000000000000000000000000000000000bf6d79ab00000000000000000000000000000000000000000000000000000000c1c52f8800000000000000000000000000000000000000000000000000000000ec1c2bb5000000000000000000000000000000000000000000000000000000000000000000000000000000006de843c33e610cc76ab7d53675a19275b75d5442000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002241b71bb00000000000000000000000000000000000000000000000000000000bb14516c00000000000000000000000000000000000000000000000000000000000000000000000000000000e387aac3e2c1f690a21dc6dceb0ee8d903f068de00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000235a7206d00000000000000000000000000000000000000000000000000000000c05b1ec3000000000000000000000000000000000000000000000000000000000000000000000000000000007f05e46146f9d3cf2086633e43c1302116f7190d000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004961113df0000000000000000000000000000000000000000000000000000000010d94006000000000000000000000000000000000000000000000000000000008fe2b41400000000000000000000000000000000000000000000000000000000020ce3a6000000000000000000000000000000000000000000000000000000000000000000000000000000002ca57d87f6be51515ace674f8d520fa3abe8f5bb0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000039912dde8000000000000000000000000000000000000000000000000000000005a601668000000000000000000000000000000000000000000000000000000008a4f4f9200000000000000000000000000000000000000000000000000000000000000000000000000000000172caf420c79ee756020792d99c77db2c77db8e800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000513abaf0700000000000000000000000000000000000000000000000000000000ece1373200000000000000000000000000000000000000000000000000000000ed903f7a00000000000000000000000000000000000000000000000000000000010d573000000000000000000000000000000000000000000000000000000000767a7b0500000000000000000000000000000000000000000000000000000000000000000000000000000000355161f7da9da53ca4ab44fcd0372ce3b22fef29000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003ce6e9f9f0000000000000000000000000000000000000000000000000000000002bc2cdb000000000000000000000000000000000000000000000000000000000448a5c400000000000000000000000000000000000000000000000000000000000000000000000000000000be09acf7a2257aa063697d31f3b3e55bd524252e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000aeee8b7ff0000000000000000000000000000000000000000000000000000000072e1132700000000000000000000000000000000000000000000000000000000f4f015700000000000000000000000000000000000000000000000000000000046a384be00000000000000000000000000000000000000000000000000000000e949756100000000000000000000000000000000000000000000000000000000504006ca00000000000000000000000000000000000000000000000000000000c4c1662b00000000000000000000000000000000000000000000000000000000bddffdc4000000000000000000000000000000000000000000000000000000000634612f000000000000000000000000000000000000000000000000000000003b92930000000000000000000000000000000000000000000000000000000000000000000000000000000000d99dfbd7ee2cc714debff8390c33f0dbb1502ed2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b53000000000000000000000000000000000000000000000000000000000000000000000000000000005503066a836df524f8871cbb84c4290f7d65bb600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000032239f5560000000000000000000000000000000000000000000000000000000046efd16c0000000000000000000000000000000000000000000000000000000078b248e40000000000000000000000000000000000000000000000000000000000000000000000000000000028a91ecd8c1637bb102bca987084aec35b7f5853000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004a7baf6fc000000000000000000000000000000000000000000000000000000006f70d212000000000000000000000000000000000000000000000000000000000967aa82000000000000000000000000000000000000000000000000000000000f48a4820000000000000000000000000000000000000000000000000000000000000000000000000000000058af9da008a886558f6ddedaa38137b2711bd50000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000146e04a2f00000000000000000000000000000000000000000000000000000000000000000000000000000000a4b93723c4543eb67fefaee124101f044778ee2d00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000371d78fbc00000000000000000000000000000000000000000000000000000000f63761240000000000000000000000000000000000000000000000000000000033c72dfe00000000000000000000000000000000000000000000000000000000000000000000000000000000001595e532b83a43f193902f418c6365205242f9000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000001262201b60000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006c41cf14f330000000000000000000000000000000000000000000000000000000000000020000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000006200000000000000000000000007360904a663b9cb66bab538f406c04d8da86229d000000000000000000000000ab59409415e28deeb6255ba64527e3271d057fed0000000000000000000000007ccb2ddb4f7a239ca9edf765edc0bb4e7e04ef5f00000000000000000000000018d45bc9319937d2099dc8e0d0edceee033fcf2500000000000000000000000095143890162bd671d77ae9b771881a1cb76c29a4000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000180000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002800000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000480000000000000000000000000000000000000000000000000000000000000004000000000000000000000000061460874a7196d6a22d1ee4922473664b3e952700000000000000000000000000000000000000000000000000000000000000004434f4d50000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044144414900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005504344414900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000459444149000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000d0a1e359811322d97991e03f863a0c30c2cf029c0000000000000000000000000000000000000000000000000000000000000004574554480000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000004f96fe3b7a6cf9725f59d353f723c1bdb64ca6aa000000000000000000000000000000000000000000000000000000000000000344414900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000b7a4f3e9097c08da09517b5ab877f7a917224ede000000000000000000000000000000000000000000000000000000000000000455534443000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000a36085f69e2889c224210f603d836748e7dc008800000000000000000000000000000000000000000000000000000000000000044c494e4b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003000000000000000000000000f0d0eb522cfa50b716b3b1604c4f0fa6f04376ad0000000000000000000000004a92e71227d294f041bd82dd8f78591b75140d6300000000000000000000000041b5844f4680a8c38fbb695b7f9cfd1f64474a7200000000000000000000000000000000000000000000000000000000", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "blockNumber": 25103807, + "cumulativeGasUsed": "5530229", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0x61460874a7196d6a22d1ee4922473664b3e95270" + }, + { + "sym": "ADAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "PCDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "YDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "WETH", + "addr": "0xd0a1e359811322d97991e03f863a0c30c2cf029c" + }, + { + "sym": "DAI", + "addr": "0x4f96fe3b7a6cf9725f59d353f723c1bdb64ca6aa" + }, + { + "sym": "USDC", + "addr": "0xb7a4f3e9097c08da09517b5ab877f7a917224ede" + }, + { + "sym": "LINK", + "addr": "0xa36085F69e2889c224210F603D836748e7dC0088" + } + ], + "cTokens": [ + "0xf0d0eb522cfa50b716b3b1604c4f0fa6f04376ad", + "0x4a92e71227d294f041bd82dd8f78591b75140d63", + "0x41b5844f4680a8c38fbb695b7f9cfd1f64474a72" + ], + "tellerNFT": "0x7360904A663B9Cb66baB538F406C04D8da86229d", + "loansEscrowBeacon": "0xAb59409415e28deEb6255ba64527E3271D057FED", + "collateralEscrowBeacon": "0x7cCb2ddB4f7a239CA9edF765edC0bb4e7e04Ef5F", + "tTokenBeacon": "0x18D45BC9319937d2099Dc8e0D0EdCEEe033fCf25", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanUserRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanConsensusResponse[]", + "name": "responses", + "type": "tuple[]" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanUserRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanConsensusResponse[]", + "name": "responses", + "type": "tuple[]" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x731e016ac0dea74d300588c8ee2b3c12914b86c01f3b041c572ef2041d3d70eb", + "receipt": { + "to": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "1557011", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000000000000000000000000040000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xa8615f71b8dc8b88fd926aaf7d23e6d3cf8e7dd2d59ef579ab8ab46d14ca38b0", + "transactionHash": "0x731e016ac0dea74d300588c8ee2b3c12914b86c01f3b041c572ef2041d3d70eb", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25347890, + "transactionHash": "0x731e016ac0dea74d300588c8ee2b3c12914b86c01f3b041c572ef2041d3d70eb", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014e000000000000000000000000000000000000000000000000000000000000000130000000000000000000000000000000000000000000000000000000000000260000000000000000000000000000000000000000000000000000000000000034000000000000000000000000000000000000000000000000000000000000004a000000000000000000000000000000000000000000000000000000000000005a000000000000000000000000000000000000000000000000000000000000006800000000000000000000000000000000000000000000000000000000000000780000000000000000000000000000000000000000000000000000000000000084000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000ae00000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000cc00000000000000000000000000000000000000000000000000000000000000e800000000000000000000000000000000000000000000000000000000000000f8000000000000000000000000000000000000000000000000000000000000010600000000000000000000000000000000000000000000000000000000000001160000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000012e000000000000000000000000000000000000000000000000000000000000013800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003ce6e9f9f0000000000000000000000000000000000000000000000000000000002bc2cdb000000000000000000000000000000000000000000000000000000000448a5c40000000000000000000000000000000000000000000000000000000000000000000000000000000003655add6798b6a8b9b2756e59486cea85e8ba2400000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000742f1181e000000000000000000000000000000000000000000000000000000006eade577000000000000000000000000000000000000000000000000000000004dc2304d00000000000000000000000000000000000000000000000000000000ad21879e000000000000000000000000000000000000000000000000000000001cf14f330000000000000000000000000000000000000000000000000000000070712939000000000000000000000000000000000000000000000000000000006e4d22c20000000000000000000000000000000000000000000000000000000000000000000000000000000031d88294e48f70233be242a524b0bebb0d155bc40000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000049dec88b900000000000000000000000000000000000000000000000000000000ce19912900000000000000000000000000000000000000000000000000000000d10a0aec0000000000000000000000000000000000000000000000000000000074b1d75d000000000000000000000000000000000000000000000000000000000000000000000000000000003f4e01c435433cff56cc7e6a054fe210efd06645000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003c76d202d00000000000000000000000000000000000000000000000000000000839bb9a6000000000000000000000000000000000000000000000000000000008e756bb30000000000000000000000000000000000000000000000000000000000000000000000000000000085fd223609f69b8ab88383f8c9fa6a37d38582cc000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004fee2792b00000000000000000000000000000000000000000000000000000000bf6d79ab00000000000000000000000000000000000000000000000000000000c1c52f8800000000000000000000000000000000000000000000000000000000ec1c2bb5000000000000000000000000000000000000000000000000000000000000000000000000000000001ac15086efefb7aa04a6a39f3f4b83608103d2fa000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002241b71bb00000000000000000000000000000000000000000000000000000000bb14516c00000000000000000000000000000000000000000000000000000000000000000000000000000000a6682e09318c47832d95f202b177edb397a8a34200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000235a7206d00000000000000000000000000000000000000000000000000000000c05b1ec30000000000000000000000000000000000000000000000000000000000000000000000000000000007b24e3192b05fe37842f5c71aeea7d726a3cad5000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004961113df0000000000000000000000000000000000000000000000000000000010d94006000000000000000000000000000000000000000000000000000000008fe2b41400000000000000000000000000000000000000000000000000000000020ce3a600000000000000000000000000000000000000000000000000000000000000000000000000000000ca79e8eeae776affc65f539d6cda998a76b250fe0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000039912dde8000000000000000000000000000000000000000000000000000000005a601668000000000000000000000000000000000000000000000000000000008a4f4f9200000000000000000000000000000000000000000000000000000000000000000000000000000000af60235bc891aa08776e59eb6c123fd21a38e75000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000513abaf0700000000000000000000000000000000000000000000000000000000ece1373200000000000000000000000000000000000000000000000000000000ed903f7a00000000000000000000000000000000000000000000000000000000010d573000000000000000000000000000000000000000000000000000000000767a7b0500000000000000000000000000000000000000000000000000000000000000000000000000000000868f7da9164a29801fa58ca0bb6b9c90f497b6ad000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002ea40e51a00000000000000000000000000000000000000000000000000000000461aebf400000000000000000000000000000000000000000000000000000000000000000000000000000000fc11f4ebe9f7c7399464c82825a0b8678fdc4cff00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000aeee8b7ff0000000000000000000000000000000000000000000000000000000072e1132700000000000000000000000000000000000000000000000000000000f4f015700000000000000000000000000000000000000000000000000000000046a384be00000000000000000000000000000000000000000000000000000000e949756100000000000000000000000000000000000000000000000000000000504006ca00000000000000000000000000000000000000000000000000000000c4c1662b00000000000000000000000000000000000000000000000000000000bddffdc4000000000000000000000000000000000000000000000000000000000634612f000000000000000000000000000000000000000000000000000000003b9293000000000000000000000000000000000000000000000000000000000000000000000000000000000028e2ce61ec8ded7f7bc9cba02a33573f7dd9f5f5000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b5300000000000000000000000000000000000000000000000000000000000000000000000000000000c3cb507553f192879c74879102fbb80286bcf12f0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000032239f5560000000000000000000000000000000000000000000000000000000046efd16c0000000000000000000000000000000000000000000000000000000078b248e4000000000000000000000000000000000000000000000000000000000000000000000000000000004cde0f1ba09de4b9fc6850412528d0756516d87a000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004a7baf6fc000000000000000000000000000000000000000000000000000000006f70d212000000000000000000000000000000000000000000000000000000000967aa82000000000000000000000000000000000000000000000000000000000f48a482000000000000000000000000000000000000000000000000000000000000000000000000000000002f7c91d53d4ff3ae6a2a2092776095dbc14bc6df00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000146e04a2f00000000000000000000000000000000000000000000000000000000000000000000000000000000fc7c599947dca76440dd3729a1292190c645eb9200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000371d78fbc00000000000000000000000000000000000000000000000000000000f63761240000000000000000000000000000000000000000000000000000000033c72dfe000000000000000000000000000000000000000000000000000000000000000000000000000000005b5481ad34b79d8e920b5f0f83d718ed225a7102000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000001262201b6000000000000000000000000000000000000000000000000000000000000000000000000000000002966b694d1642392cd759b8d8d316b55eae7aa690000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xa8615f71b8dc8b88fd926aaf7d23e6d3cf8e7dd2d59ef579ab8ab46d14ca38b0" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25347890, + "transactionHash": "0x731e016ac0dea74d300588c8ee2b3c12914b86c01f3b041c572ef2041d3d70eb", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014e000000000000000000000000000000000000000000000000000000000000000130000000000000000000000000000000000000000000000000000000000000260000000000000000000000000000000000000000000000000000000000000034000000000000000000000000000000000000000000000000000000000000004a000000000000000000000000000000000000000000000000000000000000005a000000000000000000000000000000000000000000000000000000000000006800000000000000000000000000000000000000000000000000000000000000780000000000000000000000000000000000000000000000000000000000000084000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000ae00000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000cc00000000000000000000000000000000000000000000000000000000000000e800000000000000000000000000000000000000000000000000000000000000f8000000000000000000000000000000000000000000000000000000000000010600000000000000000000000000000000000000000000000000000000000001160000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000012e000000000000000000000000000000000000000000000000000000000000013800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003ce6e9f9f0000000000000000000000000000000000000000000000000000000002bc2cdb000000000000000000000000000000000000000000000000000000000448a5c40000000000000000000000000000000000000000000000000000000000000000000000000000000003655add6798b6a8b9b2756e59486cea85e8ba2400000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000742f1181e000000000000000000000000000000000000000000000000000000006eade577000000000000000000000000000000000000000000000000000000004dc2304d00000000000000000000000000000000000000000000000000000000ad21879e000000000000000000000000000000000000000000000000000000001cf14f330000000000000000000000000000000000000000000000000000000070712939000000000000000000000000000000000000000000000000000000006e4d22c20000000000000000000000000000000000000000000000000000000000000000000000000000000031d88294e48f70233be242a524b0bebb0d155bc40000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000049dec88b900000000000000000000000000000000000000000000000000000000ce19912900000000000000000000000000000000000000000000000000000000d10a0aec0000000000000000000000000000000000000000000000000000000074b1d75d000000000000000000000000000000000000000000000000000000000000000000000000000000003f4e01c435433cff56cc7e6a054fe210efd06645000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003c76d202d00000000000000000000000000000000000000000000000000000000839bb9a6000000000000000000000000000000000000000000000000000000008e756bb30000000000000000000000000000000000000000000000000000000000000000000000000000000085fd223609f69b8ab88383f8c9fa6a37d38582cc000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004fee2792b00000000000000000000000000000000000000000000000000000000bf6d79ab00000000000000000000000000000000000000000000000000000000c1c52f8800000000000000000000000000000000000000000000000000000000ec1c2bb5000000000000000000000000000000000000000000000000000000000000000000000000000000001ac15086efefb7aa04a6a39f3f4b83608103d2fa000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002241b71bb00000000000000000000000000000000000000000000000000000000bb14516c00000000000000000000000000000000000000000000000000000000000000000000000000000000a6682e09318c47832d95f202b177edb397a8a34200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000235a7206d00000000000000000000000000000000000000000000000000000000c05b1ec30000000000000000000000000000000000000000000000000000000000000000000000000000000007b24e3192b05fe37842f5c71aeea7d726a3cad5000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004961113df0000000000000000000000000000000000000000000000000000000010d94006000000000000000000000000000000000000000000000000000000008fe2b41400000000000000000000000000000000000000000000000000000000020ce3a600000000000000000000000000000000000000000000000000000000000000000000000000000000ca79e8eeae776affc65f539d6cda998a76b250fe0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000039912dde8000000000000000000000000000000000000000000000000000000005a601668000000000000000000000000000000000000000000000000000000008a4f4f9200000000000000000000000000000000000000000000000000000000000000000000000000000000af60235bc891aa08776e59eb6c123fd21a38e75000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000513abaf0700000000000000000000000000000000000000000000000000000000ece1373200000000000000000000000000000000000000000000000000000000ed903f7a00000000000000000000000000000000000000000000000000000000010d573000000000000000000000000000000000000000000000000000000000767a7b0500000000000000000000000000000000000000000000000000000000000000000000000000000000868f7da9164a29801fa58ca0bb6b9c90f497b6ad000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002ea40e51a00000000000000000000000000000000000000000000000000000000461aebf400000000000000000000000000000000000000000000000000000000000000000000000000000000fc11f4ebe9f7c7399464c82825a0b8678fdc4cff00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000aeee8b7ff0000000000000000000000000000000000000000000000000000000072e1132700000000000000000000000000000000000000000000000000000000f4f015700000000000000000000000000000000000000000000000000000000046a384be00000000000000000000000000000000000000000000000000000000e949756100000000000000000000000000000000000000000000000000000000504006ca00000000000000000000000000000000000000000000000000000000c4c1662b00000000000000000000000000000000000000000000000000000000bddffdc4000000000000000000000000000000000000000000000000000000000634612f000000000000000000000000000000000000000000000000000000003b9293000000000000000000000000000000000000000000000000000000000000000000000000000000000028e2ce61ec8ded7f7bc9cba02a33573f7dd9f5f5000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b5300000000000000000000000000000000000000000000000000000000000000000000000000000000c3cb507553f192879c74879102fbb80286bcf12f0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000032239f5560000000000000000000000000000000000000000000000000000000046efd16c0000000000000000000000000000000000000000000000000000000078b248e4000000000000000000000000000000000000000000000000000000000000000000000000000000004cde0f1ba09de4b9fc6850412528d0756516d87a000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004a7baf6fc000000000000000000000000000000000000000000000000000000006f70d212000000000000000000000000000000000000000000000000000000000967aa82000000000000000000000000000000000000000000000000000000000f48a482000000000000000000000000000000000000000000000000000000000000000000000000000000002f7c91d53d4ff3ae6a2a2092776095dbc14bc6df00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000146e04a2f00000000000000000000000000000000000000000000000000000000000000000000000000000000fc7c599947dca76440dd3729a1292190c645eb9200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000371d78fbc00000000000000000000000000000000000000000000000000000000f63761240000000000000000000000000000000000000000000000000000000033c72dfe000000000000000000000000000000000000000000000000000000000000000000000000000000005b5481ad34b79d8e920b5f0f83d718ed225a7102000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000001262201b6000000000000000000000000000000000000000000000000000000000000000000000000000000002966b694d1642392cd759b8d8d316b55eae7aa690000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xa8615f71b8dc8b88fd926aaf7d23e6d3cf8e7dd2d59ef579ab8ab46d14ca38b0", + "args": [ + [ + [ + "0x0000000000000000000000000000000000000000", + 2, + ["0xce6e9f9f", "0x02bc2cdb", "0x0448a5c4"] + ], + [ + "0x03655Add6798b6a8B9b2756E59486Cea85e8ba24", + 1, + [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + ], + [ + "0x31D88294E48f70233bE242A524B0bebb0d155BC4", + 1, + [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + ], + [ + "0x3F4e01c435433CfF56Cc7e6A054Fe210EFd06645", + 1, + ["0xc76d202d", "0x839bb9a6", "0x8e756bb3"] + ], + [ + "0x85FD223609f69b8aB88383F8c9FA6a37d38582CC", + 1, + [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + ], + [ + "0x1Ac15086EFeFb7aa04A6a39f3F4b83608103D2fA", + 1, + ["0x241b71bb", "0xbb14516c"] + ], + [ + "0xa6682e09318c47832D95f202b177Edb397a8a342", + 1, + ["0x35a7206d", "0xc05b1ec3"] + ], + [ + "0x07B24e3192B05FE37842F5C71aEEa7d726a3caD5", + 1, + [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + ], + [ + "0xcA79e8EEAe776AFfC65f539d6cdA998a76b250FE", + 1, + ["0x9912dde8", "0x5a601668", "0x8a4f4f92"] + ], + [ + "0xAf60235Bc891Aa08776E59Eb6c123fd21A38E750", + 1, + [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + ], + [ + "0x868f7DA9164a29801Fa58CA0BB6b9C90f497B6ad", + 0, + ["0xea40e51a", "0x461aebf4"] + ], + [ + "0xFC11f4ebe9f7c7399464c82825A0B8678fdc4cff", + 1, + [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + ], + [ + "0x28E2Ce61Ec8dEd7f7bC9CBa02a33573f7dd9f5F5", + 1, + [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + ], + [ + "0xc3cB507553f192879c74879102fBB80286bcf12F", + 1, + ["0x2239f556", "0x46efd16c", "0x78b248e4"] + ], + [ + "0x4cDe0F1bA09DE4B9fC6850412528D0756516D87A", + 1, + [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + ], + [ + "0x2f7C91D53d4Ff3ae6a2a2092776095DBc14bc6dF", + 1, + ["0x46e04a2f"] + ], + [ + "0xFc7c599947DCa76440DD3729a1292190C645Eb92", + 1, + ["0x71d78fbc", "0xf6376124", "0x33c72dfe"] + ], + [ + "0x5B5481Ad34b79D8e920B5F0f83d718ED225A7102", + 1, + ["0x262201b6"] + ], + [ + "0x2966b694D1642392CD759B8d8D316B55eaE7aA69", + 1, + ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"] + ] + ], + "0x0000000000000000000000000000000000000000", + "0x" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 25347890, + "cumulativeGasUsed": "1557011", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "0x608060405260405162002d4538038062002d45833981016040819052620000269162000db2565b604080516000808252602082019092526200004e918491620000f560201b620000db1760201c565b620000688160000151620002b560201b6200027d1760201c565b60006200007f6200031760201b620003021760201c565b6301ffc9a760e01b600090815260039091016020526040808220805460ff1990811660019081179092556307e4c70760e21b845282842080548216831790556348e2b09360e01b845282842080548216831790556307f5828d60e41b845291909220805490911690911790555062001442915050565b60005b8351811015620002665760008482815181106200011157fe5b6020026020010151602001519050600060028111156200012d57fe5b8160028111156200013a57fe5b14156200018957620001838583815181106200015257fe5b6020026020010151600001518684815181106200016b57fe5b6020026020010151604001516200033b60201b60201c565b6200025c565b60018160028111156200019857fe5b1415620001e15762000183858381518110620001b057fe5b602002602001015160000151868481518110620001c957fe5b6020026020010151604001516200054e60201b60201c565b6002816002811115620001f057fe5b14156200023957620001838583815181106200020857fe5b6020026020010151600001518684815181106200022157fe5b6020026020010151604001516200077860201b60201c565b60405162461bcd60e51b815260040162000253906200117c565b60405180910390fd5b50600101620000f8565b507f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb6738383836040516200029c9392919062000f25565b60405180910390a1620002b082826200083f565b505050565b6000620002c162000317565b6004810180546001600160a01b038581166001600160a01b031983168117909355604051939450169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c90565b60008151116200035f5760405162461bcd60e51b81526004016200025390620010d4565b60006200036b62000317565b90506001600160a01b038316620003965760405162461bcd60e51b81526004016200025390620011c3565b6001600160a01b038316600090815260018201602052604090205461ffff81166200043c57620003e08460405180606001604052806024815260200162002d21602491396200097c565b6002820180546001600160a01b038616600081815260018087016020908152604083208201805461ffff191661ffff90961695909517909455845490810185559381529190912090910180546001600160a01b03191690911790555b60005b8351811015620005475760008482815181106200045857fe5b6020908102919091018101516001600160e01b031981166000908152918690526040909120549091506001600160a01b03168015620004ab5760405162461bcd60e51b81526004016200025390620012ba565b506001600160a01b0386166000818152600186810160209081526040808420805480850182559085528285206008820401805463ffffffff60079093166004026101000a928302191660e089901c929092029190911790556001600160e01b0319909516835287905292902080546001600160a01b03191690911761ffff60a01b1916600160a01b61ffff86160217905591820191016200043f565b5050505050565b6000815111620005725760405162461bcd60e51b81526004016200025390620010d4565b60006200057e62000317565b90506001600160a01b038316620005a95760405162461bcd60e51b81526004016200025390620011c3565b6001600160a01b038316600090815260018201602052604090205461ffff81166200064f57620005f38460405180606001604052806024815260200162002d21602491396200097c565b6002820180546001600160a01b038616600081815260018087016020908152604083208201805461ffff191661ffff90961695909517909455845490810185559381529190912090910180546001600160a01b03191690911790555b60005b8351811015620005475760008482815181106200066b57fe5b6020908102919091018101516001600160e01b031981166000908152918690526040909120549091506001600160a01b03908116908716811415620006c45760405162461bcd60e51b8152600401620002539062001317565b620006d08183620009a0565b506001600160e01b03198116600081815260208681526040808320805461ffff60a01b1916600160a01b61ffff8a16021781556001600160a01b038b168085526001808b018552928520805480850182559086528486206008820401805463ffffffff60079093166004026101000a928302191660e09990991c91909102979097179096559390925286905281546001600160a01b0319169092179055918201910162000652565b60008151116200079c5760405162461bcd60e51b81526004016200025390620010d4565b6000620007a862000317565b90506001600160a01b03831615620007d45760405162461bcd60e51b8152600401620002539062001374565b60005b825181101562000839576000838281518110620007f057fe5b6020908102919091018101516001600160e01b031981166000908152918590526040909120549091506001600160a01b03166200082e8183620009a0565b5050600101620007d7565b50505050565b6001600160a01b0382166200087657805115620008705760405162461bcd60e51b8152600401620002539062001031565b62000978565b60008151116200089a5760405162461bcd60e51b815260040162000253906200120f565b6001600160a01b0382163014620008d057620008d08260405180606001604052806028815260200162002cf9602891396200097c565b600080836001600160a01b031683604051620008ed919062000f07565b600060405180830381855af49150503d80600081146200092a576040519150601f19603f3d011682016040523d82523d6000602084013e6200092f565b606091505b50915091508162000839578051156200095e578060405162461bcd60e51b815260040162000253919062001015565b60405162461bcd60e51b815260040162000253906200108e565b5050565b813b8181620008395760405162461bcd60e51b815260040162000253919062001015565b6000620009ac62000317565b90506001600160a01b038316620009d75760405162461bcd60e51b815260040162000253906200111f565b6001600160a01b03831630141562000a035760405162461bcd60e51b815260040162000253906200126c565b6001600160e01b03198216600090815260208281526040808320546001600160a01b03871684526001850190925290912054600160a01b90910461ffff16906000190180821462000b27576001600160a01b0385166000908152600184016020526040812080548390811062000a7557fe5b600091825260208083206008830401546001600160a01b038a168452600188019091526040909220805460079092166004026101000a90920460e01b92508291908590811062000ac157fe5b600091825260208083206008830401805463ffffffff60079094166004026101000a938402191660e09590951c929092029390931790556001600160e01b031992909216825284905260409020805461ffff60a01b1916600160a01b61ffff8516021790555b6001600160a01b0385166000908152600184016020526040902080548062000b4b57fe5b60008281526020808220600860001990940193840401805463ffffffff600460078716026101000a0219169055919092556001600160e01b0319861682528490526040902080546001600160b01b031916905580620005475760028301546001600160a01b03861660009081526001858101602052604090912001546000199091019061ffff1680821462000c6357600085600201838154811062000bec57fe5b6000918252602090912001546002870180546001600160a01b03909216925082918490811062000c1857fe5b600091825260208083209190910180546001600160a01b0319166001600160a01b0394851617905592909116815260018781019092526040902001805461ffff191661ffff83161790555b8460020180548062000c7157fe5b60008281526020808220830160001990810180546001600160a01b03191690559092019092556001600160a01b03891682526001878101909152604090912001805461ffff1916905550505050505050565b80516001600160a01b038116811462000cdb57600080fd5b919050565b600082601f83011262000cf1578081fd5b8151602062000d0a62000d0483620013f5565b620013d1565b828152818101908583018385028701840188101562000d27578586fd5b855b8581101562000d5d5781516001600160e01b03198116811462000d4a578788fd5b8452928401929084019060010162000d29565b5090979650505050505050565b60006020828403121562000d7c578081fd5b604051602081016001600160401b038111828210171562000d9957fe5b60405290508062000daa8362000cc3565b905292915050565b6000806040838503121562000dc5578182fd5b82516001600160401b038082111562000ddc578384fd5b818501915085601f83011262000df0578384fd5b8151602062000e0362000d0483620013f5565b82815281810190858301885b8581101562000eaa57815188016060818e03601f1901121562000e30578a8bfd5b604051606081018181108a8211171562000e4657fe5b60405262000e5682880162000cc3565b815260408201516003811062000e6a578c8dfd5b8188015260608201518981111562000e80578c8dfd5b62000e908f898386010162000ce0565b604083015250855250928401929084019060010162000e0f565b5050809750505062000ebf8882890162000d6a565b9450505050509250929050565b6001600160a01b03169052565b6000815180845262000ef381602086016020860162001413565b601f01601f19169290920160200192915050565b6000825162000f1b81846020870162001413565b9190910192915050565b606080825284518282018190526000919060809081850190602080820287018401818b01875b8481101562000fe257898303607f19018652815180516001600160a01b0316845284810151898501906003811062000f7f57fe5b858701526040918201519185018a9052815190819052908501908a90898601905b8083101562000fcc5783516001600160e01b031916825292870192600192909201919087019062000fa0565b5097860197945050509083019060010162000f4b565b505062000ff28289018b62000ecc565b878103604089015262001006818a62000ed9565b9b9a5050505050505050505050565b6000602082526200102a602083018462000ed9565b9392505050565b6020808252603c908201527f4c69624469616d6f6e644375743a205f696e697420697320616464726573732860408201527f3029206275745f63616c6c64617461206973206e6f7420656d70747900000000606082015260800190565b60208082526026908201527f4c69624469616d6f6e644375743a205f696e69742066756e6374696f6e2072656040820152651d995c9d195960d21b606082015260800190565b6020808252602b908201527f4c69624469616d6f6e644375743a204e6f2073656c6563746f727320696e206660408201526a1858d95d081d1bc818dd5d60aa1b606082015260800190565b60208082526037908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f76652066756e6360408201527f74696f6e207468617420646f65736e2774206578697374000000000000000000606082015260800190565b60208082526027908201527f4c69624469616d6f6e644375743a20496e636f727265637420466163657443756040820152663a20b1ba34b7b760c91b606082015260800190565b6020808252602c908201527f4c69624469616d6f6e644375743a204164642066616365742063616e2774206260408201526b65206164647265737328302960a01b606082015260800190565b6020808252603d908201527f4c69624469616d6f6e644375743a205f63616c6c6461746120697320656d707460408201527f7920627574205f696e6974206973206e6f742061646472657373283029000000606082015260800190565b6020808252602e908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f766520696d6d7560408201526d3a30b1363290333ab731ba34b7b760911b606082015260800190565b60208082526035908201527f4c69624469616d6f6e644375743a2043616e2774206164642066756e6374696f60408201527f6e207468617420616c7265616479206578697374730000000000000000000000606082015260800190565b60208082526038908201527f4c69624469616d6f6e644375743a2043616e2774207265706c6163652066756e60408201527f6374696f6e20776974682073616d652066756e6374696f6e0000000000000000606082015260800190565b60208082526036908201527f4c69624469616d6f6e644375743a2052656d6f7665206661636574206164647260408201527f657373206d757374206265206164647265737328302900000000000000000000606082015260800190565b6040518181016001600160401b0381118282101715620013ed57fe5b604052919050565b60006001600160401b038211156200140957fe5b5060209081020190565b60005b838110156200143057818101518382015260200162001416565b83811115620008395750506000910152565b6118a780620014526000396000f3fe60806040523661000b57005b600080357fffffffff000000000000000000000000000000000000000000000000000000001681527fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c6020819052604090912054819073ffffffffffffffffffffffffffffffffffffffff16806100b7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906115f3565b60405180910390fd5b3660008037600080366000845af43d6000803e8080156100d6573d6000f35b3d6000fd5b60005b83518110156102325760008482815181106100f557fe5b60200260200101516020015190506000600281111561011057fe5b81600281111561011c57fe5b141561015f5761015a85838151811061013157fe5b60200260200101516000015186848151811061014957fe5b602002602001015160400151610326565b610229565b600181600281111561016d57fe5b14156101ab5761015a85838151811061018257fe5b60200260200101516000015186848151811061019a57fe5b60200260200101516040015161065e565b60028160028111156101b957fe5b14156101f75761015a8583815181106101ce57fe5b6020026020010151600001518684815181106101e657fe5b6020026020010151604001516109ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611539565b506001016100de565b507f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb67383838360405161026693929190611282565b60405180910390a16102788282610acb565b505050565b6000610287610302565b60048101805473ffffffffffffffffffffffffffffffffffffffff8581167fffffffffffffffffffffffff000000000000000000000000000000000000000083168117909355604051939450169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c90565b6000815111610361576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b600061036b610302565b905073ffffffffffffffffffffffffffffffffffffffff83166103ba576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166104ab5761040d8460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106104c557fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff168015610554576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906116e2565b5073ffffffffffffffffffffffffffffffffffffffff86166000818152600186810160209081526040808420805480850182559085528285206008820401805463ffffffff60079093166004026101000a928302191660e089901c929092029190911790557fffffffff00000000000000000000000000000000000000000000000000000000909516835287905292902080547fffffffffffffffffffffffff0000000000000000000000000000000000000000169091177fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff86160217905591820191016104ae565b5050505050565b6000815111610699576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006106a3610302565b905073ffffffffffffffffffffffffffffffffffffffff83166106f2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166107e3576107458460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106107fd57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff908116908716811415610892576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061173f565b61089c8183610cbc565b507fffffffff00000000000000000000000000000000000000000000000000000000811660008181526020868152604080832080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8a160217815573ffffffffffffffffffffffffffffffffffffffff8b168085526001808b018552928520805480850182559086528486206008820401805463ffffffff60079093166004026101000a928302191660e09990991c91909102979097179096559390925286905281547fffffffffffffffffffffffff000000000000000000000000000000000000000016909217905591820191016107e6565b60008151116109e6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006109f0610302565b905073ffffffffffffffffffffffffffffffffffffffff831615610a40576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061179c565b60005b8251811015610ac5576000838281518110610a5a57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529185905260409091205490915073ffffffffffffffffffffffffffffffffffffffff16610abb8183610cbc565b5050600101610a43565b50505050565b73ffffffffffffffffffffffffffffffffffffffff8216610b2457805115610b1f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906113c5565b610c7d565b6000815111610b5f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611628565b73ffffffffffffffffffffffffffffffffffffffff82163014610b9e57610b9e8260405180606001604052806028815260200161182660289139610c81565b6000808373ffffffffffffffffffffffffffffffffffffffff1683604051610bc69190611266565b600060405180830381855af49150503d8060008114610c01576040519150601f19603f3d011682016040523d82523d6000602084013e610c06565b606091505b509150915081610ac557805115610c4b57806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611422565b5050565b813b8181610ac5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6000610cc6610302565b905073ffffffffffffffffffffffffffffffffffffffff8316610d15576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906114dc565b73ffffffffffffffffffffffffffffffffffffffff8316301415610d65576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611685565b7fffffffff0000000000000000000000000000000000000000000000000000000082166000908152602082815260408083205473ffffffffffffffffffffffffffffffffffffffff8716845260018501909252909120547401000000000000000000000000000000000000000090910461ffff16907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01808214610f375773ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260408120805483908110610e3657fe5b6000918252602080832060088304015473ffffffffffffffffffffffffffffffffffffffff8a168452600188019091526040909220805460079092166004026101000a90920460e01b925082919085908110610e8e57fe5b600091825260208083206008830401805463ffffffff60079094166004026101000a938402191660e09590951c929092029390931790557fffffffff000000000000000000000000000000000000000000000000000000009290921682528490526040902080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8516021790555b73ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260409020805480610f6757fe5b6000828152602080822060087fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90940193840401805463ffffffff600460078716026101000a0219169055919092557fffffffff00000000000000000000000000000000000000000000000000000000861682528490526040902080547fffffffffffffffffffff000000000000000000000000000000000000000000001690558061065757600283015473ffffffffffffffffffffffffffffffffffffffff861660009081526001858101602052604090912001547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9091019061ffff1680821461114357600085600201838154811061107e57fe5b60009182526020909120015460028701805473ffffffffffffffffffffffffffffffffffffffff90921692508291849081106110b657fe5b600091825260208083209190910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff9485161790559290911681526001878101909252604090200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff83161790555b8460020180548061115057fe5b6000828152602080822083017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90810180547fffffffffffffffffffffffff000000000000000000000000000000000000000016905590920190925573ffffffffffffffffffffffffffffffffffffffff89168252600187810190915260409091200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000016905550505050505050565b73ffffffffffffffffffffffffffffffffffffffff169052565b600081518084526112348160208601602086016117f9565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b600082516112788184602087016117f9565b9190910192915050565b606080825284518282018190526000919060809081850190602080820287018401818b01875b8481101561137c577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff808a8403018652815188840173ffffffffffffffffffffffffffffffffffffffff8251168552858201516003811061130457fe5b858701526040918201519185018a9052815190819052908501908a90898601905b808310156113675783517fffffffff00000000000000000000000000000000000000000000000000000000168252928701926001929092019190870190611325565b509786019794505050908301906001016112a8565b505061138a8289018b611202565b878103604089015261139c818a61121c565b9b9a5050505050505050505050565b6000602082526113be602083018461121c565b9392505050565b6020808252603c908201527f4c69624469616d6f6e644375743a205f696e697420697320616464726573732860408201527f3029206275745f63616c6c64617461206973206e6f7420656d70747900000000606082015260800190565b60208082526026908201527f4c69624469616d6f6e644375743a205f696e69742066756e6374696f6e20726560408201527f7665727465640000000000000000000000000000000000000000000000000000606082015260800190565b6020808252602b908201527f4c69624469616d6f6e644375743a204e6f2073656c6563746f727320696e206660408201527f6163657420746f20637574000000000000000000000000000000000000000000606082015260800190565b60208082526037908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f76652066756e6360408201527f74696f6e207468617420646f65736e2774206578697374000000000000000000606082015260800190565b60208082526027908201527f4c69624469616d6f6e644375743a20496e636f7272656374204661636574437560408201527f74416374696f6e00000000000000000000000000000000000000000000000000606082015260800190565b6020808252602c908201527f4c69624469616d6f6e644375743a204164642066616365742063616e2774206260408201527f6520616464726573732830290000000000000000000000000000000000000000606082015260800190565b6020808252818101527f4469616d6f6e643a2046756e6374696f6e20646f6573206e6f74206578697374604082015260600190565b6020808252603d908201527f4c69624469616d6f6e644375743a205f63616c6c6461746120697320656d707460408201527f7920627574205f696e6974206973206e6f742061646472657373283029000000606082015260800190565b6020808252602e908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f766520696d6d7560408201527f7461626c652066756e6374696f6e000000000000000000000000000000000000606082015260800190565b60208082526035908201527f4c69624469616d6f6e644375743a2043616e2774206164642066756e6374696f60408201527f6e207468617420616c7265616479206578697374730000000000000000000000606082015260800190565b60208082526038908201527f4c69624469616d6f6e644375743a2043616e2774207265706c6163652066756e60408201527f6374696f6e20776974682073616d652066756e6374696f6e0000000000000000606082015260800190565b60208082526036908201527f4c69624469616d6f6e644375743a2052656d6f7665206661636574206164647260408201527f657373206d757374206265206164647265737328302900000000000000000000606082015260800190565b60005b838110156118145781810151838201526020016117fc565b83811115610ac5575050600091015256fe4c69624469616d6f6e644375743a205f696e6974206164647265737320686173206e6f20636f64654c69624469616d6f6e644375743a204e657720666163657420686173206e6f20636f6465a264697066735822122054a3c3a118803545231f43700030cb5e290869be0182196a4a05e7d4a1b71d7e64736f6c634300070600334c69624469616d6f6e644375743a205f696e6974206164647265737320686173206e6f20636f64654c69624469616d6f6e644375743a204e657720666163657420686173206e6f20636f6465", + "deployedBytecode": "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", + "facets": [ + [ + "0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", + ["0x1f931c1c"] + ], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x03655Add6798b6a8B9b2756E59486Cea85e8ba24", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0x31D88294E48f70233bE242A524B0bebb0d155BC4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3F4e01c435433CfF56Cc7e6A054Fe210EFd06645", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x85FD223609f69b8aB88383F8c9FA6a37d38582CC", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x1Ac15086EFeFb7aa04A6a39f3F4b83608103D2fA", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xa6682e09318c47832D95f202b177Edb397a8a342", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x07B24e3192B05FE37842F5C71aEEa7d726a3caD5", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xcA79e8EEAe776AFfC65f539d6cdA998a76b250FE", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0xAf60235Bc891Aa08776E59Eb6c123fd21A38E750", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x868f7DA9164a29801Fa58CA0BB6b9C90f497B6ad", + "functionSelectors": ["0xea40e51a", "0x461aebf4"] + }, + { + "facetAddress": "0xFC11f4ebe9f7c7399464c82825A0B8678fdc4cff", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0x28E2Ce61Ec8dEd7f7bC9CBa02a33573f7dd9f5F5", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0xc3cB507553f192879c74879102fBB80286bcf12F", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x4cDe0F1bA09DE4B9fC6850412528D0756516D87A", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x2f7C91D53d4Ff3ae6a2a2092776095DBc14bc6dF", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xFc7c599947DCa76440DD3729a1292190C645Eb92", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x5B5481Ad34b79D8e920B5F0f83d718ED225A7102", + "functionSelectors": ["0x262201b6"] + }, + { + "facetAddress": "0x2966b694D1642392CD759B8d8D316B55eaE7aA69", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ] + } + ], + "diamondCut": [ + { + "facetAddress": "0x0000000000000000000000000000000000000000", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 2 + }, + { + "facetAddress": "0x03655Add6798b6a8B9b2756E59486Cea85e8ba24", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 1 + }, + { + "facetAddress": "0x31D88294E48f70233bE242A524B0bebb0d155BC4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 1 + }, + { + "facetAddress": "0x3F4e01c435433CfF56Cc7e6A054Fe210EFd06645", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 1 + }, + { + "facetAddress": "0x85FD223609f69b8aB88383F8c9FA6a37d38582CC", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 1 + }, + { + "facetAddress": "0x1Ac15086EFeFb7aa04A6a39f3F4b83608103D2fA", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 1 + }, + { + "facetAddress": "0xa6682e09318c47832D95f202b177Edb397a8a342", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 1 + }, + { + "facetAddress": "0x07B24e3192B05FE37842F5C71aEEa7d726a3caD5", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 1 + }, + { + "facetAddress": "0xcA79e8EEAe776AFfC65f539d6cdA998a76b250FE", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 1 + }, + { + "facetAddress": "0xAf60235Bc891Aa08776E59Eb6c123fd21A38E750", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 1 + }, + { + "facetAddress": "0x868f7DA9164a29801Fa58CA0BB6b9C90f497B6ad", + "functionSelectors": ["0xea40e51a", "0x461aebf4"], + "action": 0 + }, + { + "facetAddress": "0xFC11f4ebe9f7c7399464c82825A0B8678fdc4cff", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 1 + }, + { + "facetAddress": "0x28E2Ce61Ec8dEd7f7bC9CBa02a33573f7dd9f5F5", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 1 + }, + { + "facetAddress": "0xc3cB507553f192879c74879102fBB80286bcf12F", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 1 + }, + { + "facetAddress": "0x4cDe0F1bA09DE4B9fC6850412528D0756516D87A", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 1 + }, + { + "facetAddress": "0x2f7C91D53d4Ff3ae6a2a2092776095DBc14bc6dF", + "functionSelectors": ["0x46e04a2f"], + "action": 1 + }, + { + "facetAddress": "0xFc7c599947DCa76440DD3729a1292190C645Eb92", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 1 + }, + { + "facetAddress": "0x5B5481Ad34b79D8e920B5F0f83d718ED225A7102", + "functionSelectors": ["0x262201b6"], + "action": 1 + }, + { + "facetAddress": "0x2966b694D1642392CD759B8d8D316B55eaE7aA69", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ], + "action": 1 + } + ], + "history": [ + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "5530229", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000020000020000008000000840000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000008000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000420000000000000000000000000000000000000000000000000000000000000008000", + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea00000000000000000000000000000000000000000000000000000000000001300000000000000000000000000000000000000000000000000000000000000001100000000000000000000000000000000000000000000000000000000000002200000000000000000000000000000000000000000000000000000000000000380000000000000000000000000000000000000000000000000000000000000048000000000000000000000000000000000000000000000000000000000000005600000000000000000000000000000000000000000000000000000000000000660000000000000000000000000000000000000000000000000000000000000072000000000000000000000000000000000000000000000000000000000000007e000000000000000000000000000000000000000000000000000000000000008e000000000000000000000000000000000000000000000000000000000000009c00000000000000000000000000000000000000000000000000000000000000ae00000000000000000000000000000000000000000000000000000000000000bc00000000000000000000000000000000000000000000000000000000000000d800000000000000000000000000000000000000000000000000000000000000e800000000000000000000000000000000000000000000000000000000000000f600000000000000000000000000000000000000000000000000000000000001060000000000000000000000000000000000000000000000000000000000000110000000000000000000000000000000000000000000000000000000000000011e0000000000000000000000000d326456fa02a0976a6304152248cdd576302471a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000742f1181e000000000000000000000000000000000000000000000000000000006eade577000000000000000000000000000000000000000000000000000000004dc2304d00000000000000000000000000000000000000000000000000000000ad21879e000000000000000000000000000000000000000000000000000000001cf14f330000000000000000000000000000000000000000000000000000000070712939000000000000000000000000000000000000000000000000000000006e4d22c200000000000000000000000000000000000000000000000000000000000000000000000000000000bb25ad0cb256f9cb457856b30c36756859a536570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000049dec88b900000000000000000000000000000000000000000000000000000000ce19912900000000000000000000000000000000000000000000000000000000d10a0aec0000000000000000000000000000000000000000000000000000000074b1d75d000000000000000000000000000000000000000000000000000000000000000000000000000000003b34fbafa24db8c5c6c88bb9996703a31bd0e97b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003c76d202d00000000000000000000000000000000000000000000000000000000839bb9a6000000000000000000000000000000000000000000000000000000008e756bb30000000000000000000000000000000000000000000000000000000000000000000000000000000042b98ea041d660ee5696ac64e0e684040f84bc5f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004fee2792b00000000000000000000000000000000000000000000000000000000bf6d79ab00000000000000000000000000000000000000000000000000000000c1c52f8800000000000000000000000000000000000000000000000000000000ec1c2bb5000000000000000000000000000000000000000000000000000000000000000000000000000000006de843c33e610cc76ab7d53675a19275b75d5442000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002241b71bb00000000000000000000000000000000000000000000000000000000bb14516c00000000000000000000000000000000000000000000000000000000000000000000000000000000e387aac3e2c1f690a21dc6dceb0ee8d903f068de00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000235a7206d00000000000000000000000000000000000000000000000000000000c05b1ec3000000000000000000000000000000000000000000000000000000000000000000000000000000007f05e46146f9d3cf2086633e43c1302116f7190d000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004961113df0000000000000000000000000000000000000000000000000000000010d94006000000000000000000000000000000000000000000000000000000008fe2b41400000000000000000000000000000000000000000000000000000000020ce3a6000000000000000000000000000000000000000000000000000000000000000000000000000000002ca57d87f6be51515ace674f8d520fa3abe8f5bb0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000039912dde8000000000000000000000000000000000000000000000000000000005a601668000000000000000000000000000000000000000000000000000000008a4f4f9200000000000000000000000000000000000000000000000000000000000000000000000000000000172caf420c79ee756020792d99c77db2c77db8e800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000513abaf0700000000000000000000000000000000000000000000000000000000ece1373200000000000000000000000000000000000000000000000000000000ed903f7a00000000000000000000000000000000000000000000000000000000010d573000000000000000000000000000000000000000000000000000000000767a7b0500000000000000000000000000000000000000000000000000000000000000000000000000000000355161f7da9da53ca4ab44fcd0372ce3b22fef29000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003ce6e9f9f0000000000000000000000000000000000000000000000000000000002bc2cdb000000000000000000000000000000000000000000000000000000000448a5c400000000000000000000000000000000000000000000000000000000000000000000000000000000be09acf7a2257aa063697d31f3b3e55bd524252e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000aeee8b7ff0000000000000000000000000000000000000000000000000000000072e1132700000000000000000000000000000000000000000000000000000000f4f015700000000000000000000000000000000000000000000000000000000046a384be00000000000000000000000000000000000000000000000000000000e949756100000000000000000000000000000000000000000000000000000000504006ca00000000000000000000000000000000000000000000000000000000c4c1662b00000000000000000000000000000000000000000000000000000000bddffdc4000000000000000000000000000000000000000000000000000000000634612f000000000000000000000000000000000000000000000000000000003b92930000000000000000000000000000000000000000000000000000000000000000000000000000000000d99dfbd7ee2cc714debff8390c33f0dbb1502ed2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b53000000000000000000000000000000000000000000000000000000000000000000000000000000005503066a836df524f8871cbb84c4290f7d65bb600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000032239f5560000000000000000000000000000000000000000000000000000000046efd16c0000000000000000000000000000000000000000000000000000000078b248e40000000000000000000000000000000000000000000000000000000000000000000000000000000028a91ecd8c1637bb102bca987084aec35b7f5853000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004a7baf6fc000000000000000000000000000000000000000000000000000000006f70d212000000000000000000000000000000000000000000000000000000000967aa82000000000000000000000000000000000000000000000000000000000f48a4820000000000000000000000000000000000000000000000000000000000000000000000000000000058af9da008a886558f6ddedaa38137b2711bd50000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000146e04a2f00000000000000000000000000000000000000000000000000000000000000000000000000000000a4b93723c4543eb67fefaee124101f044778ee2d00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000371d78fbc00000000000000000000000000000000000000000000000000000000f63761240000000000000000000000000000000000000000000000000000000033c72dfe00000000000000000000000000000000000000000000000000000000000000000000000000000000001595e532b83a43f193902f418c6365205242f9000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000001262201b60000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006c41cf14f330000000000000000000000000000000000000000000000000000000000000020000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000006200000000000000000000000007360904a663b9cb66bab538f406c04d8da86229d000000000000000000000000ab59409415e28deeb6255ba64527e3271d057fed0000000000000000000000007ccb2ddb4f7a239ca9edf765edc0bb4e7e04ef5f00000000000000000000000018d45bc9319937d2099dc8e0d0edceee033fcf2500000000000000000000000095143890162bd671d77ae9b771881a1cb76c29a4000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000180000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002800000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000480000000000000000000000000000000000000000000000000000000000000004000000000000000000000000061460874a7196d6a22d1ee4922473664b3e952700000000000000000000000000000000000000000000000000000000000000004434f4d50000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044144414900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005504344414900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000459444149000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000d0a1e359811322d97991e03f863a0c30c2cf029c0000000000000000000000000000000000000000000000000000000000000004574554480000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000004f96fe3b7a6cf9725f59d353f723c1bdb64ca6aa000000000000000000000000000000000000000000000000000000000000000344414900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000b7a4f3e9097c08da09517b5ab877f7a917224ede000000000000000000000000000000000000000000000000000000000000000455534443000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000a36085f69e2889c224210f603d836748e7dc008800000000000000000000000000000000000000000000000000000000000000044c494e4b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003000000000000000000000000f0d0eb522cfa50b716b3b1604c4f0fa6f04376ad0000000000000000000000004a92e71227d294f041bd82dd8f78591b75140d6300000000000000000000000041b5844f4680a8c38fbb695b7f9cfd1f64474a7200000000000000000000000000000000000000000000000000000000", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "args": [ + "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0" + ], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "blockNumber": 25103807, + "cumulativeGasUsed": "5530229", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0x61460874a7196d6a22d1ee4922473664b3e95270" + }, + { + "sym": "ADAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "PCDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "YDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "WETH", + "addr": "0xd0a1e359811322d97991e03f863a0c30c2cf029c" + }, + { + "sym": "DAI", + "addr": "0x4f96fe3b7a6cf9725f59d353f723c1bdb64ca6aa" + }, + { + "sym": "USDC", + "addr": "0xb7a4f3e9097c08da09517b5ab877f7a917224ede" + }, + { + "sym": "LINK", + "addr": "0xa36085F69e2889c224210F603D836748e7dC0088" + } + ], + "cTokens": [ + "0xf0d0eb522cfa50b716b3b1604c4f0fa6f04376ad", + "0x4a92e71227d294f041bd82dd8f78591b75140d63", + "0x41b5844f4680a8c38fbb695b7f9cfd1f64474a72" + ], + "tellerNFT": "0x7360904A663B9Cb66baB538F406C04D8da86229d", + "loansEscrowBeacon": "0xAb59409415e28deEb6255ba64527E3271D057FED", + "collateralEscrowBeacon": "0x7cCb2ddB4f7a239CA9edF765edC0bb4e7e04Ef5F", + "tTokenBeacon": "0x18D45BC9319937d2099Dc8e0D0EdCEEe033fCf25", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "receipt": { + "to": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "204539", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000000000000000000000000040000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb", + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25104070, + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000617bf3ec25f4b04ca986ae559ed37be7f68cccad0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25104070, + "transactionHash": "0x2195686daf5bfe396f49a252349a7d2cc825175e59530e3777f7771e1a890e6b", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000617bf3ec25f4b04ca986ae559ed37be7f68cccad0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0xbfa2026e74039a6d3e31bf8922c1780120fb15f66b21f978cdebd4aea2a15ddb", + "args": [ + [ + [ + "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + 0, + ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"] + ] + ], + "0x0000000000000000000000000000000000000000", + "0x" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 25104070, + "cumulativeGasUsed": "204539", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + [ + "0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", + ["0x1f931c1c"] + ], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0x617bf3EC25f4b04CA986AE559ed37BE7F68CCCAd", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ], + "action": 0 + } + ], + "history": [ + { + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "5530229", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000020000020000008000000840000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000008000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000420000000000000000000000000000000000000000000000000000000000000008000", + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x0000000000000000000000006eba841f1201ffdde7ddc2ba995d3308f6c4aea0", + "logIndex": 2, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017", + "args": [ + "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0" + ], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + }, + { + "transactionIndex": 0, + "blockNumber": 25103807, + "transactionHash": "0x65e5a80465137131ceb4d02bfdce801a358af027e4d0324c2dcfec24faa73517", + "address": "0x6EBA841F1201fFDDe7DDC2ba995D3308f6C4aEa0", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x00b686a2adbf87cbddca767e0884f48b7ff7022372ec23d448d3c11652758017" + } + ], + "blockNumber": 25103807, + "cumulativeGasUsed": "5530229", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": [ + "0x241b71bb", + "0xbb14516c" + ], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": [ + "0x35a7206d", + "0xc05b1ec3" + ], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ] + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0xd326456Fa02A0976a6304152248cdd576302471a", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xbb25AD0cb256F9cB457856B30C36756859a53657", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x3B34FbAFA24DB8C5C6C88BB9996703a31Bd0E97b", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x42b98ea041D660eE5696Ac64E0E684040F84bC5f", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x6DE843C33e610cC76Ab7d53675A19275b75D5442", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xE387AAc3E2C1F690A21DC6DCeb0ee8D903f068De", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x7f05e46146F9D3cF2086633E43C1302116F7190D", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x2ca57D87F6be51515ACE674F8d520fA3abE8F5bB", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x172Caf420c79ee756020792D99c77Db2c77dB8E8", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x355161f7da9Da53Ca4AB44Fcd0372CE3b22fef29", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0xBe09ACf7A2257aA063697d31F3b3E55Bd524252e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0xD99dFbd7eE2cc714DEbff8390C33f0dBB1502eD2", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x5503066A836Df524F8871cbb84c4290F7d65bB60", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x28A91eCd8c1637bB102BCA987084aeC35b7f5853", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0x58Af9DA008A886558F6dDeDaa38137B2711bd500", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0xA4b93723c4543Eb67FefaEE124101F044778ee2D", + "functionSelectors": [ + "0x71d78fbc", + "0xf6376124", + "0x33c72dfe" + ], + "action": 0 + }, + { + "facetAddress": "0x001595E532b83a43F193902f418C6365205242F9", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0x61460874a7196d6a22d1ee4922473664b3e95270" + }, + { + "sym": "ADAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "PCDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "YDAI", + "addr": "0x0000000000000000000000000000000000000000" + }, + { + "sym": "WETH", + "addr": "0xd0a1e359811322d97991e03f863a0c30c2cf029c" + }, + { + "sym": "DAI", + "addr": "0x4f96fe3b7a6cf9725f59d353f723c1bdb64ca6aa" + }, + { + "sym": "USDC", + "addr": "0xb7a4f3e9097c08da09517b5ab877f7a917224ede" + }, + { + "sym": "LINK", + "addr": "0xa36085F69e2889c224210F603D836748e7dC0088" + } + ], + "cTokens": [ + "0xf0d0eb522cfa50b716b3b1604c4f0fa6f04376ad", + "0x4a92e71227d294f041bd82dd8f78591b75140d63", + "0x41b5844f4680a8c38fbb695b7f9cfd1f64474a72" + ], + "tellerNFT": "0x7360904A663B9Cb66baB538F406C04D8da86229d", + "loansEscrowBeacon": "0xAb59409415e28deEb6255ba64527E3271D057FED", + "collateralEscrowBeacon": "0x7cCb2ddB4f7a239CA9edF765edC0bb4e7e04Ef5F", + "tTokenBeacon": "0x18D45BC9319937d2099Dc8e0D0EdCEEe033fCf25", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } } ], "devdoc": { diff --git a/deployments/kovan/solcInputs/151024dde4edc20ecc11a6b585cef1b4.json b/deployments/kovan/solcInputs/151024dde4edc20ecc11a6b585cef1b4.json new file mode 100644 index 000000000..8168526a0 --- /dev/null +++ b/deployments/kovan/solcInputs/151024dde4edc20ecc11a6b585cef1b4.json @@ -0,0 +1,561 @@ +{ + "language": "Solidity", + "sources": { + "contracts/contexts/access-control/context.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./internal/grant-role.sol\";\nimport \"./internal/revoke-role.sol\";\nimport \"./internal/renounce-role.sol\";\n\nabstract contract ctx_AccessControl_v1 is\n int_grantRole_AccessControl_v1,\n int_revokeRole_AccessControl_v1,\n int_renounceRole_AccessControl_v1\n{}\n" + }, + "contracts/contexts/access-control/internal/grant-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { AccessControlEvents } from \"../data.sol\";\nimport \"./has-role.sol\";\n\nabstract contract int_grantRole_AccessControl_v1 is\n int_hasRole_AccessControl_v1\n{\n /**\n * @dev Should only use when circumventing admin checking. See {../entry/grant-role.sol}\n */\n function _grantRole(bytes32 role, address account) internal {\n if (_hasRole(role, account)) return;\n accessControlRolesStore().roles[role].members[account] = true;\n emit AccessControlEvents.RoleGranted(role, account, msg.sender);\n }\n}\n" + }, + "contracts/contexts/access-control/internal/revoke-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { AccessControlEvents } from \"../data.sol\";\nimport \"./has-role.sol\";\n\nabstract contract int_revokeRole_AccessControl_v1 is\n int_hasRole_AccessControl_v1\n{\n function _revokeRole(bytes32 role, address account) internal {\n if (!_hasRole(role, account)) return;\n accessControlRolesStore().roles[role].members[account] = false;\n emit AccessControlEvents.RoleRevoked(role, account, msg.sender);\n }\n}\n" + }, + "contracts/contexts/access-control/internal/renounce-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlEvents } from \"../data.sol\";\nimport \"./has-role.sol\";\n\nabstract contract int_renounceRole_AccessControl_v1 is\n int_hasRole_AccessControl_v1\n{\n function _renounceRole(bytes32 role, address account) internal {\n require(_hasRole(role, msg.sender), \"CAN'T RENOUNCE\");\n accessControlRolesStore().roles[role].members[account] = false;\n emit AccessControlEvents.RoleRevoked(role, account, msg.sender);\n }\n}\n" + }, + "contracts/contexts/access-control/data.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nstruct RoleData {\n mapping(address => bool) members;\n bytes32 adminRole;\n}\n\nlibrary AccessControlEvents {\n event OwnerSet(address indexed owner);\n\n event OwnerTransferred(address indexed owner, address indexed prevOwner);\n\n /**\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n *\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n * {RoleAdminChanged} not being emitted signaling this.\n *\n * _Available since v3.1._\n */\n event RoleAdminChanged(\n bytes32 indexed role,\n bytes32 indexed previousAdminRole,\n bytes32 indexed newAdminRole\n );\n\n /**\n * @dev Emitted when `account` is granted `role`.\n *\n * `sender` is the account that originated the contract call, an admin role\n * bearer except when using {_setupRole}.\n */\n event RoleGranted(\n bytes32 indexed role,\n address indexed account,\n address indexed sender\n );\n\n /**\n * @dev Emitted when `account` is revoked `role`.\n *\n * `sender` is the account that originated the contract call:\n * - if using `revokeRole`, it is the admin role bearer\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\n */\n event RoleRevoked(\n bytes32 indexed role,\n address indexed account,\n address indexed sender\n );\n}\n" + }, + "contracts/contexts/access-control/internal/has-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"../storage/roles.sol\";\n\nabstract contract int_hasRole_AccessControl_v1 is sto_AccessControl_Roles {\n function _hasRole(bytes32 role, address account)\n internal\n view\n returns (bool hasRole_)\n {\n hasRole_ = accessControlRolesStore().roles[role].members[account];\n }\n}\n" + }, + "contracts/contexts/access-control/storage/roles.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { RoleData } from \"../data.sol\";\n\ncontract sto_AccessControl_Roles {\n bytes32 internal constant POS =\n keccak256(\"teller_protocol.storage.access_control.roles\");\n\n struct AccessControlRolesStorage {\n mapping(bytes32 => RoleData) roles;\n }\n\n function accessControlRolesStore()\n internal\n pure\n returns (AccessControlRolesStorage storage s)\n {\n bytes32 position = POS;\n\n assembly {\n s.slot := position\n }\n }\n}\n" + }, + "contracts/contexts/initializable/context.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"../access-control/internal/grant-role.sol\";\nimport \"../access-control/internal/revoke-role.sol\";\nimport \"../access-control/internal/renounce-role.sol\";\n\ncontract ctx_Initializable_v1 is\n int_grantRole_AccessControl_v1,\n int_revokeRole_AccessControl_v1,\n int_renounceRole_AccessControl_v1\n{}\n" + }, + "contracts/contexts/access-control/entry/revoke-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../data.sol\";\nimport \"../internal/revoke-role.sol\";\nimport \"../internal/is-admin-for-role.sol\";\n\ncontract ent_revokeRole_AccessControl_v1 is\n int_revokeRole_AccessControl_v1,\n int_isAdminForRole_AccessControl_v1\n{\n /**\n * @notice Removes a role from an address.\n *\n * Requirements:\n * - Sender must be role admin.\n */\n function revokeRole(bytes32 role, address account) external {\n require(_isAdminForRole(role, msg.sender), \"AccessControl: not admin\");\n _revokeRole(role, account);\n }\n}\n" + }, + "contracts/contexts/access-control/internal/is-admin-for-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"../storage/roles.sol\";\n\nabstract contract int_isAdminForRole_AccessControl_v1 is\n sto_AccessControl_Roles\n{\n function _isAdminForRole(bytes32 role, address account)\n internal\n view\n returns (bool isAdminForRole_)\n {\n isAdminForRole_ = accessControlRolesStore().roles[\n accessControlRolesStore().roles[role].adminRole\n ]\n .members[account];\n }\n}\n" + }, + "contracts/contexts/access-control/entry/renounce-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../data.sol\";\nimport \"../internal/revoke-role.sol\";\nimport \"../internal/is-admin-for-role.sol\";\n\ncontract ent_renounceRole_AccessControl_v1 is\n int_revokeRole_AccessControl_v1,\n int_isAdminForRole_AccessControl_v1\n{\n /**\n * @notice Grants an address a new role.\n * @param role the role to revoke for the account\n * @param account the address of the respective account to revoke\n * Requirements:\n * - Sender must be role admin.\n */\n function renounceRole(bytes32 role, address account) external {\n require(\n account == msg.sender,\n \"AccessControl: can only renounce roles for self\"\n );\n _revokeRole(role, account);\n }\n}\n" + }, + "contracts/contexts/access-control/storage.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./data.sol\";\n\ncontract sto_AccessControl {\n struct AccessControlLayout {\n mapping(bytes32 => RoleData) roles;\n bool notEntered;\n }\n\n function accessControl()\n internal\n pure\n returns (AccessControlLayout storage l_)\n {\n bytes32 position = keccak256(\"teller_protocol.storage.access_control\");\n\n assembly {\n l_.slot := position\n }\n }\n}\n" + }, + "contracts/contexts/access-control/modifiers/entry.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { sto_AccessControl } from \"../storage.sol\";\n\nabstract contract mod_entry_AccessControl_v1 is sto_AccessControl {\n modifier entry {\n AccessControlLayout storage layout = accessControl();\n require(layout.notEntered, \"RE_ENTRANCY\");\n layout.notEntered = false;\n _;\n layout.notEntered = true;\n }\n}\n" + }, + "contracts/contexts/access-control/internal/transfer-owner.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlEvents } from \"../data.sol\";\nimport \"../storage/owner.sol\";\n\nabstract contract int_transferOwner_AccessControl_v1 is\n sto_AccessControl_Owner\n{\n function _transferOwner(address owner) internal {\n require(\n accessControlOwnerStore().owner == msg.sender,\n \"AccessControl: cannot transfer; not owner\"\n );\n accessControlOwnerStore().owner = owner;\n emit AccessControlEvents.OwnerTransferred(owner, msg.sender);\n }\n}\n" + }, + "contracts/contexts/access-control/storage/owner.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract sto_AccessControl_Owner {\n bytes32 internal constant POS =\n keccak256(\"teller_protocol.storage.access_control.owner\");\n\n struct AccessControlOwnerStorage {\n address owner;\n }\n\n function accessControlOwnerStore()\n internal\n pure\n returns (AccessControlOwnerStorage storage s)\n {\n bytes32 position = POS;\n\n assembly {\n s.slot := position\n }\n }\n}\n" + }, + "contracts/contexts/access-control/modifiers/only-owner.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"../storage/owner.sol\";\n\nabstract contract mod_onlyOwner_AccessControl_v1 is sto_AccessControl_Owner {\n modifier onlyOwner() {\n require(\n accessControlOwnerStore().owner == msg.sender,\n \"AccessControl: not owner\"\n );\n _;\n }\n}\n\nabstract contract mod_onlyOwner_AccessControl is\n mod_onlyOwner_AccessControl_v1\n{}\n" + }, + "contracts/contexts/access-control/internal/set-owner.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlEvents } from \"../data.sol\";\nimport \"../storage/owner.sol\";\n\nabstract contract int_setOwner_AccessControl_v1 is sto_AccessControl_Owner {\n function _setOwner(address owner) internal {\n require(\n accessControlOwnerStore().owner == address(0),\n \"AccessControl: owner already set\"\n );\n accessControlOwnerStore().owner = owner;\n emit AccessControlEvents.OwnerSet(owner);\n }\n}\n" + }, + "contracts/contexts/access-control/internal/set-role-admin.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlEvents } from \"../data.sol\";\nimport \"./admin-role-for.sol\";\n\nabstract contract int_setRoleAdmin_AccessControl_v1 is\n int_adminRoleFor_AccessControl_v1\n{\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal {\n accessControlRolesStore().roles[role].adminRole = adminRole;\n emit AccessControlEvents.RoleAdminChanged(\n role,\n _adminRoleFor(role),\n adminRole\n );\n }\n}\n" + }, + "contracts/contexts/access-control/internal/admin-role-for.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../storage/roles.sol\";\n\nabstract contract int_adminRoleFor_AccessControl_v1 is sto_AccessControl_Roles {\n function _adminRoleFor(bytes32 role)\n internal\n view\n returns (bytes32 adminRoleFor_)\n {\n adminRoleFor_ = accessControlRolesStore().roles[role].adminRole;\n }\n}\n\nabstract contract int_adminRoleFor_AccessControl is\n int_adminRoleFor_AccessControl_v1\n{}\n" + }, + "contracts/contexts/access-control/internal/require-authorization.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./has-role.sol\";\n\nabstract contract int_requireAuthorization_AccessControl_v1 is\n int_hasRole_AccessControl_v1\n{\n function _requireAuthorization(bytes32 role, address account)\n internal\n view\n {\n require(_hasRole(role, account), \"AccessControl: unauthorized\");\n }\n}\n" + }, + "contracts/contexts/access-control/modifiers/authorized.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {\n int_requireAuthorization_AccessControl_v1\n} from \"../internal/require-authorization.sol\";\n\nabstract contract mod_authorized_AccessControl_v1 is\n int_requireAuthorization_AccessControl_v1\n{\n modifier authorized(bytes32 role, address account) {\n _requireAuthorization(role, account);\n _;\n }\n}\n\nabstract contract mod_authorized_AccessControl is\n mod_authorized_AccessControl_v1\n{}\n" + }, + "contracts/nft/distributor/entry/move-merkle.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../store.sol\";\nimport \"../../../contexts/access-control/modifiers/authorized.sol\";\n\n// Utils\nimport { DistributorEvents, ADMIN, MerkleRoot } from \"../data.sol\";\n\ncontract ent_moveMerkle_NFTDistributor_v1 is\n sto_NFTDistributor,\n mod_authorized_AccessControl_v1\n{\n /**\n * @notice Change a merkle to be for a different tier to be able to claim NFTs.\n * @param index Index of merkle to set.\n * @param tierIndex Index of NFT tier to assign merkle for.\n *\n * Requirements:\n * - Caller must be an admin\n */\n function moveMerkle(uint256 index, uint256 tierIndex)\n external\n authorized(ADMIN, msg.sender)\n {\n MerkleRoot storage merkle = distributorStore().merkleRoots[index];\n merkle.tierIndex = tierIndex;\n }\n}\n" + }, + "contracts/nft/distributor/store.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Interfaces\nimport \"../ITellerNFT.sol\";\nimport \"../TellerNFTDictionary.sol\";\n\n// Utils\nimport { MerkleRoot } from \"./data.sol\";\n\nabstract contract sto_NFTDistributor {\n struct DistributorStorage {\n ITellerNFT nft;\n MerkleRoot[] merkleRoots;\n mapping(uint256 => mapping(uint256 => uint256)) claimedBitMap;\n TellerNFTDictionary dictionary;\n }\n\n bytes32 constant POSITION = keccak256(\"teller_nft.distributor\");\n\n function distributorStore()\n internal\n pure\n returns (DistributorStorage storage s)\n {\n bytes32 P = POSITION;\n assembly {\n s.slot := P\n }\n }\n}\n" + }, + "contracts/nft/distributor/data.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nbytes32 constant ADMIN = keccak256(\"ADMIN\");\nbytes32 constant MINTER = keccak256(\"MINTER\");\n\nstruct MerkleRoot {\n bytes32 merkleRoot;\n uint256 tierIndex;\n}\n\nstruct ClaimNFTRequest {\n uint256 merkleIndex;\n uint256 nodeIndex;\n uint256 amount;\n bytes32[] merkleProof;\n}\n\nlibrary DistributorEvents {\n event Claimed(address indexed account);\n\n event MerkleAdded(uint256 index);\n}\n" + }, + "contracts/nft/ITellerNFT.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\npragma experimental ABIEncoderV2;\n\n// Interfaces\nimport \"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\";\n\ninterface ITellerNFT {\n struct Tier {\n uint256 baseLoanSize;\n string[] hashes;\n address contributionAsset;\n uint256 contributionSize;\n uint8 contributionMultiplier;\n }\n\n /**\n * @notice The contract metadata URI.\n * @return the contractURI in string\n */\n function contractURI() external view returns (string memory);\n\n /**\n * @notice It returns information about a Tier with from a tier index\n * @param index Tier index to get info.\n * @return tier_ the tier which belongs to the respective index\n */\n function getTier(uint256 index) external view returns (Tier memory tier_);\n\n /**\n * @notice It returns information about a Tier for a token ID.\n * @param tokenId ID of the token to get Tier info.\n * @return index_ the index of the tier the tokenID belongs in\n * @return tier_ the tier where the tokenID belongs in\n */\n function getTokenTier(uint256 tokenId)\n external\n view\n returns (uint256 index_, Tier memory tier_);\n\n /**\n * @notice It returns an array of hashes in a tier\n * @param tierIndex the tier index to get the tier hashes\n * @return hashes_ all the tokenID hashes\n */\n function getTierHashes(uint256 tierIndex)\n external\n view\n returns (string[] memory hashes_);\n\n /**\n * @notice It returns an array of token IDs owned by an address.\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\n * @dev Can be costly if calling within a contract for address with many tokens.\n * @return owned the array of tokenIDs owned by the address\n */\n function getOwnedTokens(address owner)\n external\n view\n returns (uint256[] memory owned);\n\n /**\n * @notice It mints a new token for a Tier index.\n * @param tierIndex the tier index to mint the token in\n * @param owner the owner of the new token\n * Requirements:\n * - Caller must be an authorized minter\n */\n function mint(uint256 tierIndex, address owner) external;\n\n /**\n * @notice Adds a new Tier to be minted with the given information.\n * @dev It auto increments the index of the next tier to add.\n * @param newTier Information about the new tier to add.\n *\n * Requirements:\n * - Caller must have the {MINTER} role\n */\n function addTier(Tier memory newTier) external;\n\n /**\n * @notice Sets the contract level metadata URI hash.\n * @param contractURIHash The hash to the initial contract level metadata.\n */\n function setContractURIHash(string memory contractURIHash) external;\n\n /**\n * @notice Initializes the TellerNFT.\n * @param minters The addresses that should allowed to mint tokens.\n */\n function initialize(address[] calldata minters) external;\n}\n" + }, + "contracts/nft/TellerNFTDictionary.sol": { + "content": "/**\n * @notice TellerNFTDictionary Version 1.02\n *\n * @notice This contract is used to gather data for TellerV1 NFTs more efficiently.\n * @notice This contract has data which must be continuously synchronized with the TellerV1 NFT data\n *\n * @author develop@teller.finance\n */\n\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\";\n\n// Interfaces\nimport \"./IStakeableNFT.sol\";\n\n/**\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\n *\n * @author develop@teller.finance\n */\ncontract TellerNFTDictionary is IStakeableNFT, AccessControlUpgradeable {\n struct Tier {\n uint256 baseLoanSize;\n string[] hashes;\n address contributionAsset;\n uint256 contributionSize;\n uint8 contributionMultiplier;\n }\n\n mapping(uint256 => uint256) public baseLoanSizes;\n mapping(uint256 => string[]) public hashes;\n mapping(uint256 => address) public contributionAssets;\n mapping(uint256 => uint256) public contributionSizes;\n mapping(uint256 => uint8) public contributionMultipliers;\n\n /* Constants */\n\n bytes32 public constant ADMIN = keccak256(\"ADMIN\");\n\n /* State Variables */\n\n mapping(uint256 => uint256) public _tokenTierMappingCompressed;\n bool public _tokenTierMappingCompressedSet;\n\n /* Modifiers */\n\n modifier onlyAdmin() {\n require(hasRole(ADMIN, _msgSender()), \"TellerNFTDictionary: not admin\");\n _;\n }\n\n function initialize(address initialAdmin) public {\n _setupRole(ADMIN, initialAdmin);\n _setRoleAdmin(ADMIN, ADMIN);\n\n __AccessControl_init();\n }\n\n /* External Functions */\n\n /**\n * @notice It returns information about a Tier for a token ID.\n * @param tokenId ID of the token to get Tier info.\n */\n function getTokenTierIndex(uint256 tokenId)\n public\n view\n returns (uint8 index_)\n {\n //32 * 8 = 256 - each uint256 holds the data of 32 tokens . 8 bits each.\n\n uint256 mappingIndex = tokenId / 32;\n\n uint256 compressedRegister = _tokenTierMappingCompressed[mappingIndex];\n\n //use 31 instead of 32 to account for the '0x' in the start.\n //the '31 -' reverses our bytes order which is necessary\n\n uint256 offset = ((31 - (tokenId % 32)) * 8);\n\n uint8 tierIndex = uint8((compressedRegister >> offset));\n\n return tierIndex;\n }\n\n function getTierHashes(uint256 tierIndex)\n external\n view\n returns (string[] memory)\n {\n return hashes[tierIndex];\n }\n\n /**\n * @notice Adds a new Tier to be minted with the given information.\n * @dev It auto increments the index of the next tier to add.\n * @param newTier Information about the new tier to add.\n *\n * Requirements:\n * - Caller must have the {Admin} role\n */\n function setTier(uint256 index, Tier memory newTier)\n external\n onlyAdmin\n returns (bool)\n {\n baseLoanSizes[index] = newTier.baseLoanSize;\n hashes[index] = newTier.hashes;\n contributionAssets[index] = newTier.contributionAsset;\n contributionSizes[index] = newTier.contributionSize;\n contributionMultipliers[index] = newTier.contributionMultiplier;\n\n return true;\n }\n\n /**\n * @notice Sets the tiers for each tokenId using compressed data.\n * @param tiersMapping Information about the new tiers to add.\n *\n * Requirements:\n * - Caller must have the {Admin} role\n */\n function setAllTokenTierMappings(uint256[] memory tiersMapping)\n public\n onlyAdmin\n returns (bool)\n {\n require(\n !_tokenTierMappingCompressedSet,\n \"TellerNFTDictionary: token tier mapping already set\"\n );\n for (uint256 i = 0; i < tiersMapping.length; i++) {\n _tokenTierMappingCompressed[i] = tiersMapping[i];\n }\n\n _tokenTierMappingCompressedSet = true;\n return true;\n }\n\n /**\n * @notice Sets the tiers for each tokenId using compressed data.\n * @param index the mapping row, each holds data for 32 tokens\n * @param tierMapping Information about the new tier to add.\n *\n * Requirements:\n * - Caller must have the {Admin} role\n */\n function setTokenTierMapping(uint256 index, uint256 tierMapping)\n public\n onlyAdmin\n returns (bool)\n {\n _tokenTierMappingCompressed[index] = tierMapping;\n\n return true;\n }\n\n /**\n * @notice Sets a specific tier for a specific tokenId using compressed data.\n * @param tokenIds the NFT token Ids for which to add data\n * @param tokenTier the index of the tier that these tokenIds should have\n *\n * Requirements:\n * - Caller must have the {Admin} role\n */\n function setTokenTierForTokenIds(\n uint256[] calldata tokenIds,\n uint256 tokenTier\n ) public onlyAdmin returns (bool) {\n for (uint256 i; i < tokenIds.length; i++) {\n setTokenTierForTokenId(tokenIds[i], tokenTier);\n }\n\n return true;\n }\n\n /**\n * @notice Sets a specific tier for a specific tokenId using compressed data.\n * @param tokenId the NFT token Id for which to add data\n * @param tokenTier the index of the tier that these tokenIds should have\n *\n * Requirements:\n * - Caller must have the {Admin} role\n */\n function setTokenTierForTokenId(uint256 tokenId, uint256 tokenTier)\n public\n onlyAdmin\n returns (bool)\n {\n uint256 mappingIndex = tokenId / 32;\n\n uint256 existingRegister = _tokenTierMappingCompressed[mappingIndex];\n\n uint256 offset = ((31 - (tokenId % 32)) * 8);\n\n uint256 updateMaskShifted =\n 0x00000000000000000000000000000000000000000000000000000000000000FF <<\n offset;\n\n uint256 updateMaskShiftedNegated = ~updateMaskShifted;\n\n uint256 tokenTierShifted =\n ((0x0000000000000000000000000000000000000000000000000000000000000000 |\n tokenTier) << offset);\n\n uint256 existingRegisterClearedWithMask =\n existingRegister & updateMaskShiftedNegated;\n\n uint256 updatedRegister =\n existingRegisterClearedWithMask | tokenTierShifted;\n\n _tokenTierMappingCompressed[mappingIndex] = updatedRegister;\n\n return true;\n }\n\n function supportsInterface(bytes4 interfaceId)\n public\n view\n override(AccessControlUpgradeable)\n returns (bool)\n {\n return\n interfaceId == type(IStakeableNFT).interfaceId ||\n AccessControlUpgradeable.supportsInterface(interfaceId);\n }\n\n /**\n New methods for the dictionary\n */\n\n /**\n * @notice It returns Base Loan Size for a token ID.\n * @param tokenId ID of the token to get info.\n */\n function tokenBaseLoanSize(uint256 tokenId)\n public\n view\n override\n returns (uint256)\n {\n uint8 tokenTier = getTokenTierIndex(tokenId);\n\n return baseLoanSizes[tokenTier];\n }\n\n /**\n * @notice It returns Token URI Hash for a token ID.\n * @param tokenId ID of the token to get info.\n */\n function tokenURIHash(uint256 tokenId)\n public\n view\n override\n returns (string memory)\n {\n uint8 tokenTier = getTokenTierIndex(tokenId);\n\n string[] memory tierImageHashes = hashes[tokenTier];\n return tierImageHashes[tokenId % (tierImageHashes.length)];\n }\n\n /**\n * @notice It returns Contribution Asset for a token ID.\n * @param tokenId ID of the token to get info.\n */\n function tokenContributionAsset(uint256 tokenId)\n public\n view\n override\n returns (address)\n {\n uint8 tokenTier = getTokenTierIndex(tokenId);\n\n return contributionAssets[tokenTier];\n }\n\n /**\n * @notice It returns Contribution Size for a token ID.\n * @param tokenId ID of the token to get info.\n */\n function tokenContributionSize(uint256 tokenId)\n public\n view\n override\n returns (uint256)\n {\n uint8 tokenTier = getTokenTierIndex(tokenId);\n\n return contributionSizes[tokenTier];\n }\n\n /**\n * @notice It returns Contribution Multiplier for a token ID.\n * @param tokenId ID of the token to get info.\n */\n function tokenContributionMultiplier(uint256 tokenId)\n public\n view\n override\n returns (uint8)\n {\n uint8 tokenTier = getTokenTierIndex(tokenId);\n\n return contributionMultipliers[tokenTier];\n }\n}\n" + }, + "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC721.sol\";\n\n/**\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\n * @dev See https://eips.ethereum.org/EIPS/eip-721\n */\ninterface IERC721Metadata is IERC721 {\n\n /**\n * @dev Returns the token collection name.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the token collection symbol.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\n */\n function tokenURI(uint256 tokenId) external view returns (string memory);\n}\n" + }, + "@openzeppelin/contracts/token/ERC721/IERC721.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev Required interface of an ERC721 compliant contract.\n */\ninterface IERC721 is IERC165 {\n /**\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\n */\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n\n /**\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\n */\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n\n /**\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\n */\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n /**\n * @dev Returns the number of tokens in ``owner``'s account.\n */\n function balanceOf(address owner) external view returns (uint256 balance);\n\n /**\n * @dev Returns the owner of the `tokenId` token.\n *\n * Requirements:\n *\n * - `tokenId` must exist.\n */\n function ownerOf(uint256 tokenId) external view returns (address owner);\n\n /**\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must exist and be owned by `from`.\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n *\n * Emits a {Transfer} event.\n */\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\n\n /**\n * @dev Transfers `tokenId` token from `from` to `to`.\n *\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must be owned by `from`.\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address from, address to, uint256 tokenId) external;\n\n /**\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\n * The approval is cleared when the token is transferred.\n *\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\n *\n * Requirements:\n *\n * - The caller must own the token or be an approved operator.\n * - `tokenId` must exist.\n *\n * Emits an {Approval} event.\n */\n function approve(address to, uint256 tokenId) external;\n\n /**\n * @dev Returns the account approved for `tokenId` token.\n *\n * Requirements:\n *\n * - `tokenId` must exist.\n */\n function getApproved(uint256 tokenId) external view returns (address operator);\n\n /**\n * @dev Approve or remove `operator` as an operator for the caller.\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\n *\n * Requirements:\n *\n * - The `operator` cannot be the caller.\n *\n * Emits an {ApprovalForAll} event.\n */\n function setApprovalForAll(address operator, bool _approved) external;\n\n /**\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\n *\n * See {setApprovalForAll}\n */\n function isApprovedForAll(address owner, address operator) external view returns (bool);\n\n /**\n * @dev Safely transfers `tokenId` token from `from` to `to`.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must exist and be owned by `from`.\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n *\n * Emits a {Transfer} event.\n */\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\n}\n" + }, + "@openzeppelin/contracts/utils/introspection/IERC165.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n /**\n * @dev Returns true if this contract implements the interface defined by\n * `interfaceId`. See the corresponding\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n * to learn more about how these ids are created.\n *\n * This function call must use less than 30 000 gas.\n */\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n" + }, + "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../utils/StringsUpgradeable.sol\";\nimport \"../utils/introspection/ERC165Upgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev External interface of AccessControl declared to support ERC165 detection.\n */\ninterface IAccessControlUpgradeable {\n function hasRole(bytes32 role, address account) external view returns (bool);\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\n function grantRole(bytes32 role, address account) external;\n function revokeRole(bytes32 role, address account) external;\n function renounceRole(bytes32 role, address account) external;\n}\n\n/**\n * @dev Contract module that allows children to implement role-based access\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\n * members except through off-chain means by accessing the contract event logs. Some\n * applications may benefit from on-chain enumerability, for those cases see\n * {AccessControlEnumerable}.\n *\n * Roles are referred to by their `bytes32` identifier. These should be exposed\n * in the external API and be unique. The best way to achieve this is by\n * using `public constant` hash digests:\n *\n * ```\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\n * ```\n *\n * Roles can be used to represent a set of permissions. To restrict access to a\n * function call, use {hasRole}:\n *\n * ```\n * function foo() public {\n * require(hasRole(MY_ROLE, msg.sender));\n * ...\n * }\n * ```\n *\n * Roles can be granted and revoked dynamically via the {grantRole} and\n * {revokeRole} functions. Each role has an associated admin role, and only\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\n *\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\n * that only accounts with this role will be able to grant or revoke other\n * roles. More complex role relationships can be created by using\n * {_setRoleAdmin}.\n *\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\n * grant and revoke this role. Extra precautions should be taken to secure\n * accounts that have been granted it.\n */\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\n function __AccessControl_init() internal initializer {\n __Context_init_unchained();\n __ERC165_init_unchained();\n __AccessControl_init_unchained();\n }\n\n function __AccessControl_init_unchained() internal initializer {\n }\n struct RoleData {\n mapping (address => bool) members;\n bytes32 adminRole;\n }\n\n mapping (bytes32 => RoleData) private _roles;\n\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n /**\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n *\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n * {RoleAdminChanged} not being emitted signaling this.\n *\n * _Available since v3.1._\n */\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n /**\n * @dev Emitted when `account` is granted `role`.\n *\n * `sender` is the account that originated the contract call, an admin role\n * bearer except when using {_setupRole}.\n */\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n /**\n * @dev Emitted when `account` is revoked `role`.\n *\n * `sender` is the account that originated the contract call:\n * - if using `revokeRole`, it is the admin role bearer\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\n */\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n /**\n * @dev Modifier that checks that an account has a specific role. Reverts\n * with a standardized message including the required role.\n *\n * The format of the revert reason is given by the following regular expression:\n *\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\n *\n * _Available since v4.1._\n */\n modifier onlyRole(bytes32 role) {\n _checkRole(role, _msgSender());\n _;\n }\n\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\n || super.supportsInterface(interfaceId);\n }\n\n /**\n * @dev Returns `true` if `account` has been granted `role`.\n */\n function hasRole(bytes32 role, address account) public view override returns (bool) {\n return _roles[role].members[account];\n }\n\n /**\n * @dev Revert with a standard message if `account` is missing `role`.\n *\n * The format of the revert reason is given by the following regular expression:\n *\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\n */\n function _checkRole(bytes32 role, address account) internal view {\n if(!hasRole(role, account)) {\n revert(string(abi.encodePacked(\n \"AccessControl: account \",\n StringsUpgradeable.toHexString(uint160(account), 20),\n \" is missing role \",\n StringsUpgradeable.toHexString(uint256(role), 32)\n )));\n }\n }\n\n /**\n * @dev Returns the admin role that controls `role`. See {grantRole} and\n * {revokeRole}.\n *\n * To change a role's admin, use {_setRoleAdmin}.\n */\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\n return _roles[role].adminRole;\n }\n\n /**\n * @dev Grants `role` to `account`.\n *\n * If `account` had not been already granted `role`, emits a {RoleGranted}\n * event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n */\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\n _grantRole(role, account);\n }\n\n /**\n * @dev Revokes `role` from `account`.\n *\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n */\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\n _revokeRole(role, account);\n }\n\n /**\n * @dev Revokes `role` from the calling account.\n *\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\n * purpose is to provide a mechanism for accounts to lose their privileges\n * if they are compromised (such as when a trusted device is misplaced).\n *\n * If the calling account had been granted `role`, emits a {RoleRevoked}\n * event.\n *\n * Requirements:\n *\n * - the caller must be `account`.\n */\n function renounceRole(bytes32 role, address account) public virtual override {\n require(account == _msgSender(), \"AccessControl: can only renounce roles for self\");\n\n _revokeRole(role, account);\n }\n\n /**\n * @dev Grants `role` to `account`.\n *\n * If `account` had not been already granted `role`, emits a {RoleGranted}\n * event. Note that unlike {grantRole}, this function doesn't perform any\n * checks on the calling account.\n *\n * [WARNING]\n * ====\n * This function should only be called from the constructor when setting\n * up the initial roles for the system.\n *\n * Using this function in any other way is effectively circumventing the admin\n * system imposed by {AccessControl}.\n * ====\n */\n function _setupRole(bytes32 role, address account) internal virtual {\n _grantRole(role, account);\n }\n\n /**\n * @dev Sets `adminRole` as ``role``'s admin role.\n *\n * Emits a {RoleAdminChanged} event.\n */\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\n _roles[role].adminRole = adminRole;\n }\n\n function _grantRole(bytes32 role, address account) private {\n if (!hasRole(role, account)) {\n _roles[role].members[account] = true;\n emit RoleGranted(role, account, _msgSender());\n }\n }\n\n function _revokeRole(bytes32 role, address account) private {\n if (hasRole(role, account)) {\n _roles[role].members[account] = false;\n emit RoleRevoked(role, account, _msgSender());\n }\n }\n uint256[49] private __gap;\n}\n" + }, + "contracts/nft/IStakeableNFT.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IStakeableNFT {\n function tokenBaseLoanSize(uint256 tokenId) external view returns (uint256);\n\n function tokenURIHash(uint256 tokenId)\n external\n view\n returns (string memory);\n\n function tokenContributionAsset(uint256 tokenId)\n external\n view\n returns (address);\n\n function tokenContributionSize(uint256 tokenId)\n external\n view\n returns (uint256);\n\n function tokenContributionMultiplier(uint256 tokenId)\n external\n view\n returns (uint8);\n}\n" + }, + "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\nimport \"../proxy/utils/Initializable.sol\";\n\n/*\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract ContextUpgradeable is Initializable {\n function __Context_init() internal initializer {\n __Context_init_unchained();\n }\n\n function __Context_init_unchained() internal initializer {\n }\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\n return msg.data;\n }\n uint256[50] private __gap;\n}\n" + }, + "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev String operations.\n */\nlibrary StringsUpgradeable {\n bytes16 private constant alphabet = \"0123456789abcdef\";\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n */\n function toString(uint256 value) internal pure returns (string memory) {\n // Inspired by OraclizeAPI's implementation - MIT licence\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\n\n if (value == 0) {\n return \"0\";\n }\n uint256 temp = value;\n uint256 digits;\n while (temp != 0) {\n digits++;\n temp /= 10;\n }\n bytes memory buffer = new bytes(digits);\n while (value != 0) {\n digits -= 1;\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\n value /= 10;\n }\n return string(buffer);\n }\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n */\n function toHexString(uint256 value) internal pure returns (string memory) {\n if (value == 0) {\n return \"0x00\";\n }\n uint256 temp = value;\n uint256 length = 0;\n while (temp != 0) {\n length++;\n temp >>= 8;\n }\n return toHexString(value, length);\n }\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n */\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n bytes memory buffer = new bytes(2 * length + 2);\n buffer[0] = \"0\";\n buffer[1] = \"x\";\n for (uint256 i = 2 * length + 1; i > 1; --i) {\n buffer[i] = alphabet[value & 0xf];\n value >>= 4;\n }\n require(value == 0, \"Strings: hex length insufficient\");\n return string(buffer);\n }\n\n}\n" + }, + "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165Upgradeable.sol\";\nimport \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n *\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\n */\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\n function __ERC165_init() internal initializer {\n __ERC165_init_unchained();\n }\n\n function __ERC165_init_unchained() internal initializer {\n }\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return interfaceId == type(IERC165Upgradeable).interfaceId;\n }\n uint256[50] private __gap;\n}\n" + }, + "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\n// solhint-disable-next-line compiler-version\npragma solidity ^0.8.0;\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n */\nabstract contract Initializable {\n\n /**\n * @dev Indicates that the contract has been initialized.\n */\n bool private _initialized;\n\n /**\n * @dev Indicates that the contract is in the process of being initialized.\n */\n bool private _initializing;\n\n /**\n * @dev Modifier to protect an initializer function from being invoked twice.\n */\n modifier initializer() {\n require(_initializing || !_initialized, \"Initializable: contract is already initialized\");\n\n bool isTopLevelCall = !_initializing;\n if (isTopLevelCall) {\n _initializing = true;\n _initialized = true;\n }\n\n _;\n\n if (isTopLevelCall) {\n _initializing = false;\n }\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165Upgradeable {\n /**\n * @dev Returns true if this contract implements the interface defined by\n * `interfaceId`. See the corresponding\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n * to learn more about how these ids are created.\n *\n * This function call must use less than 30 000 gas.\n */\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n" + }, + "contracts/nft/distributor/interfaces/ITellerNFTDistributor.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Interfaces\nimport \"../../ITellerNFT.sol\";\n\n// Utils\nimport { ClaimNFTRequest, MerkleRoot } from \"../data.sol\";\n\ninterface ITellerNFTDistributor {\n /**\n * @notice It gets the TellerNFT diamond instance used to mint.\n * @return _nft returns the TellerNFT diamond instance\n */\n function nft() external view returns (ITellerNFT _nft);\n\n /**\n * @notice It gets the merkle roots for NFTs it can distribute.\n * @return roots_ the returned merkle roots\n */\n function getMerkleRoots()\n external\n view\n returns (MerkleRoot[] memory roots_);\n\n /**\n * @notice It checks the merkle root for a tier if it has already been claimed.\n * @param merkleIndex Index of the tier.\n * @param nodeIndex Index of the node in the merkle root.\n * @return _claimed returns a boolean to check if the tier has already been claimed\n */\n function isClaimed(uint256 merkleIndex, uint256 nodeIndex)\n external\n view\n returns (bool _claimed);\n\n /**\n * @notice Claims TellerNFTs for a given verifiable merkle proofs for each tier.\n * @param account The address to claim NFTs on behalf.\n * @param requests An array requests data generated from the merkle tree.\n *\n * Requirements:\n * - Node in the merkle root must not be claimed already\n * - Proof of the node must match the merkle tree\n */\n function claim(address account, ClaimNFTRequest[] calldata requests)\n external;\n\n /**\n * @notice Adds a new merkle to be able to claim NFTs.\n * @param tierIndex Index of NFT tier to assign merkle for.\n * @param merkleRoot The merkle root to assign to the new tier.\n *\n * Requirements:\n * - Caller must be an admin\n */\n function addMerkle(uint256 tierIndex, bytes32 merkleRoot) external;\n\n /**\n * @notice Sets a merkle to be able to claim NFTs.\n * @param index Index of merkle to set.\n * @param tierIndex Index of NFT tier to assign merkle for.\n *\n * Requirements:\n * - Caller must be an admin\n */\n function moveMerkle(uint256 index, uint256 tierIndex) external;\n\n /**\n * @notice it grants either an ADMIN or a MINTER role into an account\n * @param role the role to be granted to an account\n * @param account the account address\n */\n function grantRole(bytes32 role, address account) external;\n\n /**\n * @notice it removes either an ADMIN or a MINTER role from an account\n * @param role the role to be granted to an account\n * @param account the account address\n */\n function revokeRole(bytes32 role, address account) external;\n\n /**\n * @notice Grants an address a new role.\n * @param role the role to revoke for the account\n * @param account the address of the respective account to revoke\n */\n function renounceRole(bytes32 role, address account) external;\n\n function setNFTDictionaryAddress(address dictionary) external;\n\n /**\n * @notice Initializes the Distributor contract with the TellerNFT\n * @param _nft The address of the TellerNFT.\n * @param admin The address of an admin.\n */\n function initialize(\n address _nft,\n address _dictionary,\n address admin\n ) external;\n}\n" + }, + "contracts/nft/distributor/entry/initialize.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../store.sol\";\nimport \"../../../contexts/initializable/modifiers/initializer.sol\";\nimport \"../../../contexts/access-control/entry/grant-role.sol\";\n\n// Utils\nimport { ADMIN } from \"../data.sol\";\n\n// Interfaces\nimport \"../../ITellerNFT.sol\";\nimport \"../../TellerNFTDictionary.sol\";\n\ncontract ent_initialize_NFTDistributor_v1 is\n sto_NFTDistributor,\n mod_initializer_Initializable_v1,\n ent_grantRole_AccessControl_v1\n{\n /**\n * @notice Initializes the Distributor contract with the TellerNFT\n * @param _nft The address of the TellerNFT.\n * @param admin The address of an admin.\n */\n function initialize(\n address _nft,\n address _dictionary,\n address admin\n ) external initializer {\n distributorStore().nft = ITellerNFT(_nft);\n distributorStore().dictionary = TellerNFTDictionary(_dictionary);\n\n _grantRole(ADMIN, admin);\n }\n}\n" + }, + "contracts/contexts/initializable/modifiers/initializer.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"../storage.sol\";\n\nabstract contract mod_initializer_Initializable_v1 is sto_Initializable {\n modifier initializer {\n require(\n !initializableStorage().initialized,\n \"Teller: already initialized\"\n );\n _;\n }\n}\n" + }, + "contracts/contexts/access-control/entry/grant-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../data.sol\";\nimport \"../internal/grant-role.sol\";\nimport \"../internal/is-admin-for-role.sol\";\n\ncontract ent_grantRole_AccessControl_v1 is\n int_grantRole_AccessControl_v1,\n int_isAdminForRole_AccessControl_v1\n{\n /**\n * @notice Grants an address a new role.\n *\n * Requirements:\n * - Sender must be role admin.\n */\n function grantRole(bytes32 role, address account) external {\n require(_isAdminForRole(role, msg.sender), \"AccessControl: not admin\");\n _grantRole(role, account);\n }\n}\n" + }, + "contracts/contexts/initializable/storage.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract sto_Initializable {\n struct InitializableLayout {\n bool initialized;\n }\n\n bytes32 internal constant INITIALIZABLE_STORAGE_POSITION =\n keccak256(abi.encode(\"teller_protocol.context.initializable.v1\"));\n\n function initializableStorage()\n internal\n pure\n returns (InitializableLayout storage l_)\n {\n bytes32 position = INITIALIZABLE_STORAGE_POSITION;\n\n assembly {\n l_.slot := position\n }\n }\n}\n" + }, + "contracts/nft/NFTFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { TellerNFT } from \"../nft/TellerNFT.sol\";\nimport { RolesMods } from \"../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN, AUTHORIZED } from \"../shared/roles.sol\";\nimport \"../nft/TellerNFTDictionary.sol\";\n\n// Libraries\nimport \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\nimport { NFTLib } from \"./libraries/NFTLib.sol\";\nimport { RolesLib } from \"../contexts2/access-control/roles/RolesLib.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\ncontract NFTFacet is RolesMods {\n /**\n * @notice it gets the staked NFTs mapped to an owner's address\n * @return staked_ the returned staked NFTs mapped to an owner's address\n */\n function getStakedNFTs(address nftOwner)\n public\n view\n returns (uint256[] memory staked_)\n {\n staked_ = NFTLib.stakedNFTs(nftOwner);\n }\n\n /**\n * @notice it returns the NFTs mapped to a loan\n * @param loanID the identifier of the respective loan to get the loan NFTs from\n * @return loanNFTs the loan NFTs mapped to a loan ID\n */\n function getLoanNFTs(uint256 loanID)\n external\n view\n returns (uint256[] memory loanNFTs)\n {\n EnumerableSet.UintSet storage nfts = NFTLib.s().loanNFTs[loanID];\n loanNFTs = new uint256[](EnumerableSet.length(nfts));\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\n loanNFTs[i] = EnumerableSet.at(nfts, i);\n }\n }\n\n /**\n * @notice Transfers multiple Teller NFTs to Diamond and applies user stake.\n * @param nftIDs IDs of Teller NFTs to stake.\n */\n function stakeNFTs(uint256[] calldata nftIDs) external {\n for (uint256 i; i < nftIDs.length; i++) {\n // Stake NFT and transfer into diamond\n NFTLib.stake(nftIDs[i], msg.sender);\n }\n // Give the caller authorization to protocol\n RolesLib.grantRole(AUTHORIZED, msg.sender);\n }\n\n /**\n * @notice Sets the NFTDictionary address used to get information about an NFT and its tier.\n * @param dictAddress Dictionary address to use.\n *\n * Requirements:\n * - Sender must have `ADMIN` role\n */\n function setNFTDictionary(address dictAddress)\n external\n authorized(ADMIN, msg.sender)\n {\n NFTLib.s().nftDictionary = TellerNFTDictionary(dictAddress);\n }\n}\n" + }, + "contracts/nft/TellerNFT.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\npragma experimental ABIEncoderV2;\n\n// Contracts\nimport \"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\";\nimport \"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\";\n\n// Libraries\nimport \"@openzeppelin/contracts/utils/Counters.sol\";\nimport \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\nimport \"@openzeppelin/contracts/utils/math/SafeMath.sol\";\n\n// Interfaces\nimport \"./ITellerNFT.sol\";\n\n/*****************************************************************************************************/\n/** WARNING **/\n/** THIS CONTRACT IS UPGRADEABLE! **/\n/** --------------------------------------------------------------------------------------------- **/\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\n/** **/\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\n/** more information. **/\n/*****************************************************************************************************/\n/**\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\n *\n * @author develop@teller.finance\n */\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\n using Counters for Counters.Counter;\n using EnumerableSet for EnumerableSet.UintSet;\n using SafeMath for uint256;\n\n /* Constants */\n\n bytes32 public constant ADMIN = keccak256(\"ADMIN\");\n bytes32 public constant MINTER = keccak256(\"MINTER\");\n\n /* State Variables */\n\n // It holds the total number of tiers.\n Counters.Counter internal _tierCounter;\n\n // It holds the total number of tokens minted.\n Counters.Counter internal _tokenCounter;\n\n // It holds the information about a tier.\n mapping(uint256 => Tier) internal _tiers;\n\n // It holds which tier a token ID is in.\n mapping(uint256 => uint256) internal _tokenTier;\n\n // It holds a set of token IDs for an owner address.\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\n\n // Link to the contract metadata\n string private _metadataBaseURI;\n\n // Hash to the contract metadata located on the {_metadataBaseURI}\n string private _contractURIHash;\n\n /* Modifiers */\n\n modifier onlyAdmin() {\n require(hasRole(ADMIN, _msgSender()), \"TellerNFT: not admin\");\n _;\n }\n\n modifier onlyMinter() {\n require(hasRole(MINTER, _msgSender()), \"TellerNFT: not minter\");\n _;\n }\n\n /* External Functions */\n\n /**\n * @notice It returns information about a Tier for a token ID.\n * @param index Tier index to get info.\n * @return tier_ the tier which belongs to the respective index\n */\n function getTier(uint256 index)\n external\n view\n override\n returns (Tier memory tier_)\n {\n tier_ = _tiers[index];\n }\n\n /**\n * @notice It returns information about a Tier for a token ID.\n * @param tokenId ID of the token to get Tier info.\n * @return index_ the index of the tier the tokenID belongs in\n * @return tier_ the tier where the tokenID belongs in\n */\n function getTokenTier(uint256 tokenId)\n external\n view\n override\n returns (uint256 index_, Tier memory tier_)\n {\n index_ = _tokenTier[tokenId];\n tier_ = _tiers[index_];\n }\n\n /**\n * @notice It returns an array of hashes in a tier\n * @param tierIndex the tier index to get the tier hashes\n * @return hashes_ all the tokenID hashes\n */\n function getTierHashes(uint256 tierIndex)\n external\n view\n override\n returns (string[] memory hashes_)\n {\n hashes_ = _tiers[tierIndex].hashes;\n }\n\n /**\n * @notice It returns an array of token IDs owned by an address.\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\n * @dev Can be costly if calling within a contract for address with many tokens.\n * @return owned_ the array of tokenIDs owned by the address\n */\n function getOwnedTokens(address owner)\n external\n view\n override\n returns (uint256[] memory owned_)\n {\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\n owned_ = new uint256[](set.length());\n for (uint256 i; i < owned_.length; i++) {\n owned_[i] = set.at(i);\n }\n }\n\n /**\n * @notice The contract metadata URI.\n * @return the contract URI hash\n */\n function contractURI() external view override returns (string memory) {\n return _contractURIHash;\n }\n\n /**\n * @notice The token URI is based on the token ID.\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\n * @return the tokenURI\n */\n function tokenURI(uint256 tokenId)\n public\n view\n override\n returns (string memory)\n {\n require(_exists(tokenId), \"TellerNFT: URI query for nonexistent token\");\n\n string memory baseURI = _baseURI();\n return\n bytes(baseURI).length > 0\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\n : \"\";\n }\n\n /**\n * @notice It mints a new token for a Tier index.\n * @param tierIndex Tier to mint token on.\n * @param owner The owner of the new token.\n *\n * Requirements:\n * - Caller must be an authorized minter\n */\n function mint(uint256 tierIndex, address owner)\n external\n override\n onlyMinter\n {\n // Get the new token ID\n uint256 tokenId = _tokenCounter.current();\n _tokenCounter.increment();\n\n // Mint and set the token to the tier index\n _safeMint(owner, tokenId);\n _tokenTier[tokenId] = tierIndex;\n\n // Set owner\n _setOwner(owner, tokenId);\n }\n\n /**\n * @notice Adds a new Tier to be minted with the given information.\n * @dev It auto increments the index of the next tier to add.\n * @param newTier Information about the new tier to add.\n *\n * Requirements:\n * - Caller must have the {MINTER} role\n */\n function addTier(Tier memory newTier) external override onlyMinter {\n Tier storage tier = _tiers[_tierCounter.current()];\n\n tier.baseLoanSize = newTier.baseLoanSize;\n tier.hashes = newTier.hashes;\n tier.contributionAsset = newTier.contributionAsset;\n tier.contributionSize = newTier.contributionSize;\n tier.contributionMultiplier = newTier.contributionMultiplier;\n\n _tierCounter.increment();\n }\n\n /**\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\n * @param minter the address of the minter\n */\n function removeMinter(address minter) external onlyMinter {\n revokeRole(MINTER, minter);\n }\n\n /**\n * @notice it adds the minter to the rule\n * @param minter the address of the minter to add to the role of MINTER\n */\n function addMinter(address minter) public onlyMinter {\n _setupRole(MINTER, minter);\n }\n\n /**\n * @notice Sets the contract level metadata URI hash.\n * @param contractURIHash The hash to the initial contract level metadata.\n */\n function setContractURIHash(string memory contractURIHash)\n external\n override\n onlyAdmin\n {\n _contractURIHash = contractURIHash;\n }\n\n /**\n * @notice Initializes the TellerNFT.\n * @param minters The addresses that should allowed to mint tokens.\n */\n function initialize(address[] calldata minters)\n external\n override\n initializer\n {\n __ERC721_init(\"Teller NFT\", \"TNFT\");\n __AccessControl_init();\n\n for (uint256 i; i < minters.length; i++) {\n _setupRole(MINTER, minters[i]);\n }\n\n _metadataBaseURI = \"https://gateway.pinata.cloud/ipfs/\";\n _contractURIHash = \"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\";\n }\n\n /**\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\n * @param interfaceId the identifier of the interface\n * @return bool stating whether or not our interface is supported\n */\n function supportsInterface(bytes4 interfaceId)\n public\n view\n override(AccessControlUpgradeable, ERC721Upgradeable)\n returns (bool)\n {\n return\n interfaceId == type(ITellerNFT).interfaceId ||\n ERC721Upgradeable.supportsInterface(interfaceId) ||\n AccessControlUpgradeable.supportsInterface(interfaceId);\n }\n\n /**\n * @notice It returns the hash to use for the token URI.\n * @param tokenId the tokenId to get the tokenURI hash\n * @return the tokenURIHash of our NFT\n */\n function _tokenURIHash(uint256 tokenId)\n internal\n view\n returns (string memory)\n {\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\n }\n\n /**\n * @notice The base URI path where the token media is hosted.\n * @dev Base URI for computing {tokenURI}\n * @return our metadata URI\n */\n function _baseURI() internal view override returns (string memory) {\n return _metadataBaseURI;\n }\n\n /**\n * @notice Moves token to new owner set and then transfers.\n * @param from address to transfer from\n * @param to address to transfer to\n * @param tokenId tokenID to transfer\n */\n function _transfer(\n address from,\n address to,\n uint256 tokenId\n ) internal override {\n _setOwner(to, tokenId);\n super._transfer(from, to, tokenId);\n }\n\n /**\n * @notice It removes the token from the current owner set and adds to new owner.\n * @param newOwner the new owner of the tokenID\n * @param tokenId the ID of the NFT\n */\n function _setOwner(address newOwner, uint256 tokenId) internal {\n address currentOwner = ownerOf(tokenId);\n if (currentOwner != address(0)) {\n _ownerTokenIDs[currentOwner].remove(tokenId);\n }\n _ownerTokenIDs[newOwner].add(tokenId);\n }\n\n function _msgData() internal pure override returns (bytes calldata) {\n return msg.data;\n }\n}\n" + }, + "contracts/contexts2/access-control/roles/RolesMods.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { RolesLib } from \"./RolesLib.sol\";\n\nabstract contract RolesMods {\n /**\n * @notice Requires that the {account} has {role}\n * @param role Encoding of the role to check.\n * @param account Address to check the {role} for.\n */\n modifier authorized(bytes32 role, address account) {\n require(\n RolesLib.hasRole(role, account),\n \"AccessControl: not authorized\"\n );\n _;\n }\n}\n" + }, + "contracts/shared/roles.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/**\n * @dev the roles for the user to assign, revoke and check in functions\n */\nbytes32 constant ADMIN = keccak256(\"ADMIN\");\nbytes32 constant PAUSER = keccak256(\"PAUSER\");\nbytes32 constant AUTHORIZED = keccak256(\"AUTHORIZED\");\n" + }, + "@openzeppelin/contracts/utils/structs/EnumerableSet.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for managing\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\n * types.\n *\n * Sets have the following properties:\n *\n * - Elements are added, removed, and checked for existence in constant time\n * (O(1)).\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\n *\n * ```\n * contract Example {\n * // Add the library methods\n * using EnumerableSet for EnumerableSet.AddressSet;\n *\n * // Declare a set state variable\n * EnumerableSet.AddressSet private mySet;\n * }\n * ```\n *\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\n * and `uint256` (`UintSet`) are supported.\n */\nlibrary EnumerableSet {\n // To implement this library for multiple types with as little code\n // repetition as possible, we write it in terms of a generic Set type with\n // bytes32 values.\n // The Set implementation uses private functions, and user-facing\n // implementations (such as AddressSet) are just wrappers around the\n // underlying Set.\n // This means that we can only create new EnumerableSets for types that fit\n // in bytes32.\n\n struct Set {\n // Storage of set values\n bytes32[] _values;\n\n // Position of the value in the `values` array, plus 1 because index 0\n // means a value is not in the set.\n mapping (bytes32 => uint256) _indexes;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function _add(Set storage set, bytes32 value) private returns (bool) {\n if (!_contains(set, value)) {\n set._values.push(value);\n // The value is stored at length-1, but we add 1 to all indexes\n // and use 0 as a sentinel value\n set._indexes[value] = set._values.length;\n return true;\n } else {\n return false;\n }\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function _remove(Set storage set, bytes32 value) private returns (bool) {\n // We read and store the value's index to prevent multiple reads from the same storage slot\n uint256 valueIndex = set._indexes[value];\n\n if (valueIndex != 0) { // Equivalent to contains(set, value)\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\n // the array, and then remove the last element (sometimes called as 'swap and pop').\n // This modifies the order of the array, as noted in {at}.\n\n uint256 toDeleteIndex = valueIndex - 1;\n uint256 lastIndex = set._values.length - 1;\n\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\n\n bytes32 lastvalue = set._values[lastIndex];\n\n // Move the last value to the index where the value to delete is\n set._values[toDeleteIndex] = lastvalue;\n // Update the index for the moved value\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\n\n // Delete the slot where the moved value was stored\n set._values.pop();\n\n // Delete the index for the deleted slot\n delete set._indexes[value];\n\n return true;\n } else {\n return false;\n }\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\n return set._indexes[value] != 0;\n }\n\n /**\n * @dev Returns the number of values on the set. O(1).\n */\n function _length(Set storage set) private view returns (uint256) {\n return set._values.length;\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\n require(set._values.length > index, \"EnumerableSet: index out of bounds\");\n return set._values[index];\n }\n\n // Bytes32Set\n\n struct Bytes32Set {\n Set _inner;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\n return _add(set._inner, value);\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\n return _remove(set._inner, value);\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\n return _contains(set._inner, value);\n }\n\n /**\n * @dev Returns the number of values in the set. O(1).\n */\n function length(Bytes32Set storage set) internal view returns (uint256) {\n return _length(set._inner);\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\n return _at(set._inner, index);\n }\n\n // AddressSet\n\n struct AddressSet {\n Set _inner;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function add(AddressSet storage set, address value) internal returns (bool) {\n return _add(set._inner, bytes32(uint256(uint160(value))));\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function remove(AddressSet storage set, address value) internal returns (bool) {\n return _remove(set._inner, bytes32(uint256(uint160(value))));\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function contains(AddressSet storage set, address value) internal view returns (bool) {\n return _contains(set._inner, bytes32(uint256(uint160(value))));\n }\n\n /**\n * @dev Returns the number of values in the set. O(1).\n */\n function length(AddressSet storage set) internal view returns (uint256) {\n return _length(set._inner);\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\n return address(uint160(uint256(_at(set._inner, index))));\n }\n\n\n // UintSet\n\n struct UintSet {\n Set _inner;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function add(UintSet storage set, uint256 value) internal returns (bool) {\n return _add(set._inner, bytes32(value));\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\n return _remove(set._inner, bytes32(value));\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\n return _contains(set._inner, bytes32(value));\n }\n\n /**\n * @dev Returns the number of values on the set. O(1).\n */\n function length(UintSet storage set) internal view returns (uint256) {\n return _length(set._inner);\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\n return uint256(_at(set._inner, index));\n }\n}\n" + }, + "contracts/nft/libraries/NFTLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { TellerNFT } from \"../TellerNFT.sol\";\n\n// Libraries\nimport {\n MerkleProof\n} from \"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\n// Storage\nimport { AppStorageLib, AppStorage } from \"../../storage/app.sol\";\nimport { NFTStorageLib, NFTStorage } from \"../../storage/nft.sol\";\n\nlibrary NFTLib {\n function s() internal pure returns (NFTStorage storage s_) {\n s_ = NFTStorageLib.store();\n }\n\n function nft() internal view returns (TellerNFT nft_) {\n nft_ = AppStorageLib.store().nft;\n }\n\n /**s\n * @notice it transfers the NFT from the sender to the diamond to stake then adds the NFTID to the list of the owner's stakedNFTs\n * @param nftID the ID of the NFT to stake\n * @param owner the owner of the NFT who will stake the NFT\n */\n function stake(uint256 nftID, address owner) internal {\n // Transfer to diamond\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\n // Add NFT ID to user set\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\n }\n\n /**\n * @notice it unstakes the NFT by removing the NFT ID from the list of the user's staked NFTs\n * @param nftID the ID of the NFT to remove from the list of the user's staked NFTs\n * @return success_ the boolean value telling us if the user has unsuccessfully unstaked the NFT\n */\n function unstake(uint256 nftID) internal returns (bool success_) {\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\n }\n\n /**\n * @notice it gets the list of staked NFTs from the owner\n * @param nftOwner the owner of the staked NFTs to pull from\n * @return staked_ the array of the staked NFTs owned by the user\n */\n function stakedNFTs(address nftOwner)\n internal\n view\n returns (uint256[] memory staked_)\n {\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\n staked_ = new uint256[](EnumerableSet.length(nfts));\n for (uint256 i; i < staked_.length; i++) {\n staked_[i] = EnumerableSet.at(nfts, i);\n }\n }\n\n /**\n * @notice if the user fails to pay his loan, then we liquidate the all the NFTs associated with the loan\n * @param loanID the identifier of the loan to liquidate the NFTs from\n */\n function liquidateNFT(uint256 loanID) internal {\n // Check if NFTs are linked\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\n NFTLib.nft().transferFrom(\n address(this),\n AppStorageLib.store().nftLiquidationController,\n EnumerableSet.at(nfts, i)\n );\n }\n }\n\n /**\n * @notice it unstakes an NFT and verifies the proof in order to apply the proof to a loan\n * @param loanID the identifier of the loan\n * @param nftID the NFT ID to apply to the loan\n */\n function applyToLoan(uint256 loanID, uint256 nftID) internal {\n // NFT must be currently staked\n // Remove NFT from being staked - returns bool\n require(unstake(nftID), \"Teller: borrower nft not staked\");\n\n // Apply NFT to loan\n EnumerableSet.add(s().loanNFTs[loanID], nftID);\n }\n\n /**\n * @notice it finds the loan's NFTs and adds them back to the owner's list of staked NFTs\n * @param loanID the identifier of the respective loan to add the NFTs back to the user's staked NFTs\n * @param owner the owner to add the unstaked NFTs back to the staked pile\n */\n function restakeLinked(uint256 loanID, address owner) internal {\n // Get linked NFT\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\n // Restake the NFT\n EnumerableSet.add(s().stakedNFTs[owner], EnumerableSet.at(nfts, i));\n }\n }\n}\n" + }, + "contracts/contexts2/access-control/roles/RolesLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlStorageLib, AccessControlStorage } from \"../storage.sol\";\n\nlibrary RolesLib {\n function s() private pure returns (AccessControlStorage storage) {\n return AccessControlStorageLib.store();\n }\n\n /**\n * @dev Emitted when `account` is granted `role`.\n */\n event RoleGranted(\n bytes32 indexed role,\n address indexed account,\n address indexed sender\n );\n\n /**\n * @dev Emitted when `account` is revoked `role`.\n */\n event RoleRevoked(\n bytes32 indexed role,\n address indexed account,\n address indexed sender\n );\n\n /**\n * @notice Checks if an account has a specific role.\n */\n function hasRole(bytes32 role, address account)\n internal\n view\n returns (bool)\n {\n return s().roles[role][account];\n }\n\n /**\n * @dev Gives an account a new role.\n * @dev Should only use when circumventing admin checking.\n * @dev If account already has the role, no event is emitted.\n * @param role Encoding of the role to give.\n * @param account Address to give the {role} to.\n */\n function grantRole(bytes32 role, address account) internal {\n if (hasRole(role, account)) return;\n s().roles[role][account] = true;\n emit RoleGranted(role, account, msg.sender);\n }\n\n /**\n * @dev Removes a role from an account.\n * @dev Should only use when circumventing admin checking.\n * @dev If account does not already have the role, no event is emitted.\n * @param role Encoding of the role to remove.\n * @param account Address to remove the {role} from.\n */\n function revokeRole(bytes32 role, address account) internal {\n if (!hasRole(role, account)) return;\n s().roles[role][account] = false;\n emit RoleRevoked(role, account, msg.sender);\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IERC721Upgradeable.sol\";\nimport \"./IERC721ReceiverUpgradeable.sol\";\nimport \"./extensions/IERC721MetadataUpgradeable.sol\";\nimport \"../../utils/AddressUpgradeable.sol\";\nimport \"../../utils/ContextUpgradeable.sol\";\nimport \"../../utils/StringsUpgradeable.sol\";\nimport \"../../utils/introspection/ERC165Upgradeable.sol\";\nimport \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\n * {ERC721Enumerable}.\n */\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\n using AddressUpgradeable for address;\n using StringsUpgradeable for uint256;\n\n // Token name\n string private _name;\n\n // Token symbol\n string private _symbol;\n\n // Mapping from token ID to owner address\n mapping (uint256 => address) private _owners;\n\n // Mapping owner address to token count\n mapping (address => uint256) private _balances;\n\n // Mapping from token ID to approved address\n mapping (uint256 => address) private _tokenApprovals;\n\n // Mapping from owner to operator approvals\n mapping (address => mapping (address => bool)) private _operatorApprovals;\n\n /**\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\n */\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\n __Context_init_unchained();\n __ERC165_init_unchained();\n __ERC721_init_unchained(name_, symbol_);\n }\n\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\n _name = name_;\n _symbol = symbol_;\n }\n\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\n return interfaceId == type(IERC721Upgradeable).interfaceId\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\n || super.supportsInterface(interfaceId);\n }\n\n /**\n * @dev See {IERC721-balanceOf}.\n */\n function balanceOf(address owner) public view virtual override returns (uint256) {\n require(owner != address(0), \"ERC721: balance query for the zero address\");\n return _balances[owner];\n }\n\n /**\n * @dev See {IERC721-ownerOf}.\n */\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\n address owner = _owners[tokenId];\n require(owner != address(0), \"ERC721: owner query for nonexistent token\");\n return owner;\n }\n\n /**\n * @dev See {IERC721Metadata-name}.\n */\n function name() public view virtual override returns (string memory) {\n return _name;\n }\n\n /**\n * @dev See {IERC721Metadata-symbol}.\n */\n function symbol() public view virtual override returns (string memory) {\n return _symbol;\n }\n\n /**\n * @dev See {IERC721Metadata-tokenURI}.\n */\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\n require(_exists(tokenId), \"ERC721Metadata: URI query for nonexistent token\");\n\n string memory baseURI = _baseURI();\n return bytes(baseURI).length > 0\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\n : '';\n }\n\n /**\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\n * in child contracts.\n */\n function _baseURI() internal view virtual returns (string memory) {\n return \"\";\n }\n\n /**\n * @dev See {IERC721-approve}.\n */\n function approve(address to, uint256 tokenId) public virtual override {\n address owner = ERC721Upgradeable.ownerOf(tokenId);\n require(to != owner, \"ERC721: approval to current owner\");\n\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\n \"ERC721: approve caller is not owner nor approved for all\"\n );\n\n _approve(to, tokenId);\n }\n\n /**\n * @dev See {IERC721-getApproved}.\n */\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\n require(_exists(tokenId), \"ERC721: approved query for nonexistent token\");\n\n return _tokenApprovals[tokenId];\n }\n\n /**\n * @dev See {IERC721-setApprovalForAll}.\n */\n function setApprovalForAll(address operator, bool approved) public virtual override {\n require(operator != _msgSender(), \"ERC721: approve to caller\");\n\n _operatorApprovals[_msgSender()][operator] = approved;\n emit ApprovalForAll(_msgSender(), operator, approved);\n }\n\n /**\n * @dev See {IERC721-isApprovedForAll}.\n */\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\n return _operatorApprovals[owner][operator];\n }\n\n /**\n * @dev See {IERC721-transferFrom}.\n */\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\n //solhint-disable-next-line max-line-length\n require(_isApprovedOrOwner(_msgSender(), tokenId), \"ERC721: transfer caller is not owner nor approved\");\n\n _transfer(from, to, tokenId);\n }\n\n /**\n * @dev See {IERC721-safeTransferFrom}.\n */\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\n safeTransferFrom(from, to, tokenId, \"\");\n }\n\n /**\n * @dev See {IERC721-safeTransferFrom}.\n */\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\n require(_isApprovedOrOwner(_msgSender(), tokenId), \"ERC721: transfer caller is not owner nor approved\");\n _safeTransfer(from, to, tokenId, _data);\n }\n\n /**\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\n *\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\n *\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\n * implement alternative mechanisms to perform token transfer, such as signature-based.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must exist and be owned by `from`.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n *\n * Emits a {Transfer} event.\n */\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\n _transfer(from, to, tokenId);\n require(_checkOnERC721Received(from, to, tokenId, _data), \"ERC721: transfer to non ERC721Receiver implementer\");\n }\n\n /**\n * @dev Returns whether `tokenId` exists.\n *\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\n *\n * Tokens start existing when they are minted (`_mint`),\n * and stop existing when they are burned (`_burn`).\n */\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\n return _owners[tokenId] != address(0);\n }\n\n /**\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\n *\n * Requirements:\n *\n * - `tokenId` must exist.\n */\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\n require(_exists(tokenId), \"ERC721: operator query for nonexistent token\");\n address owner = ERC721Upgradeable.ownerOf(tokenId);\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\n }\n\n /**\n * @dev Safely mints `tokenId` and transfers it to `to`.\n *\n * Requirements:\n *\n * - `tokenId` must not exist.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n *\n * Emits a {Transfer} event.\n */\n function _safeMint(address to, uint256 tokenId) internal virtual {\n _safeMint(to, tokenId, \"\");\n }\n\n /**\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\n */\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\n _mint(to, tokenId);\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \"ERC721: transfer to non ERC721Receiver implementer\");\n }\n\n /**\n * @dev Mints `tokenId` and transfers it to `to`.\n *\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\n *\n * Requirements:\n *\n * - `tokenId` must not exist.\n * - `to` cannot be the zero address.\n *\n * Emits a {Transfer} event.\n */\n function _mint(address to, uint256 tokenId) internal virtual {\n require(to != address(0), \"ERC721: mint to the zero address\");\n require(!_exists(tokenId), \"ERC721: token already minted\");\n\n _beforeTokenTransfer(address(0), to, tokenId);\n\n _balances[to] += 1;\n _owners[tokenId] = to;\n\n emit Transfer(address(0), to, tokenId);\n }\n\n /**\n * @dev Destroys `tokenId`.\n * The approval is cleared when the token is burned.\n *\n * Requirements:\n *\n * - `tokenId` must exist.\n *\n * Emits a {Transfer} event.\n */\n function _burn(uint256 tokenId) internal virtual {\n address owner = ERC721Upgradeable.ownerOf(tokenId);\n\n _beforeTokenTransfer(owner, address(0), tokenId);\n\n // Clear approvals\n _approve(address(0), tokenId);\n\n _balances[owner] -= 1;\n delete _owners[tokenId];\n\n emit Transfer(owner, address(0), tokenId);\n }\n\n /**\n * @dev Transfers `tokenId` from `from` to `to`.\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\n *\n * Requirements:\n *\n * - `to` cannot be the zero address.\n * - `tokenId` token must be owned by `from`.\n *\n * Emits a {Transfer} event.\n */\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \"ERC721: transfer of token that is not own\");\n require(to != address(0), \"ERC721: transfer to the zero address\");\n\n _beforeTokenTransfer(from, to, tokenId);\n\n // Clear approvals from the previous owner\n _approve(address(0), tokenId);\n\n _balances[from] -= 1;\n _balances[to] += 1;\n _owners[tokenId] = to;\n\n emit Transfer(from, to, tokenId);\n }\n\n /**\n * @dev Approve `to` to operate on `tokenId`\n *\n * Emits a {Approval} event.\n */\n function _approve(address to, uint256 tokenId) internal virtual {\n _tokenApprovals[tokenId] = to;\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\n }\n\n /**\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\n * The call is not executed if the target address is not a contract.\n *\n * @param from address representing the previous owner of the given token ID\n * @param to target address that will receive the tokens\n * @param tokenId uint256 ID of the token to be transferred\n * @param _data bytes optional data to send along with the call\n * @return bool whether the call correctly returned the expected magic value\n */\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\n private returns (bool)\n {\n if (to.isContract()) {\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\n } catch (bytes memory reason) {\n if (reason.length == 0) {\n revert(\"ERC721: transfer to non ERC721Receiver implementer\");\n } else {\n // solhint-disable-next-line no-inline-assembly\n assembly {\n revert(add(32, reason), mload(reason))\n }\n }\n }\n } else {\n return true;\n }\n }\n\n /**\n * @dev Hook that is called before any token transfer. This includes minting\n * and burning.\n *\n * Calling conditions:\n *\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\n * transferred to `to`.\n * - When `from` is zero, `tokenId` will be minted for `to`.\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n *\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n */\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\n uint256[44] private __gap;\n}\n" + }, + "@openzeppelin/contracts/utils/Counters.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @title Counters\n * @author Matt Condon (@shrugs)\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\n *\n * Include with `using Counters for Counters.Counter;`\n */\nlibrary Counters {\n struct Counter {\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\n // this feature: see https://github.com/ethereum/solidity/issues/4637\n uint256 _value; // default: 0\n }\n\n function current(Counter storage counter) internal view returns (uint256) {\n return counter._value;\n }\n\n function increment(Counter storage counter) internal {\n unchecked {\n counter._value += 1;\n }\n }\n\n function decrement(Counter storage counter) internal {\n uint256 value = counter._value;\n require(value > 0, \"Counter: decrement overflow\");\n unchecked {\n counter._value = value - 1;\n }\n }\n}\n" + }, + "@openzeppelin/contracts/utils/math/SafeMath.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n// CAUTION\n// This version of SafeMath should only be used with Solidity 0.8 or later,\n// because it relies on the compiler's built in overflow checks.\n\n/**\n * @dev Wrappers over Solidity's arithmetic operations.\n *\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\n * now has built in overflow checking.\n */\nlibrary SafeMath {\n /**\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\n *\n * _Available since v3.4._\n */\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n uint256 c = a + b;\n if (c < a) return (false, 0);\n return (true, c);\n }\n }\n\n /**\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\n *\n * _Available since v3.4._\n */\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b > a) return (false, 0);\n return (true, a - b);\n }\n }\n\n /**\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\n *\n * _Available since v3.4._\n */\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n // benefit is lost if 'b' is also tested.\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n if (a == 0) return (true, 0);\n uint256 c = a * b;\n if (c / a != b) return (false, 0);\n return (true, c);\n }\n }\n\n /**\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\n *\n * _Available since v3.4._\n */\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b == 0) return (false, 0);\n return (true, a / b);\n }\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\n *\n * _Available since v3.4._\n */\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b == 0) return (false, 0);\n return (true, a % b);\n }\n }\n\n /**\n * @dev Returns the addition of two unsigned integers, reverting on\n * overflow.\n *\n * Counterpart to Solidity's `+` operator.\n *\n * Requirements:\n *\n * - Addition cannot overflow.\n */\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\n return a + b;\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, reverting on\n * overflow (when the result is negative).\n *\n * Counterpart to Solidity's `-` operator.\n *\n * Requirements:\n *\n * - Subtraction cannot overflow.\n */\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n return a - b;\n }\n\n /**\n * @dev Returns the multiplication of two unsigned integers, reverting on\n * overflow.\n *\n * Counterpart to Solidity's `*` operator.\n *\n * Requirements:\n *\n * - Multiplication cannot overflow.\n */\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n return a * b;\n }\n\n /**\n * @dev Returns the integer division of two unsigned integers, reverting on\n * division by zero. The result is rounded towards zero.\n *\n * Counterpart to Solidity's `/` operator.\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\n return a / b;\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n * reverting when dividing by zero.\n *\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n return a % b;\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n * overflow (when the result is negative).\n *\n * CAUTION: This function is deprecated because it requires allocating memory for the error\n * message unnecessarily. For custom revert reasons use {trySub}.\n *\n * Counterpart to Solidity's `-` operator.\n *\n * Requirements:\n *\n * - Subtraction cannot overflow.\n */\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n unchecked {\n require(b <= a, errorMessage);\n return a - b;\n }\n }\n\n /**\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\n * division by zero. The result is rounded towards zero.\n *\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Counterpart to Solidity's `/` operator. Note: this function uses a\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\n * uses an invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n unchecked {\n require(b > 0, errorMessage);\n return a / b;\n }\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n * reverting with custom message when dividing by zero.\n *\n * CAUTION: This function is deprecated because it requires allocating memory for the error\n * message unnecessarily. For custom revert reasons use {tryMod}.\n *\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n unchecked {\n require(b > 0, errorMessage);\n return a % b;\n }\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../../utils/introspection/IERC165Upgradeable.sol\";\n\n/**\n * @dev Required interface of an ERC721 compliant contract.\n */\ninterface IERC721Upgradeable is IERC165Upgradeable {\n /**\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\n */\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n\n /**\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\n */\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n\n /**\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\n */\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n /**\n * @dev Returns the number of tokens in ``owner``'s account.\n */\n function balanceOf(address owner) external view returns (uint256 balance);\n\n /**\n * @dev Returns the owner of the `tokenId` token.\n *\n * Requirements:\n *\n * - `tokenId` must exist.\n */\n function ownerOf(uint256 tokenId) external view returns (address owner);\n\n /**\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must exist and be owned by `from`.\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n *\n * Emits a {Transfer} event.\n */\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\n\n /**\n * @dev Transfers `tokenId` token from `from` to `to`.\n *\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must be owned by `from`.\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address from, address to, uint256 tokenId) external;\n\n /**\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\n * The approval is cleared when the token is transferred.\n *\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\n *\n * Requirements:\n *\n * - The caller must own the token or be an approved operator.\n * - `tokenId` must exist.\n *\n * Emits an {Approval} event.\n */\n function approve(address to, uint256 tokenId) external;\n\n /**\n * @dev Returns the account approved for `tokenId` token.\n *\n * Requirements:\n *\n * - `tokenId` must exist.\n */\n function getApproved(uint256 tokenId) external view returns (address operator);\n\n /**\n * @dev Approve or remove `operator` as an operator for the caller.\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\n *\n * Requirements:\n *\n * - The `operator` cannot be the caller.\n *\n * Emits an {ApprovalForAll} event.\n */\n function setApprovalForAll(address operator, bool _approved) external;\n\n /**\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\n *\n * See {setApprovalForAll}\n */\n function isApprovedForAll(address owner, address operator) external view returns (bool);\n\n /**\n * @dev Safely transfers `tokenId` token from `from` to `to`.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must exist and be owned by `from`.\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n *\n * Emits a {Transfer} event.\n */\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @title ERC721 token receiver interface\n * @dev Interface for any contract that wants to support safeTransfers\n * from ERC721 asset contracts.\n */\ninterface IERC721ReceiverUpgradeable {\n /**\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\n * by `operator` from `from`, this function is called.\n *\n * It must return its Solidity selector to confirm the token transfer.\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\n *\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\n */\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC721Upgradeable.sol\";\n\n/**\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\n * @dev See https://eips.ethereum.org/EIPS/eip-721\n */\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\n\n /**\n * @dev Returns the token collection name.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the token collection symbol.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\n */\n function tokenURI(uint256 tokenId) external view returns (string memory);\n}\n" + }, + "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary AddressUpgradeable {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize, which returns 0 for contracts in\n // construction, since the code is only stored at the end of the\n // constructor execution.\n\n uint256 size;\n // solhint-disable-next-line no-inline-assembly\n assembly { size := extcodesize(account) }\n return size > 0;\n }\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\n (bool success, ) = recipient.call{ value: amount }(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain`call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCall(target, data, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n require(isContract(target), \"Address: call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\n return _verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\n require(isContract(target), \"Address: static call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.staticcall(data);\n return _verifyCallResult(success, returndata, errorMessage);\n }\n\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\n if (success) {\n return returndata;\n } else {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n }\n}\n" + }, + "contracts/contexts2/access-control/storage.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nstruct AccessControlStorage {\n mapping(bytes32 => mapping(address => bool)) roles;\n mapping(address => address) owners;\n mapping(bytes32 => bool) entered;\n}\n\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\n \"teller.access_control.storage\"\n);\n\nlibrary AccessControlStorageLib {\n function store() internal pure returns (AccessControlStorage storage s) {\n bytes32 pos = ACCESS_CONTROL_POS;\n assembly {\n s.slot := pos\n }\n }\n}\n" + }, + "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev These functions deal with verification of Merkle Trees proofs.\n *\n * The proofs can be generated using the JavaScript library\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\n *\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\n */\nlibrary MerkleProof {\n /**\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\n * defined by `root`. For this, a `proof` must be provided, containing\n * sibling hashes on the branch from the leaf to the root of the tree. Each\n * pair of leaves and each pair of pre-images are assumed to be sorted.\n */\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\n bytes32 computedHash = leaf;\n\n for (uint256 i = 0; i < proof.length; i++) {\n bytes32 proofElement = proof[i];\n\n if (computedHash <= proofElement) {\n // Hash(current computed hash + current element of the proof)\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\n } else {\n // Hash(current element of the proof + current computed hash)\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\n }\n }\n\n // Check if the computed hash (root) is equal to the provided root\n return computedHash == root;\n }\n}\n" + }, + "contracts/storage/app.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { TellerNFT } from \"../nft/TellerNFT.sol\";\n\n// Interfaces\n\n// Libraries\nimport {\n PlatformSetting\n} from \"../settings/platform/libraries/PlatformSettingsLib.sol\";\nimport { Cache } from \"../shared/libraries/CacheLib.sol\";\nimport {\n UpgradeableBeaconFactory\n} from \"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\";\n\nstruct AppStorage {\n // is it initialized\n bool initialized;\n // is it platform restricted\n bool platformRestricted;\n // mapping between contract IDs and if they're paused\n mapping(bytes32 => bool) paused;\n //p\n mapping(bytes32 => PlatformSetting) platformSettings;\n mapping(address => Cache) assetSettings;\n mapping(string => address) assetAddresses;\n mapping(address => bool) cTokenRegistry;\n TellerNFT nft;\n UpgradeableBeaconFactory loansEscrowBeacon;\n UpgradeableBeaconFactory collateralEscrowBeacon;\n address nftLiquidationController;\n UpgradeableBeaconFactory tTokenBeacon;\n}\n\nlibrary AppStorageLib {\n function store() internal pure returns (AppStorage storage s) {\n assembly {\n s.slot := 0\n }\n }\n}\n" + }, + "contracts/storage/nft.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../nft/TellerNFTDictionary.sol\";\n\n// Utils\nimport \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\nstruct NFTStorage {\n // Maps NFT owner to set of token IDs owned\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\n // Maps loanID to NFT IDs indicating NFT being used for the loan\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\n // Merkle root used for verifying nft IDs to base loan size\n TellerNFTDictionary nftDictionary;\n}\n\nbytes32 constant NFT_STORAGE_POS = keccak256(\"teller.staking.storage\");\n\nlibrary NFTStorageLib {\n function store() internal pure returns (NFTStorage storage s) {\n bytes32 pos = NFT_STORAGE_POS;\n assembly {\n s.slot := pos\n }\n }\n}\n" + }, + "contracts/settings/platform/libraries/PlatformSettingsLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AppStorageLib } from \"../../../storage/app.sol\";\nimport \"../names.sol\" as NAMES;\nimport {\n RolesMods\n} from \"../../../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN, AUTHORIZED } from \"../../../shared/roles.sol\";\nimport { RolesLib } from \"../../../contexts2/access-control/roles/RolesLib.sol\";\n\n// It defines a platform settings. It includes: value, min, and max values.\nstruct PlatformSetting {\n uint256 value;\n uint256 min;\n uint256 max;\n bool exists;\n}\n\n/**\n * @notice Utility library of inline functions on the PlatformSetting struct.\n *\n * @author develop@teller.finance\n */\nlibrary PlatformSettingsLib {\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\n return AppStorageLib.store().platformSettings[name];\n }\n\n /**\n * @notice It gets the current \"NFTInterestRate\" setting's value\n * @return value_ the current value.\n */\n function getNFTInterestRate() internal view returns (uint16 value_) {\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\n }\n\n /**\n * @notice It gets the current \"RequiredSubmissionsPercentage\" setting's value\n * @return value_ the current value.\n */\n function getRequiredSubmissionsPercentageValue()\n internal\n view\n returns (uint256 value_)\n {\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\n }\n\n /**\n * @notice It gets the current \"MaximumTolerance\" setting's value\n * @return value_ the current value.\n */\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\n }\n\n /**\n * @notice It gets the current \"ResponseExpiryLength\" setting's value\n * @return value_ the current value.\n */\n function getResponseExpiryLengthValue()\n internal\n view\n returns (uint256 value_)\n {\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\n }\n\n /**\n * @notice It gets the current \"SafetyInterval\" setting's value\n * @return value_ the current value.\n */\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\n value_ = s(NAMES.SAFETY_INTERVAL).value;\n }\n\n /**\n * @notice It gets the current \"TermsExpiryTime\" setting's value\n * @return value_ the current value.\n */\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\n }\n\n /**\n * @notice It gets the current \"LiquidateRewardPercent\" setting's value\n * @return value_ the current value.\n */\n function getLiquidateRewardPercent()\n internal\n view\n returns (uint256 value_)\n {\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\n }\n\n /**\n * @notice It gets the current \"MaximumLoanDuration\" setting's value\n * @return value_ the current value.\n */\n function getMaximumLoanDurationValue()\n internal\n view\n returns (uint256 value_)\n {\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\n }\n\n /**\n * @notice It gets the current \"RequestLoanTermsRateLimit\" setting's value\n * @return value_ the current value.\n */\n function getRequestLoanTermsRateLimitValue()\n internal\n view\n returns (uint256 value_)\n {\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\n }\n\n /**\n * @notice It gets the current \"CollateralBuffer\" setting's value\n * @return value_ the current value.\n */\n function getCollateralBufferValue() internal view returns (uint256 value_) {\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\n }\n\n /**\n * @notice It gets the current \"OverCollateralizedBuffer\" setting's value\n * @return value_ the current value.\n */\n function getOverCollateralizedBufferValue()\n internal\n view\n returns (uint256 value_)\n {\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\n }\n}\n" + }, + "contracts/shared/libraries/CacheLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nenum CacheType { Address, Uint, Int, Byte, Bool }\n\n/**\n * @notice This struct manages the cache of the library instance.\n * @param addresses A mapping of address values mapped to cache keys in bytes.\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\n * @param ints A mapping of int values mapped to cache keys names in bytes.\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\n */\nstruct Cache {\n // Mapping of cache keys names to address values.\n mapping(bytes32 => address) addresses;\n // Mapping of cache keys names to uint256 values.\n mapping(bytes32 => uint256) uints;\n // Mapping of cache keys names to int256 values.\n mapping(bytes32 => int256) ints;\n // Mapping of cache keys names to bytes32 values.\n mapping(bytes32 => bytes32) bites;\n // Mapping of cache keys names to bool values.\n mapping(bytes32 => bool) bools;\n}\n\nlibrary CacheLib {\n // The constant for the initialization check\n bytes32 private constant INITIALIZED = keccak256(\"Initialized\");\n\n /**\n * @notice Initializes the cache instance.\n * @param cache The current cache\n */\n function initialize(Cache storage cache) internal {\n requireNotExists(cache);\n cache.bools[INITIALIZED] = true;\n }\n\n /**\n * @notice Checks whether the current cache does not, throwing an error if it does.\n * @param cache The current cache\n */\n function requireNotExists(Cache storage cache) internal view {\n require(!exists(cache), \"CACHE_ALREADY_EXISTS\");\n }\n\n /**\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\n * @param cache The current cache\n */\n function requireExists(Cache storage cache) internal view {\n require(exists(cache), \"CACHE_DOES_NOT_EXIST\");\n }\n\n /**\n * @notice Tests whether the current cache exists or not.\n * @param cache The current cache.\n * @return bool True if the cache exists.\n */\n function exists(Cache storage cache) internal view returns (bool) {\n return cache.bools[INITIALIZED];\n }\n\n /**\n * @notice it updates the cache with a key, value and cache type\n * @param cache cache to update\n * @param key the memory reference to the value in bytes32\n * @param value the value to update at the key\n * @param cacheType the enum type of cache to update\n */\n function update(\n Cache storage cache,\n bytes32 key,\n bytes32 value,\n CacheType cacheType\n ) internal {\n requireExists(cache);\n\n assembly {\n mstore(0, value)\n }\n if (cacheType == CacheType.Address) {\n address addr;\n assembly {\n addr := mload(0)\n }\n cache.addresses[key] = addr;\n } else if (cacheType == CacheType.Uint) {\n uint256 ui;\n assembly {\n ui := mload(0)\n }\n cache.uints[key] = ui;\n } else if (cacheType == CacheType.Int) {\n int256 i;\n assembly {\n i := mload(0)\n }\n cache.ints[key] = i;\n } else if (cacheType == CacheType.Byte) {\n cache.bites[key] = value;\n } else if (cacheType == CacheType.Bool) {\n bool b;\n assembly {\n b := mload(0)\n }\n cache.bools[key] = b;\n }\n }\n\n /**\n * @notice it deletes the cache values at the specified key\n * @param cache the cache to delete keys from\n * @param keysToClear the keys to delete\n * @param keyTypes the types of keys to target different parts of the cache\n */\n function clearCache(\n Cache storage cache,\n bytes32[5] memory keysToClear,\n CacheType[5] memory keyTypes\n ) internal {\n requireExists(cache);\n require(\n keysToClear.length == keyTypes.length,\n \"ARRAY_LENGTHS_MISMATCH\"\n );\n for (uint256 i; i <= keysToClear.length; i++) {\n if (keyTypes[i] == CacheType.Address) {\n delete cache.addresses[keysToClear[i]];\n } else if (keyTypes[i] == CacheType.Uint) {\n delete cache.uints[keysToClear[i]];\n } else if (keyTypes[i] == CacheType.Int) {\n delete cache.ints[keysToClear[i]];\n } else if (keyTypes[i] == CacheType.Byte) {\n delete cache.bites[keysToClear[i]];\n } else if (keyTypes[i] == CacheType.Bool) {\n delete cache.bools[keysToClear[i]];\n }\n }\n }\n}\n" + }, + "contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/proxy/Clones.sol\";\nimport \"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\";\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\nimport \"@openzeppelin/contracts/utils/Address.sol\";\nimport \"./InitializeableBeaconProxy.sol\";\n\n/**\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\n * implementation contract, which is where they will delegate all function calls.\n *\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\n */\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\n address private _implementation;\n InitializeableBeaconProxy public proxyAddress;\n\n /**\n * @dev Emitted when the implementation returned by the beacon is changed.\n */\n event Upgraded(address indexed implementation);\n\n /**\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\n * beacon.\n */\n constructor(address payable proxyAddress_, address implementation_) {\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\n _setImplementation(implementation_);\n }\n\n /**\n * @dev Returns the current implementation address.\n */\n function implementation() public view virtual override returns (address) {\n return _implementation;\n }\n\n /**\n * @notice it clones the proxy contract at an address\n * @param initData the data to initialize after the proxy is cloned\n * @return proxy_ the cloned proxy\n */\n function cloneProxy(bytes memory initData)\n external\n returns (address payable proxy_)\n {\n proxy_ = payable(Clones.clone(address(proxyAddress)));\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\n }\n\n /**\n * @dev Upgrades the beacon to a new implementation.\n *\n * Emits an {Upgraded} event.\n *\n * Requirements:\n *\n * - msg.sender must be the owner of the contract.\n * - `newImplementation` must be a contract.\n */\n function upgradeTo(address newImplementation) public virtual onlyOwner {\n _setImplementation(newImplementation);\n emit Upgraded(newImplementation);\n }\n\n /**\n * @dev Sets the implementation contract address for this beacon\n *\n * Requirements:\n *\n * - `newImplementation` must be a contract.\n */\n function _setImplementation(address newImplementation) private {\n require(\n Address.isContract(newImplementation),\n \"UpgradeableBeacon: implementation is not a contract\"\n );\n _implementation = newImplementation;\n }\n}\n" + }, + "contracts/settings/platform/names.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/**\n @dev The setting name for loans taken out with an NFT.\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\n */\nbytes32 constant NFT_INTEREST_RATE = keccak256(\"NFTInterestRate\");\n\n/**\n @dev The setting name for the required subsmission settings.\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\n */\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\n \"RequiredSubmissionsPercentage\"\n);\n\n/**\n @dev The setting name for the maximum tolerance settings.\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\n @dev This is a percentage value with 2 decimal places.\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\n @dev The max value is 100% => 10000\n */\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\"MaximumTolerance\");\n/**\n @dev The setting name for the response expiry length settings.\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\n */\n\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\"ResponseExpiryLength\");\n\n/**\n @dev The setting name for the safety interval settings.\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\n */\nbytes32 constant SAFETY_INTERVAL = keccak256(\"SafetyInterval\");\n\n/**\n @dev The setting name for the term expiry time settings.\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\n */\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\"TermsExpiryTime\");\n\n/**\n @dev The setting name for the liquidation reward percent setting.\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\n i.e. an ETH liquidation price at 5% is stored as 500\n */\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\"LiquidateRewardPercent\");\n\n/**\n @dev The setting name for the maximum loan duration settings.\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\n */\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\"MaximumLoanDuration\");\n\n/**\n @dev The setting name for the request loan terms rate limit settings.\n @dev The request loan terms rate limit setting is defined in seconds.\n */\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\n \"RequestLoanTermsRateLimit\"\n);\n\n/**\n @dev The setting name for the collateral buffer.\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\n e.g.: collateral buffer at 100% is stored as 10000.\n */\nbytes32 constant COLLATERAL_BUFFER = keccak256(\"CollateralBuffer\");\n\n/**\n @dev The setting name for the over collateralized buffer.\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\n e.g.: over collateralized buffer at 130% is stored as 13000.\n */\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\n \"OverCollateralizedBuffer\"\n);\n" + }, + "@openzeppelin/contracts/proxy/Clones.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\n * deploying minimal proxy contracts, also known as \"clones\".\n *\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\n *\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\n * deterministic method.\n *\n * _Available since v3.4._\n */\nlibrary Clones {\n /**\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\n *\n * This function uses the create opcode, which should never revert.\n */\n function clone(address implementation) internal returns (address instance) {\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let ptr := mload(0x40)\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\n mstore(add(ptr, 0x14), shl(0x60, implementation))\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\n instance := create(0, ptr, 0x37)\n }\n require(instance != address(0), \"ERC1167: create failed\");\n }\n\n /**\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\n *\n * This function uses the create2 opcode and a `salt` to deterministically deploy\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\n * the clones cannot be deployed twice at the same address.\n */\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let ptr := mload(0x40)\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\n mstore(add(ptr, 0x14), shl(0x60, implementation))\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\n instance := create2(0, ptr, 0x37, salt)\n }\n require(instance != address(0), \"ERC1167: create2 failed\");\n }\n\n /**\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\n */\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let ptr := mload(0x40)\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\n mstore(add(ptr, 0x14), shl(0x60, implementation))\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\n mstore(add(ptr, 0x38), shl(0x60, deployer))\n mstore(add(ptr, 0x4c), salt)\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\n predicted := keccak256(add(ptr, 0x37), 0x55)\n }\n }\n\n /**\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\n */\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\n return predictDeterministicAddress(implementation, salt, address(this));\n }\n}\n" + }, + "@openzeppelin/contracts/proxy/beacon/IBeacon.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\n */\ninterface IBeacon {\n /**\n * @dev Must return an address that can be used as a delegate call target.\n *\n * {BeaconProxy} will check that this address is a contract.\n */\n function implementation() external view returns (address);\n}\n" + }, + "@openzeppelin/contracts/access/Ownable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n address private _owner;\n\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Initializes the contract setting the deployer as the initial owner.\n */\n constructor () {\n address msgSender = _msgSender();\n _owner = msgSender;\n emit OwnershipTransferred(address(0), msgSender);\n }\n\n /**\n * @dev Returns the address of the current owner.\n */\n function owner() public view virtual returns (address) {\n return _owner;\n }\n\n /**\n * @dev Throws if called by any account other than the owner.\n */\n modifier onlyOwner() {\n require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n _;\n }\n\n /**\n * @dev Leaves the contract without owner. It will not be possible to call\n * `onlyOwner` functions anymore. Can only be called by the current owner.\n *\n * NOTE: Renouncing ownership will leave the contract without an owner,\n * thereby removing any functionality that is only available to the owner.\n */\n function renounceOwnership() public virtual onlyOwner {\n emit OwnershipTransferred(_owner, address(0));\n _owner = address(0);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) public virtual onlyOwner {\n require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n emit OwnershipTransferred(_owner, newOwner);\n _owner = newOwner;\n }\n}\n" + }, + "@openzeppelin/contracts/utils/Address.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize, which returns 0 for contracts in\n // construction, since the code is only stored at the end of the\n // constructor execution.\n\n uint256 size;\n // solhint-disable-next-line no-inline-assembly\n assembly { size := extcodesize(account) }\n return size > 0;\n }\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\n (bool success, ) = recipient.call{ value: amount }(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain`call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCall(target, data, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n require(isContract(target), \"Address: call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\n return _verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\n require(isContract(target), \"Address: static call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.staticcall(data);\n return _verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\n require(isContract(target), \"Address: delegate call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return _verifyCallResult(success, returndata, errorMessage);\n }\n\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\n if (success) {\n return returndata;\n } else {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n }\n}\n" + }, + "contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\";\nimport \"@openzeppelin/contracts/proxy/Proxy.sol\";\nimport \"@openzeppelin/contracts/utils/Address.sol\";\n\n/**\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\n *\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\n * conflict with the storage layout of the implementation behind the proxy.\n *\n * _Available since v3.4._\n */\ncontract InitializeableBeaconProxy is Proxy {\n /**\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\n */\n bytes32 private constant _BEACON_SLOT =\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\n\n /**\n * @dev Initializes the proxy with `beacon`.\n *\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\n * constructor.\n *\n * Requirements:\n *\n * - `beacon` must be a contract with the interface {IBeacon}.\n */\n function initialize(address beacon, bytes memory data) external payable {\n assert(\n _BEACON_SLOT ==\n bytes32(uint256(keccak256(\"eip1967.proxy.beacon\")) - 1)\n );\n require(_beacon() == address(0), \"Beacon: already initialized\");\n\n _setBeacon(beacon, data);\n }\n\n /**\n * @dev Returns the current beacon address.\n */\n function _beacon() internal view virtual returns (address beacon) {\n bytes32 slot = _BEACON_SLOT;\n // solhint-disable-next-line no-inline-assembly\n assembly {\n beacon := sload(slot)\n }\n }\n\n /**\n * @dev Returns the current implementation address of the associated beacon.\n */\n function _implementation()\n internal\n view\n virtual\n override\n returns (address)\n {\n return IBeacon(_beacon()).implementation();\n }\n\n /**\n * @dev Changes the proxy to use a new beacon.\n *\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\n *\n * Requirements:\n *\n * - `beacon` must be a contract.\n * - The implementation returned by `beacon` must be a contract.\n */\n function _setBeacon(address beacon, bytes memory data) internal virtual {\n bytes32 slot = _BEACON_SLOT;\n\n // solhint-disable-next-line no-inline-assembly\n assembly {\n sstore(slot, beacon)\n }\n\n if (data.length > 0) {\n Address.functionDelegateCall(\n _implementation(),\n data,\n \"BeaconProxy: function call failed\"\n );\n }\n }\n\n receive() external payable override {\n // Needed to receive ETH without data\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\n }\n}\n" + }, + "@openzeppelin/contracts/utils/Context.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/*\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\n return msg.data;\n }\n}\n" + }, + "@openzeppelin/contracts/proxy/Proxy.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\n * be specified by overriding the virtual {_implementation} function.\n *\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\n * different contract through the {_delegate} function.\n *\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\n */\nabstract contract Proxy {\n /**\n * @dev Delegates the current call to `implementation`.\n *\n * This function does not return to its internall call site, it will return directly to the external caller.\n */\n function _delegate(address implementation) internal virtual {\n // solhint-disable-next-line no-inline-assembly\n assembly {\n // Copy msg.data. We take full control of memory in this inline assembly\n // block because it will not return to Solidity code. We overwrite the\n // Solidity scratch pad at memory position 0.\n calldatacopy(0, 0, calldatasize())\n\n // Call the implementation.\n // out and outsize are 0 because we don't know the size yet.\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\n\n // Copy the returned data.\n returndatacopy(0, 0, returndatasize())\n\n switch result\n // delegatecall returns 0 on error.\n case 0 { revert(0, returndatasize()) }\n default { return(0, returndatasize()) }\n }\n }\n\n /**\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\n * and {_fallback} should delegate.\n */\n function _implementation() internal view virtual returns (address);\n\n /**\n * @dev Delegates the current call to the address returned by `_implementation()`.\n *\n * This function does not return to its internall call site, it will return directly to the external caller.\n */\n function _fallback() internal virtual {\n _beforeFallback();\n _delegate(_implementation());\n }\n\n /**\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\n * function in the contract matches the call data.\n */\n fallback () external payable virtual {\n _fallback();\n }\n\n /**\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\n * is empty.\n */\n receive () external payable virtual {\n _fallback();\n }\n\n /**\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\n * call, or as part of the Solidity `fallback` or `receive` functions.\n *\n * If overriden should call `super._beforeFallback()`.\n */\n function _beforeFallback() internal virtual {\n }\n}\n" + }, + "contracts/shared/interfaces/ITellerDiamond.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { IDiamondCut } from \"./IDiamondCut.sol\";\nimport { IDiamondLoupe } from \"./IDiamondLoupe.sol\";\n\nimport { SettingsFacet } from \"../../settings/SettingsFacet.sol\";\nimport {\n PlatformSettingsFacet\n} from \"../../settings/platform/PlatformSettingsFacet.sol\";\nimport {\n AssetSettingsDataFacet\n} from \"../../settings/asset/AssetSettingsDataFacet.sol\";\nimport {\n AssetSettingsFacet\n} from \"../../settings/asset/AssetSettingsFacet.sol\";\nimport { PausableFacet } from \"../../settings/pausable/PausableFacet.sol\";\nimport { PriceAggFacet } from \"../../price-aggregator/PriceAggFacet.sol\";\nimport {\n ChainlinkAggFacet\n} from \"../../price-aggregator/chainlink/ChainlinkAggFacet.sol\";\nimport { LendingFacet } from \"../../lending/LendingFacet.sol\";\nimport { CreateLoanFacet } from \"../../market/CreateLoanFacet.sol\";\nimport { LoanDataFacet } from \"../../market/LoanDataFacet.sol\";\nimport { RepayFacet } from \"../../market/RepayFacet.sol\";\nimport { SignersFacet } from \"../../market/SignersFacet.sol\";\nimport { NFTFacet } from \"../../nft/NFTFacet.sol\";\nimport { CollateralFacet } from \"../../market/CollateralFacet.sol\";\nimport { CompoundFacet } from \"../../escrow/dapps/CompoundFacet.sol\";\nimport { UniswapFacet } from \"../../escrow/dapps/UniswapFacet.sol\";\n\nabstract contract ITellerDiamond is\n SettingsFacet,\n PlatformSettingsFacet,\n AssetSettingsDataFacet,\n AssetSettingsFacet,\n PausableFacet,\n PriceAggFacet,\n ChainlinkAggFacet,\n LendingFacet,\n CollateralFacet,\n CreateLoanFacet,\n LoanDataFacet,\n RepayFacet,\n SignersFacet,\n NFTFacet,\n CompoundFacet,\n UniswapFacet,\n IDiamondCut,\n IDiamondLoupe\n{}\n" + }, + "contracts/shared/interfaces/IDiamondCut.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/******************************************************************************\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\n/******************************************************************************/\n\ninterface IDiamondCut {\n enum FacetCutAction { Add, Replace, Remove }\n\n struct FacetCut {\n address facetAddress;\n FacetCutAction action;\n bytes4[] functionSelectors;\n }\n\n /// @notice Add/replace/remove any number of functions and optionally execute\n /// a function with delegatecall\n /// @param _diamondCut Contains the facet addresses and function selectors\n /// @param _init The address of the contract or facet to execute _calldata\n /// @param _calldata A function call, including function selector and arguments\n /// _calldata is executed with delegatecall on _init\n function diamondCut(\n FacetCut[] calldata _diamondCut,\n address _init,\n bytes calldata _calldata\n ) external;\n\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\n}\n" + }, + "contracts/shared/interfaces/IDiamondLoupe.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// A loupe is a small magnifying glass used to look at diamonds.\n// These functions look at diamonds\ninterface IDiamondLoupe {\n /// These functions are expected to be called frequently\n /// by tools.\n\n struct Facet {\n address facetAddress;\n bytes4[] functionSelectors;\n }\n\n /// @notice Gets all facet addresses and their four byte function selectors.\n /// @return facets_ Facet\n function facets() external view returns (Facet[] memory facets_);\n\n /// @notice Gets all the function selectors supported by a specific facet.\n /// @param _facet The facet address.\n /// @return facetFunctionSelectors_\n function facetFunctionSelectors(address _facet)\n external\n view\n returns (bytes4[] memory facetFunctionSelectors_);\n\n /// @notice Get all the facet addresses used by a diamond.\n /// @return facetAddresses_\n function facetAddresses()\n external\n view\n returns (address[] memory facetAddresses_);\n\n /// @notice Gets the facet that supports the given selector.\n /// @dev If facet is not found return address(0).\n /// @param _functionSelector The function selector.\n /// @return facetAddress_ The facet address.\n function facetAddress(bytes4 _functionSelector)\n external\n view\n returns (address facetAddress_);\n}\n" + }, + "contracts/settings/SettingsFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN, PAUSER, AUTHORIZED } from \"../shared/roles.sol\";\nimport {\n UpgradeableBeaconFactory\n} from \"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\";\nimport { TellerNFT } from \"../nft/TellerNFT.sol\";\n\n// Interfaces\nimport { IUniswapV2Router } from \"../shared/interfaces/IUniswapV2Router.sol\";\n\n// Libraries\nimport { RolesLib } from \"../contexts2/access-control/roles/RolesLib.sol\";\n\n// Storage\nimport { AppStorageLib, AppStorage } from \"../storage/app.sol\";\n\nstruct InitAssets {\n string sym;\n address addr;\n}\n\nstruct InitArgs {\n address admin;\n InitAssets[] assets;\n address[] cTokens;\n address tellerNFT;\n address loansEscrowBeacon;\n address collateralEscrowBeacon;\n address tTokenBeacon;\n address nftLiquidationController;\n}\n\ncontract SettingsFacet is RolesMods {\n /**\n * @notice This event is emitted when the platform restriction is switched\n * @param restriction Boolean representing the state of the restriction\n * @param pauser address of the pauser flipping the switch\n */\n event PlatformRestricted(bool restriction, address indexed pauser);\n\n /**\n * @notice Restricts the use of the Teller protocol to authorized wallet addresses only\n * @param restriction Bool turning the resitriction on or off\n */\n function restrictPlatform(bool restriction)\n internal\n authorized(ADMIN, msg.sender)\n {\n AppStorageLib.store().platformRestricted = restriction;\n emit PlatformRestricted(restriction, msg.sender);\n }\n\n /**\n * @notice Adds a wallet address to the list of authorized wallets\n * @param account The wallet address of the user being authorized\n */\n function addAuthorizedAddress(address account)\n external\n authorized(ADMIN, msg.sender)\n {\n RolesLib.grantRole(AUTHORIZED, account);\n }\n\n /**\n * @notice Adds a list of wallet addresses to the list of authorized wallets\n * @param addressesToAdd The list of wallet addresses being authorized\n */\n function addAuthorizedAddressList(address[] calldata addressesToAdd)\n external\n authorized(ADMIN, msg.sender)\n {\n for (uint256 i; i < addressesToAdd.length; i++) {\n RolesLib.grantRole(AUTHORIZED, addressesToAdd[i]);\n }\n }\n\n /**\n * @notice Removes a wallet address from the list of authorized wallets\n * @param account The wallet address of the user being unauthorized\n */\n function removeAuthorizedAddress(address account)\n external\n authorized(ADMIN, msg.sender)\n {\n RolesLib.revokeRole(AUTHORIZED, account);\n }\n\n /**\n * @notice Tests whether an account has authorization\n * @param account The account address to check for\n * @return True if account has authorization, false if it does not\n */\n function hasAuthorization(address account) external view returns (bool) {\n return RolesLib.hasRole(AUTHORIZED, account);\n }\n\n /**\n * @notice Sets a new address to which NFTs should be sent when used for taking out a loan and gets liquidated.\n * @param newController The address where NFTs should be transferred.\n */\n function setNFTLiquidationController(address newController)\n external\n authorized(ADMIN, msg.sender)\n {\n AppStorageLib.store().nftLiquidationController = newController;\n }\n\n /**\n * @notice Gets the new address where NFTs are sent when used for taking out a loan and gets liquidated.\n * @return controller_ The address where NFTs are be transferred.\n */\n function getNFTLiquidationController()\n external\n returns (address controller_)\n {\n controller_ = AppStorageLib.store().nftLiquidationController;\n }\n\n /**\n * @notice it stores multiple parameters in the AppStorageLib\n * @param _args multiple arguments that are stored in the AppStorageLibrary\n */\n function init(InitArgs calldata _args) external {\n AppStorage storage s = AppStorageLib.store();\n\n if (s.initialized) return;\n s.initialized = true;\n\n RolesLib.grantRole(ADMIN, _args.admin);\n RolesLib.grantRole(PAUSER, _args.admin);\n\n for (uint256 i; i < _args.assets.length; i++) {\n s.assetAddresses[_args.assets[i].sym] = _args.assets[i].addr;\n }\n for (uint256 i; i < _args.cTokens.length; i++) {\n s.cTokenRegistry[_args.cTokens[i]] = true;\n }\n\n s.nft = TellerNFT(_args.tellerNFT);\n s.loansEscrowBeacon = UpgradeableBeaconFactory(_args.loansEscrowBeacon);\n s.collateralEscrowBeacon = UpgradeableBeaconFactory(\n _args.collateralEscrowBeacon\n );\n s.tTokenBeacon = UpgradeableBeaconFactory(_args.tTokenBeacon);\n s.nftLiquidationController = _args.nftLiquidationController;\n }\n}\n" + }, + "contracts/settings/platform/PlatformSettingsFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN, AUTHORIZED } from \"../../shared/roles.sol\";\n\n// Libraries\nimport {\n PlatformSettingsLib,\n PlatformSetting\n} from \"./libraries/PlatformSettingsLib.sol\";\nimport { AppStorageLib } from \"../../storage/app.sol\";\n\n// Storage\nimport { AppStorageLib, AppStorage } from \"../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions on the PlatformSetting struct.\n *\n * @author develop@teller.finance\n */\ncontract PlatformSettingsFacet is RolesMods {\n /**\n * @notice This event is emitted when a new platform setting is created.\n * @param settingName New setting name.\n * @param sender Address that created it.\n * @param value Value for the new setting.\n * @param minValue Minimum boundary for the new setting.\n * @param maxValue Maximum boundary for the new setting.\n */\n event PlatformSettingCreated(\n bytes32 indexed settingName,\n address indexed sender,\n uint256 value,\n uint256 minValue,\n uint256 maxValue\n );\n\n /**\n * @notice This event is emitted when a platform setting is updated.\n * @param settingName Keccak'ed settings name.\n * @param sender Address that updated it.\n * @param oldValue Previous value for the setting.\n * @param newValue New value for the setting.\n */\n event PlatformSettingUpdated(\n bytes32 indexed settingName,\n address indexed sender,\n uint256 oldValue,\n uint256 newValue\n );\n\n /**\n * @notice This event is emitted when a current platform setting is removed.\n * @param settingName setting name removed.\n * @param sender address that removed it.\n * @param oldMin Previous minimum boundary.\n * @param oldMax Previous minimum boundary.\n * @param newMin New minimum boundary.\n * @param newMax New maximum boundary.\n */\n event PlatformSettingBoundariesUpdated(\n bytes32 indexed settingName,\n address indexed sender,\n uint256 oldMin,\n uint256 oldMax,\n uint256 newMin,\n uint256 newMax\n );\n\n /**\n * @notice Gets the values for a platform setting name.\n * @param name The keccak'ed name for a setting.\n * @return setting_ Values for the setting {name}\n */\n function getPlatformSetting(bytes32 name)\n external\n view\n returns (PlatformSetting memory setting_)\n {\n setting_ = PlatformSettingsLib.s(name);\n }\n\n /**\n * @notice It creates a new platform setting given a name, min and max values.\n * @param name Keccak'ed name for the setting.\n * @param value Initial value for the setting.\n * @param min Minimum value allowed for the setting.\n * @param max Maximum value allowed for the setting.\n */\n function createPlatformSetting(\n bytes32 name,\n uint256 value,\n uint256 min,\n uint256 max\n ) external authorized(ADMIN, msg.sender) {\n require(\n !PlatformSettingsLib.s(name).exists,\n \"Teller: platform setting already exists\"\n );\n require(value >= min, \"Teller: platform setting value less than min\");\n require(\n value <= max,\n \"Teller: platform setting value greater than max\"\n );\n\n PlatformSettingsLib.s(name).value = value;\n PlatformSettingsLib.s(name).min = min;\n PlatformSettingsLib.s(name).max = max;\n PlatformSettingsLib.s(name).exists = true;\n\n emit PlatformSettingCreated(name, msg.sender, value, min, max);\n }\n\n /**\n * @notice It updates a current platform setting.\n * @param name Keccak'ed name for the setting.\n * @param newValue the new value to set in the platform setting.\n *\n * Requirements:\n * - New value is equal to the current value.\n * - New value is grater than the max value.\n * - New value is less than the min value\n */\n function updatePlatformSetting(bytes32 name, uint256 newValue)\n external\n authorized(ADMIN, msg.sender)\n returns (uint256 oldValue)\n {\n require(\n PlatformSettingsLib.s(name).exists,\n \"Teller: platform setting not exists\"\n );\n require(\n PlatformSettingsLib.s(name).value != newValue,\n \"Teller: new platform setting not different\"\n );\n require(\n newValue >= PlatformSettingsLib.s(name).min,\n \"Teller: new platform setting less than min\"\n );\n require(\n newValue <= PlatformSettingsLib.s(name).max,\n \"Teller: new platform setting greater than max\"\n );\n\n oldValue = PlatformSettingsLib.s(name).value;\n PlatformSettingsLib.s(name).value = newValue;\n\n emit PlatformSettingUpdated(name, msg.sender, oldValue, newValue);\n }\n\n /**\n * @notice Updates the boundary (min & max) values for a platform setting.\n * @param name Keccak'ed name for the setting.\n * @param min New minimum boundary for the setting.\n * @param max New maximum boundary for the setting.\n */\n function updatePlatformSettingBoundaries(\n bytes32 name,\n uint256 min,\n uint256 max\n ) external authorized(ADMIN, msg.sender) {\n require(\n PlatformSettingsLib.s(name).exists,\n \"Teller: platform setting not exists\"\n );\n\n emit PlatformSettingBoundariesUpdated(\n name,\n msg.sender,\n PlatformSettingsLib.s(name).min,\n PlatformSettingsLib.s(name).max,\n min,\n max\n );\n\n PlatformSettingsLib.s(name).min = min;\n PlatformSettingsLib.s(name).max = max;\n }\n}\n" + }, + "contracts/settings/asset/AssetSettingsDataFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN, AUTHORIZED } from \"../../shared/roles.sol\";\n\n// Interfaces\nimport { ICErc20 } from \"../../shared/interfaces/ICErc20.sol\";\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../shared/libraries/CacheLib.sol\";\nimport { AssetCTokenLib } from \"./libraries/AssetCTokenLib.sol\";\nimport { MaxLoanAmountLib } from \"./libraries/MaxLoanAmountLib.sol\";\nimport { MaxTVLLib } from \"./libraries/MaxTVLLib.sol\";\n\n// Storage\nimport { AppStorageLib, AppStorage } from \"../../storage/app.sol\";\n\n/**\n * @notice View function to get asset setting values.\n *\n * @author develop@teller.finance\n */\ncontract AssetSettingsDataFacet {\n /**\n * @notice it gets the asset's max loan amount\n * @param asset the address of the asset\n * @return the max loan amount\n */\n function getAssetMaxLoanAmount(address asset)\n external\n view\n returns (uint256)\n {\n return MaxLoanAmountLib.get(asset);\n }\n\n /**\n * @notice it gets the maxTVL of an asset\n * @param asset the address of the asset\n * @return it returns the maxTVL\n */\n function getAssetMaxTVL(address asset) external view returns (uint256) {\n return MaxTVLLib.get(asset);\n }\n\n /**\n * @notice it returns the asset's cToken\n * @param asset the address of the asset\n * @return the cToken of an asset\n */\n function getAssetCToken(address asset) external view returns (ICErc20) {\n return AssetCTokenLib.get(asset);\n }\n}\n" + }, + "contracts/settings/asset/AssetSettingsFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN, AUTHORIZED } from \"../../shared/roles.sol\";\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../shared/libraries/CacheLib.sol\";\nimport { MaxTVLLib } from \"./libraries/MaxTVLLib.sol\";\n\n// Storage\nimport { AppStorageLib, AppStorage } from \"../../storage/app.sol\";\n\nstruct AssetSettingRequest {\n bytes32 key;\n bytes32 value;\n CacheType cacheType;\n}\n\ncontract AssetSettingsFacet is RolesMods {\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n event AssetSettingsCreated(\n address indexed asset,\n bytes32 indexed key,\n bytes32 value,\n CacheType cacheType\n );\n\n event AssetSettingsUpdated(\n address indexed asset,\n bytes32 indexed key,\n bytes32 value,\n CacheType cacheType\n );\n\n /**\n * @notice it checks if the settings of an asset is initialized\n * @param asset the address of the asset\n * @return bool to check if settings of an asset exists\n */\n function isAssetSettingInitialized(address asset)\n external\n view\n returns (bool)\n {\n return CacheLib.exists(s(asset));\n }\n\n /**\n * @notice it gets the MaxTVL amount of an asset\n * @param asset the address of the asset\n * @return the max TVL amount\n */\n function getMaxTVLAmount(address asset) external view returns (uint256) {\n return MaxTVLLib.get(asset);\n }\n\n /**\n * @notice It creates an asset settings with the given parameters.\n * @param asset the address to create settings for\n * @param requests the multiple settings to update the asset with \n */\n function createAssetSetting(\n address asset,\n AssetSettingRequest[] calldata requests\n ) external authorized(ADMIN, msg.sender) {\n require(asset != address(0), \"Teller: asset address required\");\n\n CacheLib.initialize(s(asset));\n\n for (uint256 i; i < requests.length; i++) {\n CacheLib.update(\n s(asset),\n requests[i].key,\n requests[i].value,\n requests[i].cacheType\n );\n\n emit AssetSettingsCreated(\n asset,\n requests[i].key,\n requests[i].value,\n requests[i].cacheType\n );\n }\n }\n\n /**\n * @notice It updates an asset with the given parameter\n * @param asset the address of the asset to update\n * @param request the setting to update the asset with\n */\n function updateAssetSetting(\n address asset,\n AssetSettingRequest calldata request\n ) external authorized(ADMIN, msg.sender) {\n require(\n CacheLib.exists(s(asset)),\n \"Teller: asset setting does not exists\"\n );\n\n CacheLib.update(\n s(asset),\n request.key,\n request.value,\n request.cacheType\n );\n\n emit AssetSettingsUpdated(\n asset,\n request.key,\n request.value,\n request.cacheType\n );\n }\n}\n" + }, + "contracts/settings/pausable/PausableFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../../contexts2/access-control/roles/RolesMods.sol\";\nimport { PAUSER } from \"../../shared/roles.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../storage/app.sol\";\n\ncontract PausableFacet is RolesMods {\n /**\n * @dev Emitted when an {id} is paused by {sender}.\n */\n event Paused(bytes32 indexed id, address sender);\n\n /**\n * @dev Emitted when an {id} is unpaused by {sender}.\n */\n event UnPaused(bytes32 indexed id, address sender);\n\n /**\n * @notice Puts an id in the given state.\n * @dev A blank id (\"\") is equivalent to the whole protocol. If a specific facet should be paused, pass its encoded id.\n * @param id Encoded id of a facet to {pause}.\n * @param state The new state that {id} should be in.\n *\n * Requirements:\n * - Sender must have the PAUSER role.\n */\n function pause(bytes32 id, bool state)\n external\n authorized(PAUSER, msg.sender)\n {\n if (isPaused(id) == state) return;\n AppStorageLib.store().paused[id] = state;\n if (state) {\n emit Paused(id, msg.sender);\n } else {\n emit UnPaused(id, msg.sender);\n }\n }\n\n /**\n * @notice Checks if an id is paused.\n * @dev A blank id (\"\") is equivalent to the whole protocol. If a specific facet should be paused, pass its encoded id.\n * @param id Encoded id of a facet to {pause}.\n * @return The state that {id} is in.\n */\n function isPaused(bytes32 id) public view returns (bool) {\n return AppStorageLib.store().paused[id];\n }\n}\n" + }, + "contracts/price-aggregator/PriceAggFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport { SafeCast } from \"@openzeppelin/contracts/utils/math/SafeCast.sol\";\nimport { ChainlinkLib } from \"./chainlink/ChainlinkLib.sol\";\nimport { CompoundLib } from \"../shared/libraries/CompoundLib.sol\";\n\n// Interfaces\nimport {\n AggregatorV2V3Interface\n} from \"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\";\nimport { ERC20 } from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../storage/app.sol\";\n\ncontract PriceAggFacet {\n uint256 internal constant TEN = 10;\n\n /**\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\n * @param src Source token address.\n * @param dst Destination token address.\n * @return int256 The latest answer as given from Chainlink.\n */\n function getPriceFor(address src, address dst)\n external\n view\n returns (int256)\n {\n return _priceFor(src, dst);\n }\n\n /**\n * @notice It calculates the value of a token amount into another.\n * @param src Source token address.\n * @param dst Destination token address.\n * @param srcAmount Amount of the source token to convert into the destination token.\n * @return uint256 Value of the source token amount in destination tokens.\n */\n function getValueFor(\n address src,\n address dst,\n uint256 srcAmount\n ) external view returns (uint256) {\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\n }\n\n function _valueFor(\n address src,\n uint256 amount,\n uint256 exchangeRate\n ) internal view returns (uint256) {\n return (amount * exchangeRate) / _oneToken(src);\n }\n\n /**\n * @notice it returns 10^{numberOfDecimals} for a token\n * @param token the address to calculate the decimals for\n * @return 10^number of decimals used to calculate the price and value of different token pairs\n */\n function _oneToken(address token) internal view returns (uint256) {\n return TEN**_decimalsFor(token);\n }\n\n /**\n * @notice It gets the number of decimals for a given token.\n * @param addr Token address to get decimals for.\n * @return uint8 Number of decimals the given token.\n */\n function _decimalsFor(address addr) internal view returns (uint8) {\n return ERC20(addr).decimals();\n }\n\n /**\n * @notice it tries to calculate a price from Compound and Chainlink.\n * @dev if no price is found on compound, then calculate it on chainlink\n * @param src the token address to calculate the price for in dst\n * @param dst the token address to retrieve the price of src\n * @return price_ the price of src in dst\n */\n function _priceFor(address src, address dst)\n private\n view\n returns (int256 price_)\n {\n // If no Compound route, try Chainlink directly.\n price_ = int256(_compoundPriceFor(src, dst));\n if (price_ == 0) {\n price_ = _chainlinkPriceFor(src, dst);\n if (price_ == 0) {\n revert(\"Teller: cannot calc price\");\n }\n }\n }\n\n /**\n * @notice Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\n * @param src the address of the src token\n * @param dst the address of the dst token\n * @return the price of the src token in dst token\n\n */\n function _compoundPriceFor(address src, address dst)\n private\n view\n returns (uint256)\n {\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\n if (isSrcCompound) {\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\n if (srcUnderlying == dst) {\n return cRate;\n } else {\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\n }\n } else {\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\n if (isDstCompound) {\n uint256 cRate =\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\n if (dstUnderlying == src) {\n return cRate;\n } else {\n return\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\n }\n }\n }\n\n return 0;\n }\n\n /**\n * @notice Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\n * @param src the source token to calculate price for with chainlink\n * @param dst the destination token to calculate price for with chainlink\n * @param cRate the compound rate to multiply with the price of the dst token\n * @return the price of src in dst after scaling the difference in decimal values\n */\n function _calcPriceFromCompoundRate(\n address src,\n address dst,\n uint256 cRate\n ) private view returns (uint256) {\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\n uint256 value = (cRate * _oneToken(dst)) / rate;\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\n }\n\n /**\n * @notice Scales the {value} by the difference in decimal values.\n * @param value the the value of the src in dst\n * @param srcDecimals src token decimals\n * @param dstDecimals dst token decimals\n * @return the price of src in dst after scaling the difference in decimal values\n */\n function _scale(\n uint256 value,\n uint256 srcDecimals,\n uint256 dstDecimals\n ) internal pure returns (uint256) {\n if (dstDecimals > srcDecimals) {\n return value * (TEN**(dstDecimals - srcDecimals));\n } else {\n return value / (TEN**(srcDecimals - dstDecimals));\n }\n }\n\n /**\n * @notice it tries to calculate the price of {src} in {dst}\n * @param src address of source token\n * @param dst address of destination token\n * @return the price of src token in dst\n */\n function _chainlinkPriceFor(address src, address dst)\n private\n view\n returns (int256)\n {\n (address agg, bool foundAgg, bool inverse) =\n ChainlinkLib.aggregatorFor(src, dst);\n if (foundAgg) {\n uint256 price =\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\n if (inverse) {\n price = (TEN**(resDecimals + resDecimals)) / price;\n }\n return\n SafeCast.toInt256(\n (_scale(price, resDecimals, _decimalsFor(dst)))\n );\n } else {\n address WETH = AppStorageLib.store().assetAddresses[\"WETH\"];\n if (dst != WETH) {\n int256 price1 = _priceFor(src, WETH);\n if (price1 > 0) {\n int256 price2 = _priceFor(dst, WETH);\n if (price2 > 0) {\n uint256 dstFactor = TEN**_decimalsFor(dst);\n return (price1 * int256(dstFactor)) / price2;\n }\n }\n }\n }\n\n return 0;\n }\n\n /**\n * @notice it checks if a token is a cToken. If it is, then get the underlying address\n * @param token address of the token\n * @return isCToken boolean whether it's a cToken\n * @return underlying the address of the cToken\n */\n function _isCToken(address token)\n private\n view\n returns (bool isCToken, address underlying)\n {\n isCToken = CompoundLib.isCompoundToken(token);\n if (isCToken) {\n underlying = CompoundLib.getUnderlying(token);\n }\n }\n}\n" + }, + "contracts/price-aggregator/chainlink/ChainlinkAggFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN } from \"../../shared/roles.sol\";\n\n// Libraries\nimport { Address } from \"@openzeppelin/contracts/utils/Address.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\nimport { ChainlinkLib } from \"./ChainlinkLib.sol\";\n\n// Storage\nimport {\n PriceAggStorageLib,\n PriceAggStorage\n} from \"../../storage/price-aggregator.sol\";\n\ncontract ChainlinkAggFacet is RolesMods {\n /**\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\n * @param src Source token address.\n * @param dst Destination token address.\n * @return agg The Chainlink Aggregator address.\n * @return found whether or not the ChainlinkAggregator exists.\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\n */\n function getChainlinkAggregatorFor(address src, address dst)\n external\n view\n returns (\n address agg,\n bool found,\n bool inverse\n )\n {\n (agg, found, inverse) = ChainlinkLib.aggregatorFor(src, dst);\n }\n\n /**\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\n * @param token Token address to check if is supported.\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\n */\n function isChainlinkTokenSupported(address token)\n external\n view\n returns (bool)\n {\n return ChainlinkLib.isTokenSupported(token);\n }\n\n /**\n * @notice It allows for additional Chainlink Aggregators to be supported.\n * @param src Source token address.\n * @param dst Destination token address.\n * @param aggregator Price aggregator address.\n */\n function addChainlinkAggregator(\n address src,\n address dst,\n address aggregator\n ) external authorized(ADMIN, msg.sender) {\n (, bool found, ) = ChainlinkLib.aggregatorFor(src, dst);\n require(!found, \"Teller: chainlink aggregator already exists\");\n require(Address.isContract(src), \"Teller: source token not contract\");\n require(\n Address.isContract(dst),\n \"Teller: destination token not contract\"\n );\n require(\n Address.isContract(aggregator),\n \"Teller: chainlink aggregator not contract\"\n );\n\n // Store now aggregator\n ChainlinkLib.s().aggregators[src][dst] = aggregator;\n // Make sure token addresses are known to be supported\n EnumerableSet.add(ChainlinkLib.s().supportedTokens, src);\n EnumerableSet.add(ChainlinkLib.s().supportedTokens, dst);\n // Increment token pair counts\n ChainlinkLib.s().pairCount[src]++;\n ChainlinkLib.s().pairCount[dst]++;\n }\n\n /**\n * @notice It removes support for a Chainlink Aggregator pair.\n * @param src Source token address.\n * @param dst Destination token address.\n */\n function removeChainlinkAggregator(address src, address dst)\n external\n authorized(ADMIN, msg.sender)\n {\n (, bool found, ) = ChainlinkLib.aggregatorFor(src, dst);\n if (!found) {\n return;\n }\n\n // Delete aggregator storage\n delete ChainlinkLib.s().aggregators[src][dst];\n // Decrement token pair counts\n ChainlinkLib.s().pairCount[src]--;\n ChainlinkLib.s().pairCount[dst]--;\n // Remove token support if token pair length is 0\n if (ChainlinkLib.s().pairCount[src] == 0) {\n EnumerableSet.remove(ChainlinkLib.s().supportedTokens, src);\n }\n if (ChainlinkLib.s().pairCount[dst] == 0) {\n EnumerableSet.remove(ChainlinkLib.s().supportedTokens, dst);\n }\n }\n}\n" + }, + "contracts/lending/LendingFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { PausableMods } from \"../settings/pausable/PausableMods.sol\";\nimport {\n ReentryMods\n} from \"../contexts2/access-control/reentry/ReentryMods.sol\";\nimport { RolesMods } from \"../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN, AUTHORIZED } from \"../shared/roles.sol\";\n\n// Interfaces\nimport { ITToken } from \"./ttoken/ITToken.sol\";\n\n// Libraries\nimport {\n IERC20,\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport {\n SafeERC20Upgradeable\n} from \"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\";\nimport { MaxTVLLib } from \"../settings/asset/libraries/MaxTVLLib.sol\";\nimport { LendingLib } from \"./libraries/LendingLib.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../storage/app.sol\";\n\ncontract LendingFacet is RolesMods, ReentryMods, PausableMods {\n /**\n * @notice This event is emitted when a new lending pool is initialized.\n * @param sender address.\n * @param asset Token address the pool was initialized for.\n */\n event LendingPoolInitialized(address indexed sender, address asset);\n\n /**\n * @notice Get the Teller Token address for an underlying asset.\n * @param asset Address to get a Teller Token for.\n */\n function getTTokenFor(address asset)\n external\n view\n returns (address tToken_)\n {\n tToken_ = address(LendingLib.tToken(asset));\n }\n\n /**\n * @notice It allows users to deposit tokens into the pool.\n * @dev the user must call ERC20.approve function previously.\n * @dev If the cToken is available (not 0x0), it deposits the lending asset amount into Compound directly.\n * @param asset Token address to deposit into the lending pool.\n * @param amount Amount of {asset} to deposit in the pool.\n */\n function lendingPoolDeposit(address asset, uint256 amount)\n external\n paused(LendingLib.ID, false)\n authorized(AUTHORIZED, msg.sender)\n nonReentry(LendingLib.ID)\n {\n ITToken tToken = LendingLib.tToken(asset);\n require(\n address(tToken) != address(0),\n \"Teller: lending pool not initialized\"\n );\n\n require(\n tToken.currentTVL() + amount <= MaxTVLLib.get(asset),\n \"Teller: deposit TVL exceeded\"\n );\n\n // Transfer tokens from lender\n SafeERC20.safeTransferFrom(\n IERC20(asset),\n msg.sender,\n address(this),\n amount\n );\n // Set allowance for Teller token to pull funds to mint\n SafeERC20.safeIncreaseAllowance(IERC20(asset), address(tToken), amount);\n // Mint Teller tokens, then transfer to lender\n SafeERC20Upgradeable.safeTransfer(\n tToken,\n msg.sender,\n // Minting returns the amount of Teller tokens minted\n tToken.mint(amount)\n );\n }\n\n /**\n * @notice It initializes a new lending pool for the respective token\n * @param asset Token address to initialize the lending pool for.\n */\n function initLendingPool(address asset)\n external\n authorized(ADMIN, msg.sender)\n {\n require(\n address(LendingLib.tToken(asset)) == address(0),\n \"Teller: lending pool already initialized\"\n );\n\n // Create a new Teller Token\n address tToken = AppStorageLib.store().tTokenBeacon.cloneProxy(\"\");\n // Set the Teller Token to the asset mapping\n LendingLib.s().tTokens[asset] = ITToken(tToken);\n // Initialize the Teller Token\n LendingLib.s().tTokens[asset].initialize(msg.sender, asset);\n\n // Emit event\n emit LendingPoolInitialized(msg.sender, asset);\n }\n}\n" + }, + "contracts/market/CreateLoanFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { PausableMods } from \"../settings/pausable/PausableMods.sol\";\nimport {\n ReentryMods\n} from \"../contexts2/access-control/reentry/ReentryMods.sol\";\nimport { RolesMods } from \"../contexts2/access-control/roles/RolesMods.sol\";\nimport { AUTHORIZED } from \"../shared/roles.sol\";\nimport { ERC20 } from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\n\n// Libraries\nimport { LibLoans } from \"./libraries/LibLoans.sol\";\nimport { LibCollateral } from \"./libraries/LibCollateral.sol\";\nimport { LibConsensus } from \"./libraries/LibConsensus.sol\";\nimport { LendingLib } from \"../lending/libraries/LendingLib.sol\";\nimport {\n PlatformSettingsLib\n} from \"../settings/platform/libraries/PlatformSettingsLib.sol\";\nimport {\n MaxDebtRatioLib\n} from \"../settings/asset/libraries/MaxDebtRatioLib.sol\";\nimport {\n MaxLoanAmountLib\n} from \"../settings/asset/libraries/MaxLoanAmountLib.sol\";\nimport { Counters } from \"@openzeppelin/contracts/utils/Counters.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\nimport { NumbersLib } from \"../shared/libraries/NumbersLib.sol\";\nimport { NFTLib } from \"../nft/libraries/NFTLib.sol\";\n\n// Interfaces\nimport { ILoansEscrow } from \"../escrow/escrow/ILoansEscrow.sol\";\nimport { ITToken } from \"../lending/ttoken/ITToken.sol\";\n\n// Proxy\nimport {\n BeaconProxy\n} from \"@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol\";\nimport { Clones } from \"@openzeppelin/contracts/proxy/Clones.sol\";\n\n// Storage\nimport {\n LoanRequest,\n LoanStatus,\n LoanTerms,\n Loan,\n MarketStorageLib\n} from \"../storage/market.sol\";\nimport { AppStorageLib } from \"../storage/app.sol\";\n\ncontract CreateLoanFacet is RolesMods, ReentryMods, PausableMods {\n /**\n * @notice This event is emitted when a loan has been successfully taken out\n * @param loanID ID of loan from which collateral was withdrawn\n * @param borrower Account address of the borrower\n * @param amountBorrowed Total amount taken out in the loan\n * @param withNFT Boolean indicating if the loan was taken out using NFTs\n */\n event LoanTakenOut(\n uint256 indexed loanID,\n address indexed borrower,\n uint256 amountBorrowed,\n bool withNFT\n );\n\n /**\n * @notice Creates the loan from requests and validator responses then calling the main function.\n * @param request Struct of the protocol loan request\n */\n modifier __createLoan(LoanRequest calldata request, bool withNFT) {\n Loan storage loan = CreateLoanLib.createLoan(request, withNFT);\n\n _;\n\n loan.status = LoanStatus.Active;\n loan.loanStartTime = uint32(block.timestamp);\n loan.duration = request.request.duration;\n }\n\n /**\n * @notice Creates a loan with the loan request and NFTs without any collateral\n * @param request Struct of the protocol loan request\n * @param nftIDs IDs of TellerNFTs to use for the loan\n */\n function takeOutLoanWithNFTs(\n LoanRequest calldata request,\n uint16[] calldata nftIDs\n ) external paused(LibLoans.ID, false) __createLoan(request, true) {\n // Get the ID of the newly created loan\n uint256 loanID = CreateLoanLib.currentID() - 1;\n uint256 amount = LibLoans.loan(loanID).borrowedAmount;\n uint8 lendingDecimals = ERC20(request.request.assetAddress).decimals();\n\n uint256 allowedBaseLoanSize;\n for (uint256 i; i < nftIDs.length; i++) {\n NFTLib.applyToLoan(loanID, nftIDs[i]);\n\n allowedBaseLoanSize += NFTLib.s().nftDictionary.tokenBaseLoanSize(\n nftIDs[i]\n );\n }\n require(\n amount <= allowedBaseLoanSize * (10**lendingDecimals),\n \"Teller: insufficient NFT loan size\"\n );\n\n // Pull funds from Teller Token LP and transfer to the new loan escrow\n LendingLib.tToken(LibLoans.loan(loanID).lendingToken).fundLoan(\n CreateLoanLib.createEscrow(loanID),\n amount\n );\n\n emit LoanTakenOut(\n loanID,\n msg.sender,\n LibLoans.loan(loanID).borrowedAmount,\n true\n );\n }\n\n /**\n * @notice Take out a loan\n *\n * @dev collateral ratio is a percentage of the loan amount that's required in collateral\n * @dev the percentage will be *(10**2). I.e. collateralRatio of 5244 means 52.44% collateral\n * @dev is required in the loan. Interest rate is also a percentage with 2 decimal points.\n *\n * @param request Struct of the protocol loan request\n * @param collateralToken Token address to use as collateral for the new loan\n * @param collateralAmount Amount of collateral required for the loan\n */\n function takeOutLoan(\n LoanRequest calldata request,\n address collateralToken,\n uint256 collateralAmount\n )\n external\n payable\n paused(LibLoans.ID, false)\n nonReentry(\"\")\n authorized(AUTHORIZED, msg.sender)\n __createLoan(request, false)\n {\n // Check if collateral token is zero\n require(\n collateralToken != address(0x0),\n \"Teller: token addr can't be 0\"\n );\n\n // Verify collateral token is acceptable\n require(\n EnumerableSet.contains(\n MarketStorageLib.store().collateralTokens[\n request.request.assetAddress\n ],\n collateralToken\n ),\n \"Teller: collateral token not allowed\"\n );\n\n // Get the ID of the newly created loan\n Loan storage loan = LibLoans.loan(CreateLoanLib.currentID() - 1);\n\n // Save collateral token to loan\n loan.collateralToken = collateralToken;\n\n // Pay in collateral\n if (collateralAmount > 0) {\n LibCollateral.deposit(loan.id, collateralAmount);\n }\n\n // Check that enough collateral has been provided for this loan\n require(\n LibLoans.getCollateralNeeded(loan.id) <=\n LibCollateral.e(loan.id).loanSupply(loan.id),\n \"Teller: more collateral required\"\n );\n // Pull funds from Teller token LP and and transfer to the recipient\n ITToken tToken = LendingLib.tToken(request.request.assetAddress);\n\n tToken.fundLoan(\n LibLoans.canGoToEOAWithCollateralRatio(loan.collateralRatio)\n ? loan.borrower\n : CreateLoanLib.createEscrow(loan.id),\n loan.borrowedAmount\n );\n\n emit LoanTakenOut(loan.id, msg.sender, loan.borrowedAmount, false);\n }\n}\n\nlibrary CreateLoanLib {\n function createLoan(LoanRequest calldata request, bool withNFT)\n internal\n returns (Loan storage loan)\n {\n // Perform loan request checks\n require(\n msg.sender == request.request.borrower,\n \"Teller: not loan requester\"\n );\n require(\n PlatformSettingsLib.getMaximumLoanDurationValue() >=\n request.request.duration,\n \"Teller: max loan duration exceeded\"\n );\n\n // Get consensus values from request\n (uint16 interestRate, uint16 collateralRatio, uint256 maxLoanAmount) =\n LibConsensus.processLoanTerms(request);\n\n // Perform loan value checks\n require(\n MaxLoanAmountLib.get(request.request.assetAddress) > maxLoanAmount,\n \"Teller: asset max loan amount exceeded\"\n );\n require(\n LendingLib.tToken(request.request.assetAddress).debtRatioFor(\n maxLoanAmount\n ) <= MaxDebtRatioLib.get(request.request.assetAddress),\n \"Teller: max supply-to-debt ratio exceeded\"\n );\n\n // Get and increment new loan ID\n uint256 loanID = CreateLoanLib.newID();\n // Set loan data based on terms\n loan = LibLoans.loan(loanID);\n loan.id = uint128(loanID);\n loan.status = LoanStatus.TermsSet;\n loan.lendingToken = request.request.assetAddress;\n loan.borrower = request.request.borrower;\n loan.borrowedAmount = maxLoanAmount;\n if (withNFT) {\n loan.interestRate = PlatformSettingsLib.getNFTInterestRate();\n } else {\n loan.interestRate = interestRate;\n loan.collateralRatio = collateralRatio;\n }\n\n // Set loan debt\n LibLoans.debt(loanID).principalOwed = maxLoanAmount;\n LibLoans.debt(loanID).interestOwed = LibLoans.getInterestOwedFor(\n uint256(loanID),\n maxLoanAmount\n );\n\n // Add loanID to borrower list\n MarketStorageLib.store().borrowerLoans[loan.borrower].push(\n uint128(loanID)\n );\n }\n\n /**\n * @notice increments the loanIDCounter\n * @return id_ the new ID requested, which stores it in the loan data\n */\n function newID() internal returns (uint256 id_) {\n Counters.Counter storage counter =\n MarketStorageLib.store().loanIDCounter;\n id_ = Counters.current(counter);\n Counters.increment(counter);\n }\n\n function currentID() internal view returns (uint256 id_) {\n Counters.Counter storage counter =\n MarketStorageLib.store().loanIDCounter;\n id_ = Counters.current(counter);\n }\n\n /**\n * @notice it creates a new loan escrow contract\n * @param loanID the ID that identifies the loan\n * @return escrow_ the loanEscrow that gets created\n */\n function createEscrow(uint256 loanID) internal returns (address escrow_) {\n // Create escrow\n escrow_ = AppStorageLib.store().loansEscrowBeacon.cloneProxy(\"\");\n ILoansEscrow(escrow_).init();\n // Save escrow address for loan\n MarketStorageLib.store().loanEscrows[loanID] = ILoansEscrow(escrow_);\n }\n}\n" + }, + "contracts/market/LoanDataFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport { LibLoans } from \"./libraries/LibLoans.sol\";\nimport { LibEscrow } from \"../escrow/libraries/LibEscrow.sol\";\n\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\n// Storage\nimport { Loan, LoanDebt, LoanTerms } from \"../storage/market.sol\";\n\ncontract LoanDataFacet {\n /**\n * @notice Returns the information about the given {loanID}.\n * @param loanID The loan ID to get information for.\n * @return loan_ The loan data.\n */\n function getLoan(uint256 loanID) external view returns (Loan memory loan_) {\n loan_ = LibLoans.s().loans[loanID];\n }\n\n /**\n * @notice DEPRECATED\n * @notice Returns the terms for a specified loan.\n * @param loanID The loan ID to get the total amount owed.\n * @return LoanTerms The terms that the loan weer created with.\n */\n function getLoanTerms(uint256 loanID)\n external\n view\n returns (LoanTerms memory)\n {\n return LibLoans.terms(loanID);\n }\n\n /**\n * @notice Returns the loan IDs created by the {borrower} account.\n * @param borrower The account to get loan IDs for.\n * @return loanIDs The IDs for loans created by the {borrower}\n */\n function getBorrowerLoans(address borrower)\n external\n view\n returns (uint128[] memory loanIDs)\n {\n return LibLoans.s().borrowerLoans[borrower];\n }\n\n /**\n * @notice Returns the debt owed for a specified loan.\n * @param loanID The loan ID to get the total amount owed.\n * @return LoanDebt The principal and interest owed amount.\n */\n function getDebtOwed(uint256 loanID)\n external\n view\n returns (LoanDebt memory)\n {\n return LibLoans.debt(loanID);\n }\n\n /**\n * @notice Returns the total amount owed for a specified loan.\n * @param loanID The loan ID to get the total amount owed.\n * @return uint256 The total owed amount.\n */\n function getTotalOwed(uint256 loanID) external view returns (uint256) {\n return LibLoans.getTotalOwed(loanID);\n }\n\n /**\n * @notice Returns the amount of interest owed for a given loan and loan amount.\n * @param loanID The loan ID to get the owed interest.\n * @param amountBorrow The principal of the loan to take out.\n * @return uint256 The interest owed.\n */\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\n external\n view\n returns (uint256)\n {\n return LibLoans.getInterestOwedFor(loanID, amountBorrow);\n }\n\n /**\n * @notice it returns the collateral needed for a loan\n * @param loanID the identifier of the loan ID to retrieve collateral from\n * @return neededInLendingTokens total collateral needed in lending tokens\n * @return neededInCollateralTokens total collateral needed in collateral tokens\n * @return escrowLoanValue total collateral needed in loan value\n */\n function getCollateralNeededInfo(uint256 loanID)\n external\n view\n returns (\n uint256 neededInLendingTokens,\n uint256 neededInCollateralTokens,\n uint256 escrowLoanValue\n )\n {\n return LibLoans.getCollateralNeededInfo(loanID);\n }\n\n /**\n * @notice it returns the typed address of a loan escrow\n * @param loanID the identifier of the respective escrow's loan\n * @return escrow_ the typed address of the returned ILoanEscrow\n */\n function getLoanEscrow(uint256 loanID)\n external\n view\n returns (address escrow_)\n {\n escrow_ = address(LibLoans.s().loanEscrows[loanID]);\n }\n\n /**\n * @notice it returns the escrow's total value by calculating the value all the escrow tokens\n * @param loanID the identifier of the respective escrow's loan\n * @return the total value of the loan escrow\n */\n function getLoanEscrowValue(uint256 loanID)\n external\n view\n returns (uint256)\n {\n return LibEscrow.calculateTotalValue(loanID);\n }\n\n /**\n * @notice it returns the total escrow tokens held by an escrow\n * @param loanID the identifier of the respective escrow's loan\n * @return tokens_ the tokens held at the escrow loan \n */\n function getEscrowTokens(uint256 loanID)\n external\n view\n returns (address[] memory tokens_)\n {\n EnumerableSet.AddressSet storage escrowTokens =\n LibEscrow.getEscrowTokens(loanID);\n tokens_ = new address[](EnumerableSet.length(escrowTokens));\n for (uint256 i; i < tokens_.length; i++) {\n tokens_[i] = EnumerableSet.at(escrowTokens, i);\n }\n }\n}\n" + }, + "contracts/market/RepayFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../contexts2/access-control/roles/RolesMods.sol\";\nimport { PausableMods } from \"../settings/pausable/PausableMods.sol\";\nimport {\n ReentryMods\n} from \"../contexts2/access-control/reentry/ReentryMods.sol\";\nimport { AUTHORIZED } from \"../shared/roles.sol\";\nimport { LoanDataFacet } from \"./LoanDataFacet.sol\";\nimport { EscrowClaimTokens } from \"../escrow/EscrowClaimTokens.sol\";\n\n// Libraries\nimport {\n IERC20,\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\nimport { LibLoans } from \"./libraries/LibLoans.sol\";\nimport { LibCollateral } from \"./libraries/LibCollateral.sol\";\nimport { LibDapps } from \"../escrow/dapps/libraries/LibDapps.sol\";\nimport { LibEscrow } from \"../escrow/libraries/LibEscrow.sol\";\nimport {\n PlatformSettingsLib\n} from \"../settings/platform/libraries/PlatformSettingsLib.sol\";\nimport { NumbersLib } from \"../shared/libraries/NumbersLib.sol\";\nimport { PriceAggLib } from \"../price-aggregator/PriceAggLib.sol\";\nimport { NFTLib } from \"../nft/libraries/NFTLib.sol\";\n\n// Interfaces\nimport { ITToken } from \"../lending/ttoken/ITToken.sol\";\nimport { ILoansEscrow } from \"../escrow/escrow/ILoansEscrow.sol\";\n\n// Storage\nimport {\n MarketStorageLib,\n MarketStorage,\n Loan,\n LoanStatus\n} from \"../storage/market.sol\";\n\ncontract RepayFacet is RolesMods, ReentryMods, PausableMods, EscrowClaimTokens {\n /**\n @notice This event is emitted when a loan has been successfully repaid\n @param loanID ID of loan from which collateral was withdrawn\n @param borrower Account address of the borrower\n @param amountPaid Amount of the loan paid back\n @param payer Account address of the payer\n @param totalOwed Total amount of the loan to be repaid\n */\n event LoanRepaid(\n uint256 indexed loanID,\n address indexed borrower,\n uint256 amountPaid,\n address payer,\n uint256 totalOwed\n );\n\n /**\n * @notice This event is emitted when a loan has been successfully liquidated\n * @param loanID ID of loan from which collateral was withdrawn\n * @param borrower Account address of the borrower\n * @param liquidator Account address of the liquidator\n * @param reward Value in lending token paid out to liquidator\n * @param tokensIn Percentage of the collateral price paid by the liquidator to the lending pool\n */\n event LoanLiquidated(\n uint256 indexed loanID,\n address indexed borrower,\n address liquidator,\n uint256 reward,\n uint256 tokensIn\n );\n\n /**\n * @notice Repay this Escrow's loan.\n * @dev If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.\n * @dev Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\n * @param loanID The id of the loan being used.\n * @param amount The amount being repaid.\n */\n function escrowRepay(uint256 loanID, uint256 amount)\n external\n paused(\"\", false)\n authorized(AUTHORIZED, msg.sender)\n nonReentry(\"\")\n {\n uint256 balance =\n LibEscrow.balanceOf(loanID, LibLoans.loan(loanID).lendingToken);\n uint256 totalOwed = LibLoans.getTotalOwed(loanID);\n // if there isn't enough balance in the escrow, then transfer amount needed to the escrow\n if (balance < totalOwed && amount > balance) {\n uint256 amountNeeded =\n amount > totalOwed ? totalOwed - (balance) : amount - (balance);\n\n SafeERC20.safeTransferFrom(\n IERC20(LibLoans.loan(loanID).lendingToken),\n msg.sender,\n address(LibEscrow.e(loanID)),\n amountNeeded\n );\n }\n\n __repayLoan(loanID, amount, address(LibEscrow.e(loanID)), false);\n }\n\n /**\n * @notice Make a payment to a loan\n * @param loanID The ID of the loan the payment is for\n * @param amount The amount of tokens to pay back to the loan\n */\n function repayLoan(uint256 loanID, uint256 amount)\n external\n nonReentry(\"\")\n paused(\"\", false)\n authorized(AUTHORIZED, msg.sender)\n {\n __repayLoan(loanID, amount, msg.sender, false);\n }\n\n /**\n * @notice it repays the loan, either from an escrow or from a regular address\n * @param loanID the identifier of the loan to repay\n * @param amount the amount to repay the loan\n * @param sender the address of the sender that wants to pay, can also be a loan escrow\n * @param isLiquidation is this loan being liquidated?\n * @return leftToPay_ the amount left to pay for the loan\n */\n function __repayLoan(\n uint256 loanID,\n uint256 amount,\n address sender,\n bool isLiquidation\n ) private returns (uint256 leftToPay_) {\n require(amount > 0, \"Teller: zero repay\");\n\n // calculate the actual amount to repay\n leftToPay_ =\n LibLoans.debt(loanID).principalOwed +\n LibLoans.debt(loanID).interestOwed;\n if (leftToPay_ < amount) {\n amount = leftToPay_;\n leftToPay_ = 0;\n } else {\n leftToPay_ -= amount;\n }\n\n // Get the Teller token for the loan\n ITToken tToken =\n MarketStorageLib.store().tTokens[\n LibLoans.loan(loanID).lendingToken\n ];\n // Transfer funds from an escrow if an escrow is calling it\n // Otherwise, transfer funds from an account\n if (address(LibEscrow.e(loanID)) == sender) {\n LibEscrow.e(loanID).claimToken(\n LibLoans.loan(loanID).lendingToken,\n address(tToken),\n amount\n );\n } else {\n SafeERC20.safeTransferFrom(\n IERC20(LibLoans.loan(loanID).lendingToken),\n sender,\n address(tToken),\n amount\n );\n }\n\n // Deduct the interest and principal owed\n uint256 principalPaid;\n uint256 interestPaid;\n if (amount < LibLoans.debt(loanID).interestOwed) {\n interestPaid = amount;\n LibLoans.debt(loanID).interestOwed -= amount;\n } else {\n if (LibLoans.debt(loanID).interestOwed > 0) {\n interestPaid = LibLoans.debt(loanID).interestOwed;\n amount -= interestPaid;\n LibLoans.debt(loanID).interestOwed = 0;\n }\n\n if (amount > 0) {\n principalPaid = amount;\n LibLoans.debt(loanID).principalOwed -= amount;\n }\n }\n\n // Tell the Teller Token value has been deposited back into the pool.\n tToken.repayLoan(principalPaid, interestPaid);\n\n if (isLiquidation) {\n // Make sure there is nothing left to repay on the loan\n require(leftToPay_ == 0, \"Teller: liquidate partial repay\");\n\n // Set loan status\n LibLoans.loan(loanID).status = LoanStatus.Liquidated;\n\n // Transfer NFT if linked\n NFTLib.liquidateNFT(loanID);\n } else {\n // if the loan is now fully paid, close it and withdraw borrower collateral\n if (leftToPay_ == 0) {\n LibLoans.loan(loanID).status = LoanStatus.Closed;\n\n // Check if the loan has a collateral token\n if (LibLoans.loan(loanID).collateralToken != address(0)) {\n LibCollateral.withdrawAll(\n loanID,\n LibLoans.loan(loanID).borrower\n );\n }\n\n // Claim tokens in the escrow for the loan if any\n __claimEscrowTokens(loanID);\n\n // Restake any NFTs linked to loan for borrower\n NFTLib.restakeLinked(loanID, LibLoans.loan(loanID).borrower);\n }\n\n emit LoanRepaid(\n loanID,\n LibLoans.loan(loanID).borrower,\n amount,\n msg.sender,\n leftToPay_\n );\n }\n }\n\n /**\n * @notice Liquidate a loan if it is expired or under collateralized\n * @param loanID The ID of the loan to be liquidated\n */\n function liquidateLoan(uint256 loanID)\n external\n nonReentry(\"\")\n paused(\"\", false)\n authorized(AUTHORIZED, msg.sender)\n {\n Loan storage loan = LibLoans.loan(loanID);\n uint256 collateralAmount = LibCollateral.e(loanID).loanSupply(loanID);\n require(\n RepayLib.isLiquidable(loanID, collateralAmount),\n \"Teller: does not need liquidation\"\n );\n\n // Calculate the reward before repaying the loan\n (uint256 rewardInLending, uint256 collateralInLending) =\n RepayLib.getLiquidationReward(loanID, collateralAmount);\n\n // The liquidator pays the amount still owed on the loan\n uint256 amountToLiquidate =\n LibLoans.debt(loanID).principalOwed +\n LibLoans.debt(loanID).interestOwed;\n\n __repayLoan(loanID, amountToLiquidate, msg.sender, true);\n\n // Payout the liquidator reward owed\n if (rewardInLending > 0) {\n RepayLib.payOutLiquidator(\n loanID,\n rewardInLending,\n collateralInLending,\n collateralAmount,\n payable(msg.sender)\n );\n }\n\n emit LoanLiquidated(\n loanID,\n loan.borrower,\n msg.sender,\n rewardInLending,\n amountToLiquidate\n );\n }\n\n /**\n * @notice It gets the current liquidation reward for a given loan.\n * @param loanID The loan ID to get the info.\n * @return inLending_ The value the liquidator will receive denoted in lending tokens.\n * @return inCollateral_ The value the liquidator will receive denoted in collateral tokens.\n */\n function getLiquidationReward(uint256 loanID)\n external\n view\n returns (uint256 inLending_, uint256 inCollateral_)\n {\n (inLending_, ) = RepayLib.getLiquidationReward(\n loanID,\n LibCollateral.e(loanID).loanSupply(loanID)\n );\n inCollateral_ = PriceAggLib.valueFor(\n LibLoans.loan(loanID).lendingToken,\n LibLoans.loan(loanID).collateralToken,\n inLending_\n );\n }\n}\n\nlibrary RepayLib {\n /**\n * @notice It checks if a loan can be liquidated.\n * @param loanID The loan ID to check.\n * @return true if the loan is liquidable.\n */\n function isLiquidable(uint256 loanID, uint256 collateralAmount)\n internal\n view\n returns (bool)\n {\n Loan storage loan = LibLoans.loan(loanID);\n // Check if loan can be liquidated\n if (loan.status != LoanStatus.Active) {\n return false;\n }\n\n if (loan.collateralRatio > 0) {\n // If loan has a collateral ratio, check how much is needed\n (, uint256 neededInCollateral, ) =\n LoanDataFacet(address(this)).getCollateralNeededInfo(loanID);\n if (neededInCollateral > collateralAmount) {\n return true;\n }\n }\n\n // Otherwise, check if the loan has expired\n return block.timestamp >= loan.loanStartTime + loan.duration;\n }\n\n /**\n * @notice It gets the current liquidation reward for a given loan.\n * @param loanID The loan ID to get the info.\n * @param collateralAmount The amount of collateral for the {loanID}. Passed in to save gas calling the collateral escrow multiple times.\n * @return reward_ The value the liquidator will receive denoted in lending tokens.\n */\n function getLiquidationReward(uint256 loanID, uint256 collateralAmount)\n internal\n view\n returns (uint256 reward_, uint256 collateralValue_)\n {\n uint256 amountToLiquidate =\n LibLoans.debt(loanID).principalOwed +\n LibLoans.debt(loanID).interestOwed;\n\n // Max reward is amount repaid on loan plus extra percentage\n uint256 maxReward =\n amountToLiquidate +\n NumbersLib.percent(\n amountToLiquidate,\n uint16(PlatformSettingsLib.getLiquidateRewardPercent())\n );\n\n // Calculate available collateral for reward\n if (collateralAmount > 0) {\n collateralValue_ = PriceAggLib.valueFor(\n LibLoans.loan(loanID).collateralToken,\n LibLoans.loan(loanID).lendingToken,\n collateralAmount\n );\n reward_ += collateralValue_;\n }\n\n // Calculate loan escrow value if collateral not enough to cover reward\n if (reward_ < maxReward) {\n reward_ += LibEscrow.calculateTotalValue(loanID);\n }\n\n // Cap the reward to max\n if (reward_ > maxReward) {\n reward_ = maxReward;\n }\n }\n\n /**\n * @notice Checks if the loan has an Escrow and claims any tokens then pays out the loan collateral.\n * @dev See Escrow.claimTokens for more info.\n * @param loanID The loan ID which is being liquidated\n * @param rewardInLending The total amount of reward based in the lending token to pay the liquidator\n * @param collateralInLending The amount of collateral that is available for the loan denoted in lending tokens\n * @param collateralAmount The amount of collateral that is available for the loan\n * @param liquidator The address of the liquidator where the liquidation reward will be sent to\n */\n function payOutLiquidator(\n uint256 loanID,\n uint256 rewardInLending,\n uint256 collateralInLending,\n uint256 collateralAmount,\n address payable liquidator\n ) internal {\n // check if loan is liquidated\n require(\n LibLoans.loan(loanID).status == LoanStatus.Liquidated,\n \"Teller: loan not liquidated\"\n );\n\n // if the lending reward is less than the collateral lending tokens, then aggregate\n // the value for the lending token with the collateral token and send it to the liquidator\n if (rewardInLending <= collateralInLending) {\n uint256 rewardInCollateral =\n PriceAggLib.valueFor(\n LibLoans.loan(loanID).lendingToken,\n LibLoans.loan(loanID).collateralToken,\n rewardInLending\n );\n\n LibCollateral.withdraw(loanID, rewardInCollateral, liquidator);\n } else {\n // Payout whats available in the collateral token\n LibCollateral.withdraw(loanID, collateralAmount, liquidator);\n\n // Claim remaining reward value from the loan escrow\n claimEscrowTokensByValue(\n loanID,\n liquidator,\n rewardInLending - collateralInLending\n );\n }\n }\n\n /**\n * @dev Send the equivalent of tokens owned by the loan escrow (in lending value) to the recipient,\n * @param loanID The loan ID to clam tokens from\n * @param recipient address to send the tokens to\n * @param value The value of escrow held tokens to be claimed based in lending value\n */\n function claimEscrowTokensByValue(\n uint256 loanID,\n address recipient,\n uint256 value\n ) private {\n EnumerableSet.AddressSet storage tokens =\n MarketStorageLib.store().escrowTokens[loanID];\n uint256 valueLeftToTransfer = value;\n\n // Start with the lending token\n valueLeftToTransfer = claimEscrowToken(\n loanID,\n LibLoans.loan(loanID).lendingToken,\n recipient,\n valueLeftToTransfer\n );\n\n // Cycle through remaining tokens\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\n if (valueLeftToTransfer == 0) {\n return;\n }\n\n valueLeftToTransfer = claimEscrowToken(\n loanID,\n EnumerableSet.at(tokens, i),\n recipient,\n valueLeftToTransfer\n );\n }\n }\n\n /**\n * @notice it claims the escrow tokens for the liquidator\n * @notice it keeps claiming escrow tokens until there aren't anymore tokens or the valueLeftToTransfer is zero\n * @param loanID the identifier of the escrow loan to claim tokens from\n * @param token the address of the token asset to claim\n * @param recipient the address of the recipient to transfer the tokens to\n * @param valueLeftToTransfer the value left to transfer to the liquidator that is returned back\n * @return the value left to transfer\n */\n function claimEscrowToken(\n uint256 loanID,\n address token,\n address recipient,\n uint256 valueLeftToTransfer\n ) private returns (uint256) {\n uint256 balance = LibEscrow.balanceOf(loanID, token);\n // get value of token balance in lending value\n if (balance > 0) {\n // If token not the lending token, get value of token\n uint256 balanceInLending;\n if (token == LibLoans.loan(loanID).lendingToken) {\n balanceInLending = balance;\n } else {\n balanceInLending = PriceAggLib.valueFor(\n token,\n LibLoans.loan(loanID).lendingToken,\n balance\n );\n }\n\n if (balanceInLending <= valueLeftToTransfer) {\n LibEscrow.e(loanID).claimToken(token, recipient, balance);\n valueLeftToTransfer -= balanceInLending;\n } else {\n // Token balance is more than enough so calculate ratio of balance to transfer\n uint256 valueToTransfer;\n if (token == LibLoans.loan(loanID).lendingToken) {\n valueToTransfer = valueLeftToTransfer;\n } else {\n valueToTransfer = NumbersLib.percent(\n balance,\n NumbersLib.ratioOf(\n valueLeftToTransfer,\n balanceInLending\n )\n );\n }\n\n LibEscrow.e(loanID).claimToken(\n token,\n recipient,\n valueToTransfer\n );\n valueLeftToTransfer = 0;\n }\n }\n return valueLeftToTransfer;\n }\n}\n" + }, + "contracts/market/SignersFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Storage\nimport { MarketStorageLib } from \"../storage/market.sol\";\n\n// Libraries\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\ncontract SignersFacet {\n /**\n * @notice It adds a new account as a signer.\n * @param asset Token address to add signers for.\n * @param account address to add.\n * @dev The sender must be the owner.\n * @dev It throws a require error if the sender is not the owner.\n */\n function addSigner(address asset, address account) external {\n _addSigner(asset, account);\n }\n\n /**\n * @notice It adds a list of account as signers.\n * @param asset Token address to add signers for.\n * @param accounts addresses to add.\n * @dev The sender must be the owner.\n * @dev It throws a require error if the sender is not the owner.\n */\n function addSigners(address asset, address[] calldata accounts) external {\n for (uint256 i; i < accounts.length; i++) {\n _addSigner(asset, accounts[i]);\n }\n }\n\n /**\n * @notice it adds an account to a list of signers for an asset\n * @param asset is the token address to check for signers\n * @param account is the account address of the signer\n */\n function _addSigner(address asset, address account) internal {\n if (!isSigner(asset, account)) {\n EnumerableSet.add(MarketStorageLib.store().signers[asset], account);\n }\n }\n\n /**\n * @notice it checks if an account is already in the list of the asset's signers\n * @param asset the asset to check for if the signer exists\n * @param account the account to check in the list of the asset's signers\n */\n function isSigner(address asset, address account)\n public\n view\n returns (bool isSigner_)\n {\n isSigner_ = EnumerableSet.contains(\n MarketStorageLib.store().signers[asset],\n account\n );\n }\n}\n" + }, + "contracts/market/CollateralFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../contexts2/access-control/roles/RolesMods.sol\";\nimport {\n ReentryMods\n} from \"../contexts2/access-control/reentry/ReentryMods.sol\";\nimport { PausableMods } from \"../settings/pausable/PausableMods.sol\";\nimport { ADMIN, AUTHORIZED } from \"../shared/roles.sol\";\n\n// Libraries\nimport { LibLoans } from \"./libraries/LibLoans.sol\";\nimport { LibCollateral } from \"./libraries/LibCollateral.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\n// Storage\nimport {\n MarketStorageLib,\n MarketStorage,\n LoanStatus,\n Loan\n} from \"../storage/market.sol\";\n\ncontract CollateralFacet is RolesMods, ReentryMods, PausableMods {\n /**\n * @notice Deposit collateral tokens into a loan.\n * @param loanID The ID of the loan the collateral is for\n * @param amount The amount to deposit as collateral.\n */\n function depositCollateral(uint256 loanID, uint256 amount)\n external\n payable\n paused(\"\", false)\n nonReentry(\"\")\n authorized(AUTHORIZED, msg.sender)\n {\n uint256 status = uint256(LibLoans.loan(loanID).status);\n require(\n status ==\n (uint256(LoanStatus.TermsSet) ^ uint256(LoanStatus.Active)) &\n status,\n \"Teller: loan not active or set\"\n );\n\n // Transfer tokens to the collateral escrow\n LibCollateral.deposit(loanID, amount);\n }\n\n /**\n * @notice it withdraws collateral tokens from a loan\n * @param amount to wtihdraw from the loan\n * @param loanID identifier of our loan\n */\n function withdrawCollateral(uint256 amount, uint256 loanID)\n external\n paused(\"\", false)\n nonReentry(\"\")\n authorized(AUTHORIZED, msg.sender)\n {\n // check if caller is borrower\n require(\n msg.sender == LibLoans.loan(loanID).borrower,\n \"Teller: not borrower\"\n );\n\n // check if amount required to withdraw is more than zero\n require(amount > 0, \"Teller: zero withdraw\");\n\n // here, we check if the loan supply minus the needed collateral tokens is still\n // greater than the amount we want to withdraw\n if (LibLoans.loan(loanID).status == LoanStatus.Active) {\n (, uint256 needed, ) = LibLoans.getCollateralNeededInfo(loanID);\n if (needed > 0) {\n require(\n LibCollateral.e(loanID).loanSupply(loanID) - needed >=\n amount,\n \"Teller: collateral withdraw amount over limit\"\n );\n }\n }\n\n // Withdraw collateral and send to loan borrower\n LibCollateral.withdraw(loanID, amount, LibLoans.loan(loanID).borrower);\n }\n\n /**\n * @notice Adds tokens allowed to be used as collateral for {asset} loans.\n * @notice it creates an escrow for each collateral token address\n * @param asset Token address to add allowed collateral tokens.\n * @param collateralTokens List of allowed collateral token addresses.\n *\n * Requirements:\n * - Sender must be admin\n */\n function addCollateralTokens(\n address asset,\n address[] calldata collateralTokens\n ) external authorized(ADMIN, msg.sender) {\n for (uint256 i; i < collateralTokens.length; i++) {\n EnumerableSet.add(\n MarketStorageLib.store().collateralTokens[asset],\n collateralTokens[i]\n );\n LibCollateral.createEscrow(collateralTokens[i]);\n }\n }\n\n /**\n * @notice get list of collateral tokens that is allowed to be used on an {asset} loan\n * @param asset token address to get allowed collateral tokens\n * @return tokens_ collateral tokens that are accepted\n */\n function getCollateralTokens(address asset)\n external\n view\n returns (address[] memory tokens_)\n {\n EnumerableSet.AddressSet storage collateralTokens =\n MarketStorageLib.store().collateralTokens[asset];\n tokens_ = new address[](EnumerableSet.length(collateralTokens));\n for (uint256 i; i < EnumerableSet.length(collateralTokens); i++) {\n tokens_[i] = EnumerableSet.at(collateralTokens, i);\n }\n }\n\n /**\n * @notice get the total collateral tokens in a respective loan\n * @param loanID the identifier of the respective loan\n * @return supply_ the total amount of supply in collateral of the loan\n */\n function getLoanCollateral(uint256 loanID)\n external\n view\n returns (uint256 supply_)\n {\n supply_ = LibCollateral.e(loanID).loanSupply(loanID);\n }\n}\n" + }, + "contracts/escrow/dapps/CompoundFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { DappMods } from \"./DappMods.sol\";\nimport { PausableMods } from \"../../settings/pausable/PausableMods.sol\";\n\n// Libraries\nimport { LibCompound } from \"./libraries/LibCompound.sol\";\nimport { LibDapps } from \"./libraries/LibDapps.sol\";\nimport { LibEscrow } from \"../libraries/LibEscrow.sol\";\nimport {\n AssetCTokenLib\n} from \"../../settings/asset/libraries/AssetCTokenLib.sol\";\n\n// Interfaces\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { ICErc20 } from \"../../shared/interfaces/ICErc20.sol\";\n\ncontract CompoundFacet is PausableMods, DappMods {\n /**\n * @notice This event is emitted every time Compound lend is invoked successfully.\n * @param tokenAddress address of the underlying token.\n * @param cTokenAddress compound token address.\n * @param amount amount of tokens to Lend.\n */\n event CompoundLended(\n address indexed tokenAddress,\n address indexed cTokenAddress,\n uint256 amount\n );\n\n /**\n * @notice This event is emitted every time Compound redeem is invoked successfully.\n * @param tokenAddress address of the underlying token.\n * @param cTokenAddress compound token address.\n * @param amount amount of tokens to Redeem.\n */\n event CompoundRedeemed(\n address indexed tokenAddress,\n address indexed cTokenAddress,\n uint256 amount\n );\n\n /**\n * @notice To lend we first have to approve the cToken to access the token balance then mint.\n * @param loanID id of the loan being used in the dapp\n * @param tokenAddress address of the token.\n * @param amount amount of tokens to mint.\n */\n function compoundLend(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n ICErc20 cToken = AssetCTokenLib.get(tokenAddress);\n\n LibEscrow.e(loanID).setTokenAllowance(tokenAddress, address(cToken));\n\n bytes memory result =\n LibEscrow.e(loanID).callDapp(\n address(cToken),\n abi.encodeWithSelector(ICErc20.mint.selector, amount)\n );\n\n require(\n abi.decode(result, (uint256)) == LibCompound.NO_ERROR,\n \"Teller: compound deposit error\"\n );\n\n LibEscrow.tokenUpdated(loanID, address(cToken));\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n\n emit CompoundLended(tokenAddress, address(cToken), amount);\n }\n\n /**\n * @notice This function redeems the user's cTokens for a specific amount of the underlying token.\n * @param loanID id of the loan being used in the dapp\n * @param tokenAddress address of the token.\n * @param amount amount of underlying tokens to redeem.\n */\n function compoundRedeem(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n ICErc20 cToken = AssetCTokenLib.get(tokenAddress);\n __compoundRedeem(\n loanID,\n address(cToken),\n tokenAddress,\n abi.encodeWithSelector(ICErc20.redeemUnderlying.selector, amount)\n );\n\n emit CompoundRedeemed(tokenAddress, address(cToken), amount);\n }\n\n /**\n * @notice This function redeems the complete cToken balance.\n * @param loanID id of the loan being used in the dapp\n * @param tokenAddress address of the token.\n */\n function compoundRedeemAll(uint256 loanID, address tokenAddress)\n public\n paused(\"\", false)\n onlyBorrower(loanID)\n {\n ICErc20 cToken = AssetCTokenLib.get(tokenAddress);\n __compoundRedeem(\n loanID,\n address(cToken),\n tokenAddress,\n abi.encodeWithSelector(\n ICErc20.redeem.selector,\n cToken.balanceOf(address(LibEscrow.e(loanID)))\n )\n );\n\n emit CompoundRedeemed(\n tokenAddress,\n address(cToken),\n IERC20(tokenAddress).balanceOf(address(LibEscrow.e(loanID)))\n );\n }\n\n /**\n * @notice This function calls on Compound cToken to redeem an amount of the underlying token.\n * @param loanID ID of the loan being used for the dapp.\n * @param cTokenAddress Compound token address.\n * @param tokenAddress Underlying Compound token address.\n * @param callData Encoded data to send to the escrow to call.\n */\n function __compoundRedeem(\n uint256 loanID,\n address cTokenAddress,\n address tokenAddress,\n bytes memory callData\n ) private {\n bytes memory result =\n LibEscrow.e(loanID).callDapp(cTokenAddress, callData);\n\n require(\n abi.decode(result, (uint256)) !=\n LibCompound.TOKEN_INSUFFICIENT_BALANCE,\n \"Teller: compound dapp insufficient balance\"\n );\n require(\n abi.decode(result, (uint256)) == LibCompound.NO_ERROR,\n \"Teller: compound dapp withdrawal error\"\n );\n\n LibEscrow.tokenUpdated(loanID, cTokenAddress);\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n }\n}\n" + }, + "contracts/escrow/dapps/UniswapFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { DappMods } from \"./DappMods.sol\";\nimport { PausableMods } from \"../../settings/pausable/PausableMods.sol\";\n\n// Libraries\nimport { LibEscrow } from \"../libraries/LibEscrow.sol\";\nimport { LibUniswap } from \"./libraries/LibUniswap.sol\";\nimport {\n ChainlinkLib\n} from \"../../price-aggregator/chainlink/ChainlinkLib.sol\";\n\n// Interfaces\nimport { IUniswapV2Router } from \"../../shared/interfaces/IUniswapV2Router.sol\";\n\ncontract UniswapFacet is PausableMods, DappMods {\n /**\n * @notice Event emitted every time a successful swap has taken place.\n * @param sourceToken source token address.\n * @param destinationToken destination address.\n * @param sourceAmount source amount sent.\n * @param destinationAmount destination amount received.\n */\n event UniswapSwapped(\n address indexed sourceToken,\n address indexed destinationToken,\n uint256 sourceAmount,\n uint256 destinationAmount\n );\n\n /**\n * @notice Swaps tokens for tokens on Uniswap.\n * @dev {path} must have at least 2 token addresses\n * @param path An array of token addresses.\n * @param sourceAmount amount of source token to swap.\n * @param minDestination The minimum amount of output tokens that must be received for the transaction not to revert.\n */\n function uniswapSwap(\n uint256 loanID,\n address[] memory path,\n uint256 sourceAmount,\n uint256 minDestination\n ) external paused(\"\", false) onlySecured(loanID) onlyBorrower(loanID) {\n address src = path[0];\n address dst = path[path.length - 1];\n require(\n ChainlinkLib.isTokenSupported(src),\n \"Teller: uniswap src not supported\"\n );\n require(\n ChainlinkLib.isTokenSupported(dst),\n \"Teller: uniswap dst not supported\"\n );\n\n // Set allowance on source token to Uniswap Router\n LibEscrow.e(loanID).setTokenAllowance(src, address(LibUniswap.ROUTER));\n\n // Encode data for LoansEscrow to call\n bytes memory callData =\n abi.encodeWithSelector(\n IUniswapV2Router.swapExactTokensForTokens.selector,\n sourceAmount,\n minDestination,\n path,\n address(LibEscrow.e(loanID)),\n block.timestamp\n );\n // Call Escrow to do swap get the response amounts\n uint256[] memory amounts =\n abi.decode(\n LibEscrow.e(loanID).callDapp(\n address(LibUniswap.ROUTER),\n callData\n ),\n (uint256[])\n );\n uint256 destinationAmount = amounts[amounts.length - 1];\n\n LibEscrow.tokenUpdated(loanID, src);\n LibEscrow.tokenUpdated(loanID, dst);\n\n emit UniswapSwapped(src, dst, sourceAmount, destinationAmount);\n }\n}\n" + }, + "contracts/shared/interfaces/IUniswapV2Router.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/**\n @notice This interface defines the different functions available for a UniswapV2Router.\n @author develop@teller.finance\n */\ninterface IUniswapV2Router {\n function factory() external pure returns (address);\n \n function addLiquidity(\n address tokenA,\n address tokenB,\n uint256 amountADesired,\n uint256 amountBDesired,\n uint256 amountAMin,\n uint256 amountBMin,\n address to,\n uint256 deadline\n )\n external\n returns (\n uint256 amountA,\n uint256 amountB,\n uint256 liquidity\n );\n\n function addLiquidityETH(\n address token,\n uint256 amountTokenDesired,\n uint256 amountTokenMin,\n uint256 amountETHMin,\n address to,\n uint256 deadline\n )\n external\n payable\n returns (\n uint256 amountToken,\n uint256 amountETH,\n uint256 liquidity\n );\n\n function removeLiquidity(\n address tokenA,\n address tokenB,\n uint256 liquidity,\n uint256 amountAMin,\n uint256 amountBMin,\n address to,\n uint256 deadline\n ) external returns (uint256 amountA, uint256 amountB);\n\n function removeLiquidityETH(\n address token,\n uint256 liquidity,\n uint256 amountTokenMin,\n uint256 amountETHMin,\n address to,\n uint256 deadline\n ) external returns (uint256 amountToken, uint256 amountETH);\n\n function removeLiquidityWithPermit(\n address tokenA,\n address tokenB,\n uint256 liquidity,\n uint256 amountAMin,\n uint256 amountBMin,\n address to,\n uint256 deadline,\n bool approveMax,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external returns (uint256 amountA, uint256 amountB);\n\n function removeLiquidityETHWithPermit(\n address token,\n uint256 liquidity,\n uint256 amountTokenMin,\n uint256 amountETHMin,\n address to,\n uint256 deadline,\n bool approveMax,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external returns (uint256 amountToken, uint256 amountETH);\n\n function quote(\n uint256 amountA,\n uint256 reserveA,\n uint256 reserveB\n ) external pure returns (uint256 amountB);\n\n function getAmountOut(\n uint256 amountIn,\n uint256 reserveIn,\n uint256 reserveOut\n ) external pure returns (uint256 amountOut);\n\n function getAmountIn(\n uint256 amountOut,\n uint256 reserveIn,\n uint256 reserveOut\n ) external pure returns (uint256 amountIn);\n\n function getAmountsOut(uint256 amountIn, address[] calldata path)\n external\n view\n returns (uint256[] memory amounts);\n\n function getAmountsIn(uint256 amountOut, address[] calldata path)\n external\n view\n returns (uint256[] memory amounts);\n\n /**\n @notice It returns the address of the canonical WETH address;\n */\n function WETH() external pure returns (address);\n\n /**\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\n @param amountIn The amount of input tokens to send.\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\n @param to Recipient of the output tokens.\n @param deadline Unix timestamp after which the transaction will revert.\n @return amounts The input token amount and all subsequent output token amounts.\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\n */\n function swapExactTokensForTokens(\n uint256 amountIn,\n uint256 amountOutMin,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external returns (uint256[] memory amounts);\n\n /**\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\n @param amountIn The amount of input tokens to send.\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\n @param to Recipient of the ETH.\n @param deadline Unix timestamp after which the transaction will revert.\n @return amounts The input token amount and all subsequent output token amounts.\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\n */\n function swapExactTokensForETH(\n uint256 amountIn,\n uint256 amountOutMin,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external returns (uint256[] memory amounts);\n\n /**\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\n @param to Recipient of the output tokens.\n @param deadline Unix timestamp after which the transaction will revert.\n @return amounts The input token amount and all subsequent output token amounts.\n */\n function swapExactETHForTokens(\n uint256 amountOutMin,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external payable returns (uint256[] memory amounts);\n\n function swapTokensForExactTokens(\n uint256 amountOut,\n uint256 amountInMax,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external returns (uint256[] memory amounts);\n\n function swapTokensForExactETH(\n uint256 amountOut,\n uint256 amountInMax,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external returns (uint256[] memory amounts);\n\n function swapETHForExactTokens(\n uint256 amountOut,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external payable returns (uint256[] memory amounts);\n}\n" + }, + "contracts/shared/interfaces/ICErc20.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./IComptroller.sol\";\n\ninterface ICErc20 {\n /*** User Interface ***/\n\n /**\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\n @return 0 on success, otherwise an Error code\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\n */\n function mint(uint256 mintAmount) external returns (uint256);\n\n /**\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\n @param redeemTokens The number of cTokens to be redeemed.\n @return 0 on success, otherwise an Error code\n @dev msg.sender The account to which redeemed funds shall be transferred.\n */\n function redeem(uint256 redeemTokens) external returns (uint256);\n\n /**\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\n @param redeemAmount The amount of underlying to be redeemed.\n @return 0 on success, otherwise an Error code\n @dev msg.sender The account to which redeemed funds shall be transferred.\n */\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\n\n /**\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\n @param borrowAmount The amount of the underlying asset to be borrowed.\n @return 0 on success, otherwise an Error code\n @dev msg.sender The account to which borrowed funds shall be transferred.\n */\n function borrow(uint256 borrowAmount) external returns (uint256);\n\n /**\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\n @return 0 on success, otherwise an Error code\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\n */\n function repayBorrow(uint256 repayAmount) external returns (uint256);\n\n /**\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\n @param borrower The account which borrowed the asset to be repaid.\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\n @return 0 on success, otherwise an Error code\n @dev msg.sender The account which shall repay the borrow.\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\n */\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\n external\n returns (uint256);\n\n /*** Admin Functions ***/\n\n function _addReserves(uint256 addAmount) external returns (uint256);\n\n /** End Admin Functions */\n\n function underlying() external view returns (address);\n\n /**\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\n */\n function exchangeRateCurrent() external returns (uint256);\n\n function exchangeRateStored() external view returns (uint256);\n\n /**\n * @notice Applies accrued interest to total borrows and reserves\n * @dev This calculates interest accrued from the last checkpointed block\n * up to the current block and writes new checkpoint to storage.\n */\n function accrueInterest() external;\n\n function decimals() external view returns (uint8);\n\n function balanceOf(address account) external view returns (uint256);\n\n /**\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\n @param account The account to get the underlying balance of.\n @return The amount of underlying currently owned by the account.\n */\n function balanceOfUnderlying(address account) external returns (uint256);\n\n function comptroller() external view returns (IComptroller);\n}\n" + }, + "contracts/settings/asset/libraries/AssetCTokenLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../../shared/libraries/CacheLib.sol\";\nimport { ICErc20 } from \"../../../shared/interfaces/ICErc20.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions for Compound asset setting.\n *\n * @author develop@teller.finance\n */\nlibrary AssetCTokenLib {\n bytes32 private constant NAME = keccak256(\"cToken\");\n\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n function get(address asset) internal view returns (ICErc20) {\n return ICErc20(s(asset).addresses[NAME]);\n }\n\n function set(address asset, address newValue) internal {\n s(asset).addresses[NAME] = newValue;\n }\n}\n" + }, + "contracts/settings/asset/libraries/MaxLoanAmountLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../../shared/libraries/CacheLib.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions for MaxLoanAmount asset setting.\n *\n * @author develop@teller.finance\n */\nlibrary MaxLoanAmountLib {\n bytes32 private constant NAME = keccak256(\"MaxLoanAmount\");\n\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n function get(address asset) internal view returns (uint256) {\n return s(asset).uints[NAME];\n }\n\n function set(address asset, uint256 newValue) internal {\n s(asset).uints[NAME] = newValue;\n }\n}\n" + }, + "contracts/settings/asset/libraries/MaxTVLLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../../shared/libraries/CacheLib.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions for MaxDebtRatio asset setting.\n *\n * @author develop@teller.finance\n */\nlibrary MaxTVLLib {\n bytes32 private constant NAME = keccak256(\"MaxTVL\");\n\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n function get(address asset) internal view returns (uint256) {\n return s(asset).uints[NAME];\n }\n\n function set(address asset, uint256 newValue) internal {\n s(asset).uints[NAME] = newValue;\n }\n}\n" + }, + "contracts/shared/interfaces/IComptroller.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IComptroller {\n /*** Assets You Are In ***/\n\n function enterMarkets(address[] calldata cTokens)\n external\n returns (uint256[] memory);\n\n function exitMarket(address cToken) external returns (uint256);\n\n /*** Policy Hooks ***/\n\n /**\n * @notice Checks if the account should be allowed to mint tokens in the given market\n * @param cToken The market to verify the mint against\n * @param minter The account which would get the minted tokens\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\n */\n function mintAllowed(\n address cToken,\n address minter,\n uint256 mintAmount\n ) external returns (uint256);\n\n /**\n * @notice Validates mint and reverts on rejection. May emit logs.\n * @param cToken Asset being minted\n * @param minter The address minting the tokens\n * @param mintAmount The amount of the underlying asset being minted\n * @param mintTokens The number of tokens being minted\n */\n function mintVerify(\n address cToken,\n address minter,\n uint256 mintAmount,\n uint256 mintTokens\n ) external;\n\n /**\n * @notice Checks if the account should be allowed to redeem tokens in the given market\n * @param cToken The market to verify the redeem against\n * @param redeemer The account which would redeem the tokens\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\n */\n function redeemAllowed(\n address cToken,\n address redeemer,\n uint256 redeemTokens\n ) external returns (uint256);\n\n /**\n * @notice Validates redeem and reverts on rejection. May emit logs.\n * @param cToken Asset being redeemed\n * @param redeemer The address redeeming the tokens\n * @param redeemAmount The amount of the underlying asset being redeemed\n * @param redeemTokens The number of tokens being redeemed\n */\n function redeemVerify(\n address cToken,\n address redeemer,\n uint256 redeemAmount,\n uint256 redeemTokens\n ) external;\n\n /**\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\n * @param cToken The market to verify the borrow against\n * @param borrower The account which would borrow the asset\n * @param borrowAmount The amount of underlying the account would borrow\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\n */\n function borrowAllowed(\n address cToken,\n address borrower,\n uint256 borrowAmount\n ) external returns (uint256);\n\n /**\n * @notice Validates borrow and reverts on rejection. May emit logs.\n * @param cToken Asset whose underlying is being borrowed\n * @param borrower The address borrowing the underlying\n * @param borrowAmount The amount of the underlying asset requested to borrow\n */\n function borrowVerify(\n address cToken,\n address borrower,\n uint256 borrowAmount\n ) external;\n\n /**\n * @notice Checks if the account should be allowed to repay a borrow in the given market\n * @param cToken The market to verify the repay against\n * @param payer The account which would repay the asset\n * @param borrower The account which would borrowed the asset\n * @param repayAmount The amount of the underlying asset the account would repay\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\n */\n function repayBorrowAllowed(\n address cToken,\n address payer,\n address borrower,\n uint256 repayAmount\n ) external returns (uint256);\n\n /**\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\n * @param cToken Asset being repaid\n * @param payer The address repaying the borrow\n * @param borrower The address of the borrower\n * @param repayAmount The amount of underlying being repaid\n * @param borrowerIndex the index of the borrower\n */\n function repayBorrowVerify(\n address cToken,\n address payer,\n address borrower,\n uint256 repayAmount,\n uint256 borrowerIndex\n ) external;\n\n /**\n * @notice Checks if the liquidation should be allowed to occur\n * @param cTokenBorrowed Asset which was borrowed by the borrower\n * @param cTokenCollateral Asset which was used as collateral and will be seized\n * @param liquidator The address repaying the borrow and seizing the collateral\n * @param borrower The address of the borrower\n * @param repayAmount The amount of underlying being repaid\n */\n function liquidateBorrowAllowed(\n address cTokenBorrowed,\n address cTokenCollateral,\n address liquidator,\n address borrower,\n uint256 repayAmount\n ) external returns (uint256);\n\n /**\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\n * @param cTokenBorrowed Asset which was borrowed by the borrower\n * @param cTokenCollateral Asset which was used as collateral and will be seized\n * @param liquidator The address repaying the borrow and seizing the collateral\n * @param borrower The address of the borrower\n * @param repayAmount The amount of underlying being repaid\n * @param seizeTokens The number of collateral tokens to seize\n */\n function liquidateBorrowVerify(\n address cTokenBorrowed,\n address cTokenCollateral,\n address liquidator,\n address borrower,\n uint256 repayAmount,\n uint256 seizeTokens\n ) external;\n\n /**\n * @notice Checks if the seizing of assets should be allowed to occur\n * @param cTokenCollateral Asset which was used as collateral and will be seized\n * @param cTokenBorrowed Asset which was borrowed by the borrower\n * @param liquidator The address repaying the borrow and seizing the collateral\n * @param borrower The address of the borrower\n * @param seizeTokens The number of collateral tokens to seize\n */\n function seizeAllowed(\n address cTokenCollateral,\n address cTokenBorrowed,\n address liquidator,\n address borrower,\n uint256 seizeTokens\n ) external returns (uint256);\n\n /**\n * @notice Validates seize and reverts on rejection. May emit logs.\n * @param cTokenCollateral Asset which was used as collateral and will be seized\n * @param cTokenBorrowed Asset which was borrowed by the borrower\n * @param liquidator The address repaying the borrow and seizing the collateral\n * @param borrower The address of the borrower\n * @param seizeTokens The number of collateral tokens to seize\n */\n function seizeVerify(\n address cTokenCollateral,\n address cTokenBorrowed,\n address liquidator,\n address borrower,\n uint256 seizeTokens\n ) external;\n\n /**\n * @notice Checks if the account should be allowed to transfer tokens in the given market\n * @param cToken The market to verify the transfer against\n * @param src The account which sources the tokens\n * @param dst The account which receives the tokens\n * @param transferTokens The number of cTokens to transfer\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\n */\n function transferAllowed(\n address cToken,\n address src,\n address dst,\n uint256 transferTokens\n ) external returns (uint256);\n\n /**\n * @notice Validates transfer and reverts on rejection. May emit logs.\n * @param cToken Asset being transferred\n * @param src The account which sources the tokens\n * @param dst The account which receives the tokens\n * @param transferTokens The number of cTokens to transfer\n */\n function transferVerify(\n address cToken,\n address src,\n address dst,\n uint256 transferTokens\n ) external;\n\n /**\n * @notice Claim all the comp accrued by holder in all markets\n * @param holder The address to claim COMP for\n */\n function claimComp(address holder) external;\n\n /**\n * @notice Claim all the comp accrued by holder in the specified markets\n * @param holder The address to claim COMP for\n * @param cTokens The list of markets to claim COMP in\n */\n function claimComp(address holder, address[] calldata cTokens) external;\n\n /**\n * @notice Claim all comp accrued by the holders\n * @param holders The addresses to claim COMP for\n * @param cTokens The list of markets to claim COMP in\n * @param borrowers Whether or not to claim COMP earned by borrowing\n * @param suppliers Whether or not to claim COMP earned by supplying\n */\n function claimComp(\n address[] calldata holders,\n address[] calldata cTokens,\n bool borrowers,\n bool suppliers\n ) external;\n\n /*** Liquidity/Liquidation Calculations ***/\n /**\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\n * @param cTokenBorrowed The address of the borrowed cToken\n * @param cTokenCollateral The address of the collateral cToken\n * @param repayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\n */\n function liquidateCalculateSeizeTokens(\n address cTokenBorrowed,\n address cTokenCollateral,\n uint256 repayAmount\n ) external view returns (uint256, uint256);\n\n /**\n * @notice Return the address of the COMP token\n * @return The address of COMP\n */\n function getCompAddress() external view returns (address);\n}\n" + }, + "@openzeppelin/contracts/utils/math/SafeCast.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\n * checks.\n *\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\n * easily result in undesired exploitation or bugs, since developers usually\n * assume that overflows raise errors. `SafeCast` restores this intuition by\n * reverting the transaction when such an operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n *\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\n * all math on `uint256` and `int256` and then downcasting.\n */\nlibrary SafeCast {\n /**\n * @dev Returns the downcasted uint128 from uint256, reverting on\n * overflow (when the input is greater than largest uint128).\n *\n * Counterpart to Solidity's `uint128` operator.\n *\n * Requirements:\n *\n * - input must fit into 128 bits\n */\n function toUint128(uint256 value) internal pure returns (uint128) {\n require(value < 2**128, \"SafeCast: value doesn\\'t fit in 128 bits\");\n return uint128(value);\n }\n\n /**\n * @dev Returns the downcasted uint64 from uint256, reverting on\n * overflow (when the input is greater than largest uint64).\n *\n * Counterpart to Solidity's `uint64` operator.\n *\n * Requirements:\n *\n * - input must fit into 64 bits\n */\n function toUint64(uint256 value) internal pure returns (uint64) {\n require(value < 2**64, \"SafeCast: value doesn\\'t fit in 64 bits\");\n return uint64(value);\n }\n\n /**\n * @dev Returns the downcasted uint32 from uint256, reverting on\n * overflow (when the input is greater than largest uint32).\n *\n * Counterpart to Solidity's `uint32` operator.\n *\n * Requirements:\n *\n * - input must fit into 32 bits\n */\n function toUint32(uint256 value) internal pure returns (uint32) {\n require(value < 2**32, \"SafeCast: value doesn\\'t fit in 32 bits\");\n return uint32(value);\n }\n\n /**\n * @dev Returns the downcasted uint16 from uint256, reverting on\n * overflow (when the input is greater than largest uint16).\n *\n * Counterpart to Solidity's `uint16` operator.\n *\n * Requirements:\n *\n * - input must fit into 16 bits\n */\n function toUint16(uint256 value) internal pure returns (uint16) {\n require(value < 2**16, \"SafeCast: value doesn\\'t fit in 16 bits\");\n return uint16(value);\n }\n\n /**\n * @dev Returns the downcasted uint8 from uint256, reverting on\n * overflow (when the input is greater than largest uint8).\n *\n * Counterpart to Solidity's `uint8` operator.\n *\n * Requirements:\n *\n * - input must fit into 8 bits.\n */\n function toUint8(uint256 value) internal pure returns (uint8) {\n require(value < 2**8, \"SafeCast: value doesn\\'t fit in 8 bits\");\n return uint8(value);\n }\n\n /**\n * @dev Converts a signed int256 into an unsigned uint256.\n *\n * Requirements:\n *\n * - input must be greater than or equal to 0.\n */\n function toUint256(int256 value) internal pure returns (uint256) {\n require(value >= 0, \"SafeCast: value must be positive\");\n return uint256(value);\n }\n\n /**\n * @dev Returns the downcasted int128 from int256, reverting on\n * overflow (when the input is less than smallest int128 or\n * greater than largest int128).\n *\n * Counterpart to Solidity's `int128` operator.\n *\n * Requirements:\n *\n * - input must fit into 128 bits\n *\n * _Available since v3.1._\n */\n function toInt128(int256 value) internal pure returns (int128) {\n require(value >= -2**127 && value < 2**127, \"SafeCast: value doesn\\'t fit in 128 bits\");\n return int128(value);\n }\n\n /**\n * @dev Returns the downcasted int64 from int256, reverting on\n * overflow (when the input is less than smallest int64 or\n * greater than largest int64).\n *\n * Counterpart to Solidity's `int64` operator.\n *\n * Requirements:\n *\n * - input must fit into 64 bits\n *\n * _Available since v3.1._\n */\n function toInt64(int256 value) internal pure returns (int64) {\n require(value >= -2**63 && value < 2**63, \"SafeCast: value doesn\\'t fit in 64 bits\");\n return int64(value);\n }\n\n /**\n * @dev Returns the downcasted int32 from int256, reverting on\n * overflow (when the input is less than smallest int32 or\n * greater than largest int32).\n *\n * Counterpart to Solidity's `int32` operator.\n *\n * Requirements:\n *\n * - input must fit into 32 bits\n *\n * _Available since v3.1._\n */\n function toInt32(int256 value) internal pure returns (int32) {\n require(value >= -2**31 && value < 2**31, \"SafeCast: value doesn\\'t fit in 32 bits\");\n return int32(value);\n }\n\n /**\n * @dev Returns the downcasted int16 from int256, reverting on\n * overflow (when the input is less than smallest int16 or\n * greater than largest int16).\n *\n * Counterpart to Solidity's `int16` operator.\n *\n * Requirements:\n *\n * - input must fit into 16 bits\n *\n * _Available since v3.1._\n */\n function toInt16(int256 value) internal pure returns (int16) {\n require(value >= -2**15 && value < 2**15, \"SafeCast: value doesn\\'t fit in 16 bits\");\n return int16(value);\n }\n\n /**\n * @dev Returns the downcasted int8 from int256, reverting on\n * overflow (when the input is less than smallest int8 or\n * greater than largest int8).\n *\n * Counterpart to Solidity's `int8` operator.\n *\n * Requirements:\n *\n * - input must fit into 8 bits.\n *\n * _Available since v3.1._\n */\n function toInt8(int256 value) internal pure returns (int8) {\n require(value >= -2**7 && value < 2**7, \"SafeCast: value doesn\\'t fit in 8 bits\");\n return int8(value);\n }\n\n /**\n * @dev Converts an unsigned uint256 into a signed int256.\n *\n * Requirements:\n *\n * - input must be less than or equal to maxInt256.\n */\n function toInt256(uint256 value) internal pure returns (int256) {\n require(value < 2**255, \"SafeCast: value doesn't fit in an int256\");\n return int256(value);\n }\n}\n" + }, + "contracts/price-aggregator/chainlink/ChainlinkLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\n// Storage\nimport {\n PriceAggStorageLib,\n ChainlinkAggStorage\n} from \"../../storage/price-aggregator.sol\";\n\nlibrary ChainlinkLib {\n function s() internal view returns (ChainlinkAggStorage storage) {\n return PriceAggStorageLib.store().chainlink;\n }\n\n /**\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\n * @param src Source token address.\n * @param dst Destination token address.\n * @return aggregator The Chainlink Aggregator address.\n * @return found whether or not the ChainlinkAggregator exists.\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\n */\n function aggregatorFor(address src, address dst)\n internal\n view\n returns (\n address aggregator,\n bool found,\n bool inverse\n )\n {\n aggregator = s().aggregators[src][dst];\n if (aggregator != address(0)) {\n found = true;\n } else {\n aggregator = s().aggregators[dst][src];\n if (aggregator != address(0)) {\n found = true;\n inverse = true;\n }\n }\n }\n\n /**\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\n * @param token Token address to check if is supported.\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\n */\n function isTokenSupported(address token)\n internal\n view\n returns (bool isSupported_)\n {\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\n }\n}\n" + }, + "contracts/shared/libraries/CompoundLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Interfaces\nimport { ICErc20 } from \"../interfaces/ICErc20.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../storage/app.sol\";\n\n/**\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\n *\n * @author develop@teller.finance\n */\nlibrary CompoundLib {\n /**\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\n */\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\n\n function exchangeRate(address cToken) internal view returns (uint256) {\n return ICErc20(cToken).exchangeRateStored();\n }\n\n /**\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\n * @param cToken Address of the Compound token.\n * @param cTokenAmount Amount of the Compound asset.\n * @return value of the Compound token amount in underlying tokens.\n */\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\n internal\n view\n returns (uint256)\n {\n return\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\n EXCHANGE_RATE_SCALE;\n }\n\n /**\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\n * @param cToken Address of the Compound token.\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\n * @return value of the underlying amount in Compound tokens.\n */\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\n internal\n view\n returns (uint256)\n {\n return\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\n ICErc20(cToken).exchangeRateStored();\n }\n\n function isCompoundToken(address token) internal view returns (bool) {\n return AppStorageLib.store().cTokenRegistry[token];\n }\n\n /**\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\n * @dev CETH is the only Compound token that does not support the {underlying} function.\n * @param cToken address of the compound token\n * @return address of the underlying cToken\n */\n function getUnderlying(address cToken) internal view returns (address) {\n (bool success, bytes memory data) =\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\n if (success) {\n return abi.decode(data, (address));\n }\n\n return AppStorageLib.store().assetAddresses[\"WETH\"];\n }\n}\n" + }, + "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./AggregatorInterface.sol\";\nimport \"./AggregatorV3Interface.sol\";\n\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\n{\n}\n" + }, + "@openzeppelin/contracts/token/ERC20/ERC20.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IERC20.sol\";\nimport \"./extensions/IERC20Metadata.sol\";\nimport \"../../utils/Context.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * We have followed general OpenZeppelin guidelines: functions revert instead\n * of returning `false` on failure. This behavior is nonetheless conventional\n * and does not conflict with the expectations of ERC20 applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20 is Context, IERC20, IERC20Metadata {\n mapping (address => uint256) private _balances;\n\n mapping (address => mapping (address => uint256)) private _allowances;\n\n uint256 private _totalSupply;\n\n string private _name;\n string private _symbol;\n\n /**\n * @dev Sets the values for {name} and {symbol}.\n *\n * The defaut value of {decimals} is 18. To select a different value for\n * {decimals} you should overload it.\n *\n * All two of these values are immutable: they can only be set once during\n * construction.\n */\n constructor (string memory name_, string memory symbol_) {\n _name = name_;\n _symbol = symbol_;\n }\n\n /**\n * @dev Returns the name of the token.\n */\n function name() public view virtual override returns (string memory) {\n return _name;\n }\n\n /**\n * @dev Returns the symbol of the token, usually a shorter version of the\n * name.\n */\n function symbol() public view virtual override returns (string memory) {\n return _symbol;\n }\n\n /**\n * @dev Returns the number of decimals used to get its user representation.\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\n *\n * Tokens usually opt for a value of 18, imitating the relationship between\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\n * overridden;\n *\n * NOTE: This information is only used for _display_ purposes: it in\n * no way affects any of the arithmetic of the contract, including\n * {IERC20-balanceOf} and {IERC20-transfer}.\n */\n function decimals() public view virtual override returns (uint8) {\n return 18;\n }\n\n /**\n * @dev See {IERC20-totalSupply}.\n */\n function totalSupply() public view virtual override returns (uint256) {\n return _totalSupply;\n }\n\n /**\n * @dev See {IERC20-balanceOf}.\n */\n function balanceOf(address account) public view virtual override returns (uint256) {\n return _balances[account];\n }\n\n /**\n * @dev See {IERC20-transfer}.\n *\n * Requirements:\n *\n * - `recipient` cannot be the zero address.\n * - the caller must have a balance of at least `amount`.\n */\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\n _transfer(_msgSender(), recipient, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-allowance}.\n */\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\n return _allowances[owner][spender];\n }\n\n /**\n * @dev See {IERC20-approve}.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\n _approve(_msgSender(), spender, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-transferFrom}.\n *\n * Emits an {Approval} event indicating the updated allowance. This is not\n * required by the EIP. See the note at the beginning of {ERC20}.\n *\n * Requirements:\n *\n * - `sender` and `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n * - the caller must have allowance for ``sender``'s tokens of at least\n * `amount`.\n */\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\n _transfer(sender, recipient, amount);\n\n uint256 currentAllowance = _allowances[sender][_msgSender()];\n require(currentAllowance >= amount, \"ERC20: transfer amount exceeds allowance\");\n _approve(sender, _msgSender(), currentAllowance - amount);\n\n return true;\n }\n\n /**\n * @dev Atomically increases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\n return true;\n }\n\n /**\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `spender` must have allowance for the caller of at least\n * `subtractedValue`.\n */\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n uint256 currentAllowance = _allowances[_msgSender()][spender];\n require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\n\n return true;\n }\n\n /**\n * @dev Moves tokens `amount` from `sender` to `recipient`.\n *\n * This is internal function is equivalent to {transfer}, and can be used to\n * e.g. implement automatic token fees, slashing mechanisms, etc.\n *\n * Emits a {Transfer} event.\n *\n * Requirements:\n *\n * - `sender` cannot be the zero address.\n * - `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n */\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\n require(sender != address(0), \"ERC20: transfer from the zero address\");\n require(recipient != address(0), \"ERC20: transfer to the zero address\");\n\n _beforeTokenTransfer(sender, recipient, amount);\n\n uint256 senderBalance = _balances[sender];\n require(senderBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n _balances[sender] = senderBalance - amount;\n _balances[recipient] += amount;\n\n emit Transfer(sender, recipient, amount);\n }\n\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n * the total supply.\n *\n * Emits a {Transfer} event with `from` set to the zero address.\n *\n * Requirements:\n *\n * - `to` cannot be the zero address.\n */\n function _mint(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: mint to the zero address\");\n\n _beforeTokenTransfer(address(0), account, amount);\n\n _totalSupply += amount;\n _balances[account] += amount;\n emit Transfer(address(0), account, amount);\n }\n\n /**\n * @dev Destroys `amount` tokens from `account`, reducing the\n * total supply.\n *\n * Emits a {Transfer} event with `to` set to the zero address.\n *\n * Requirements:\n *\n * - `account` cannot be the zero address.\n * - `account` must have at least `amount` tokens.\n */\n function _burn(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: burn from the zero address\");\n\n _beforeTokenTransfer(account, address(0), amount);\n\n uint256 accountBalance = _balances[account];\n require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n _balances[account] = accountBalance - amount;\n _totalSupply -= amount;\n\n emit Transfer(account, address(0), amount);\n }\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n *\n * This internal function is equivalent to `approve`, and can be used to\n * e.g. set automatic allowances for certain subsystems, etc.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `owner` cannot be the zero address.\n * - `spender` cannot be the zero address.\n */\n function _approve(address owner, address spender, uint256 amount) internal virtual {\n require(owner != address(0), \"ERC20: approve from the zero address\");\n require(spender != address(0), \"ERC20: approve to the zero address\");\n\n _allowances[owner][spender] = amount;\n emit Approval(owner, spender, amount);\n }\n\n /**\n * @dev Hook that is called before any transfer of tokens. This includes\n * minting and burning.\n *\n * Calling conditions:\n *\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n * will be to transferred to `to`.\n * - when `from` is zero, `amount` tokens will be minted for `to`.\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n * - `from` and `to` are never both zero.\n *\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n */\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\n}\n" + }, + "contracts/storage/price-aggregator.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\nstruct ChainlinkAggStorage {\n // Maps source token => destination token => Chainlink Aggregator\n mapping(address => mapping(address => address)) aggregators;\n // Maps token address to number of supported Chainlink pairs\n mapping(address => uint256) pairCount;\n // Stores set of token addresses supported by Chainlink\n EnumerableSet.AddressSet supportedTokens;\n}\n\nstruct PriceAggStorage {\n ChainlinkAggStorage chainlink;\n}\n\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\n \"teller.price.aggregator.storage\"\n);\n\nlibrary PriceAggStorageLib {\n function store() internal pure returns (PriceAggStorage storage s) {\n bytes32 pos = PRICE_AGG_STORAGE_POS;\n assembly {\n s.slot := pos\n }\n }\n}\n" + }, + "@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface AggregatorInterface {\n function latestAnswer()\n external\n view\n returns (\n int256\n );\n \n function latestTimestamp()\n external\n view\n returns (\n uint256\n );\n\n function latestRound()\n external\n view\n returns (\n uint256\n );\n\n function getAnswer(\n uint256 roundId\n )\n external\n view\n returns (\n int256\n );\n\n function getTimestamp(\n uint256 roundId\n )\n external\n view\n returns (\n uint256\n );\n\n event AnswerUpdated(\n int256 indexed current,\n uint256 indexed roundId,\n uint256 updatedAt\n );\n\n event NewRound(\n uint256 indexed roundId,\n address indexed startedBy,\n uint256 startedAt\n );\n}\n" + }, + "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface AggregatorV3Interface {\n\n function decimals()\n external\n view\n returns (\n uint8\n );\n\n function description()\n external\n view\n returns (\n string memory\n );\n\n function version()\n external\n view\n returns (\n uint256\n );\n\n // getRoundData and latestRoundData should both raise \"No data present\"\n // if they do not have data to report, instead of returning unset values\n // which could be misinterpreted as actual reported values.\n function getRoundData(\n uint80 _roundId\n )\n external\n view\n returns (\n uint80 roundId,\n int256 answer,\n uint256 startedAt,\n uint256 updatedAt,\n uint80 answeredInRound\n );\n\n function latestRoundData()\n external\n view\n returns (\n uint80 roundId,\n int256 answer,\n uint256 startedAt,\n uint256 updatedAt,\n uint80 answeredInRound\n );\n\n}\n" + }, + "@openzeppelin/contracts/token/ERC20/IERC20.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address recipient, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\n\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n" + }, + "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n /**\n * @dev Returns the name of the token.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the symbol of the token.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the decimals places of the token.\n */\n function decimals() external view returns (uint8);\n}\n" + }, + "contracts/settings/pausable/PausableMods.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AppStorageLib } from \"../../storage/app.sol\";\n\nabstract contract PausableMods {\n /**\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\n * @param id id of the facet to check if is paused.\n * @param state Boolean that the protocol AND facet should be in.\n */\n modifier paused(bytes32 id, bool state) {\n require(\n __isPaused(\"\") == state && __isPaused(id) == state,\n __pausedMessage(state)\n );\n _;\n }\n\n /**\n * @dev Checks if the given id is paused.\n * @param id Encoded id of the facet to check if is paused.\n * @return the bool to tell us if the facet is paused (true) or not (false)\n */\n function __isPaused(bytes32 id) private view returns (bool) {\n return AppStorageLib.store().paused[id];\n }\n\n /**\n * @dev Gets the message that should be reverted with given a state it should be in.\n * @param state Boolean that an id should be in.\n * @return a message stating whether the facet is paused or not\n */\n function __pausedMessage(bool state) private pure returns (string memory) {\n return state ? \"Pausable: not paused\" : \"Pausable: paused\";\n }\n}\n" + }, + "contracts/contexts2/access-control/reentry/ReentryMods.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlStorageLib, AccessControlStorage } from \"../storage.sol\";\n\nabstract contract ReentryMods {\n modifier nonReentry(bytes32 id) {\n AccessControlStorage storage s = AccessControlStorageLib.store();\n require(!s.entered[id], \"AccessControl: reentered\");\n s.entered[id] = true;\n _;\n s.entered[id] = false;\n }\n}\n" + }, + "contracts/lending/ttoken/ITToken.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport {\n ERC20Upgradeable\n} from \"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\";\nimport { ERC20 } from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\nimport {\n RolesFacet\n} from \"../../contexts2/access-control/roles/RolesFacet.sol\";\n\n/**\n * @notice This contract acts as an interface for the Teller token (TToken).\n *\n * @author develop@teller.finance\n */\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\n /**\n * @notice This event is emitted when a user deposits tokens into the pool.\n */\n event Mint(\n address indexed sender,\n uint256 tTokenAmount,\n uint256 underlyingAmount\n );\n\n /**\n * @notice This event is emitted when a user withdraws tokens from the pool.\n */\n event Redeem(\n address indexed sender,\n uint256 tTokenAmount,\n uint256 underlyingAmount\n );\n\n /**\n * @notice The token that is the underlying assets for this Teller token.\n * @return ERC20 token\n */\n function underlying() external view virtual returns (ERC20);\n\n /**\n * @notice The balance of an {account} denoted in underlying value.\n * @param account Address to calculate the underlying balance.\n * @return balance_ the balance of the account\n */\n function balanceOfUnderlying(address account)\n external\n virtual\n returns (uint256 balance_);\n\n /**\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\n * @return rate_ The current exchange rate.\n */\n function exchangeRate() external virtual returns (uint256 rate_);\n\n /**\n * @notice It calculates the total supply of the underlying asset.\n * @return totalSupply_ the total supply denoted in the underlying asset.\n */\n function totalUnderlyingSupply()\n external\n virtual\n returns (uint256 totalSupply_);\n\n /**\n * @notice It calculates the market state values across a given market.\n * @notice Returns values that represent the global state across the market.\n * @return totalSupplied Total amount of the underlying asset supplied.\n * @return totalBorrowed Total amount borrowed through loans.\n * @return totalRepaid The total amount repaid till the current timestamp.\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\n * @return totalOnLoan Total amount currently deployed in loans.\n */\n function getMarketState()\n external\n virtual\n returns (\n uint256 totalSupplied,\n uint256 totalBorrowed,\n uint256 totalRepaid,\n uint256 totalInterestRepaid,\n uint256 totalOnLoan\n );\n\n /**\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\n * @return tvl_ The value locked in the pool.\n *\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\n */\n function currentTVL() external virtual returns (uint256 tvl_);\n\n /**\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\n * @param newLoanAmount the new loan amount to consider the StD ratio.\n * @return ratio_ Whether debt ratio for lending pool is valid.\n */\n function debtRatioFor(uint256 newLoanAmount)\n external\n virtual\n returns (uint16 ratio_);\n \n\n /**\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\n * @param recipient The account to send the funds to.\n * @param amount Funds requested to fulfill the loan.\n */\n function fundLoan(address recipient, uint256 amount) external virtual;\n\n /**\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\n * @param interestAmount Interest value paid into the pool from a loan.\n */\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\n\n /**\n * @notice Increase account supply of specified token amount.\n * @param amount The amount of underlying tokens to use to mint.\n * @return mintAmount_ the amount minted of the specified token\n */\n function mint(uint256 amount)\n external\n virtual\n returns (uint256 mintAmount_);\n\n /**\n * @notice Redeem supplied Teller token underlying value.\n * @param amount The amount of Teller tokens to redeem.\n */\n function redeem(uint256 amount) external virtual;\n\n /**\n * @notice Redeem supplied underlying value.\n * @param amount The amount of underlying tokens to redeem.\n */\n function redeemUnderlying(uint256 amount) external virtual;\n\n /**\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\n *\n * See {TTokenStrategy}.\n */\n function rebalance() external virtual;\n\n /**\n * @notice Sets a new strategy to use for balancing funds.\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\n * @param initData Optional data to initialize the strategy.\n *\n * Requirements:\n * - Sender must have ADMIN role\n */\n function setStrategy(address strategy, bytes calldata initData)\n external\n virtual;\n\n /**\n * @notice Gets the strategy used for balancing funds.\n * @return address of the strategy contract\n */\n function getStrategy() external view virtual returns (address);\n\n /**\n * @notice Sets the restricted state of the platform.\n * @param state boolean value that resembles the platform's state\n */\n function restrict(bool state) external virtual;\n\n /**\n * @notice it initializes the Teller Token\n * @param admin address of the admin to the respective Teller Token\n * @param underlying address of the ERC20 token\n */\n function initialize(address admin, address underlying) external virtual;\n}\n" + }, + "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\nimport \"../../../utils/Address.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n using Address for address;\n\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n }\n\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\n }\n\n /**\n * @dev Deprecated. This function has issues similar to the ones found in\n * {IERC20-approve}, and its usage is discouraged.\n *\n * Whenever possible, use {safeIncreaseAllowance} and\n * {safeDecreaseAllowance} instead.\n */\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\n // safeApprove should only be called when setting an initial allowance,\n // or when resetting it to zero. To increase and decrease it, use\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\n // solhint-disable-next-line max-line-length\n require((value == 0) || (token.allowance(address(this), spender) == 0),\n \"SafeERC20: approve from non-zero to non-zero allowance\"\n );\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\n }\n\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n uint256 newAllowance = token.allowance(address(this), spender) + value;\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n }\n\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n unchecked {\n uint256 oldAllowance = token.allowance(address(this), spender);\n require(oldAllowance >= value, \"SafeERC20: decreased allowance below zero\");\n uint256 newAllowance = oldAllowance - value;\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n }\n }\n\n /**\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n * on the return value: the return value is optional (but if data is returned, it must not be false).\n * @param token The token targeted by the call.\n * @param data The call data (encoded using abi.encode or one of its variants).\n */\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\n // the target address contains contract code and also asserts for success in the low-level call.\n\n bytes memory returndata = address(token).functionCall(data, \"SafeERC20: low-level call failed\");\n if (returndata.length > 0) { // Return data is optional\n // solhint-disable-next-line max-line-length\n require(abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n }\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20Upgradeable.sol\";\nimport \"../../../utils/AddressUpgradeable.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20Upgradeable {\n using AddressUpgradeable for address;\n\n function safeTransfer(IERC20Upgradeable token, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n }\n\n function safeTransferFrom(IERC20Upgradeable token, address from, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\n }\n\n /**\n * @dev Deprecated. This function has issues similar to the ones found in\n * {IERC20-approve}, and its usage is discouraged.\n *\n * Whenever possible, use {safeIncreaseAllowance} and\n * {safeDecreaseAllowance} instead.\n */\n function safeApprove(IERC20Upgradeable token, address spender, uint256 value) internal {\n // safeApprove should only be called when setting an initial allowance,\n // or when resetting it to zero. To increase and decrease it, use\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\n // solhint-disable-next-line max-line-length\n require((value == 0) || (token.allowance(address(this), spender) == 0),\n \"SafeERC20: approve from non-zero to non-zero allowance\"\n );\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\n }\n\n function safeIncreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\n uint256 newAllowance = token.allowance(address(this), spender) + value;\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n }\n\n function safeDecreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\n unchecked {\n uint256 oldAllowance = token.allowance(address(this), spender);\n require(oldAllowance >= value, \"SafeERC20: decreased allowance below zero\");\n uint256 newAllowance = oldAllowance - value;\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n }\n }\n\n /**\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n * on the return value: the return value is optional (but if data is returned, it must not be false).\n * @param token The token targeted by the call.\n * @param data The call data (encoded using abi.encode or one of its variants).\n */\n function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\n // the target address contains contract code and also asserts for success in the low-level call.\n\n bytes memory returndata = address(token).functionCall(data, \"SafeERC20: low-level call failed\");\n if (returndata.length > 0) { // Return data is optional\n // solhint-disable-next-line max-line-length\n require(abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n }\n }\n}\n" + }, + "contracts/lending/libraries/LendingLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport { NumbersLib } from \"../../shared/libraries/NumbersLib.sol\";\n\n// Interfaces\nimport { ITToken } from \"../ttoken/ITToken.sol\";\n\n// Storage\nimport { MarketStorageLib, MarketStorage } from \"../../storage/market.sol\";\n\nlibrary LendingLib {\n bytes32 internal constant ID = keccak256(\"LENDING\");\n\n function s() internal pure returns (MarketStorage storage) {\n return MarketStorageLib.store();\n }\n\n function tToken(address asset) internal view returns (ITToken tToken_) {\n tToken_ = s().tTokens[asset];\n }\n}" + }, + "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IERC20Upgradeable.sol\";\nimport \"./extensions/IERC20MetadataUpgradeable.sol\";\nimport \"../../utils/ContextUpgradeable.sol\";\nimport \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * We have followed general OpenZeppelin guidelines: functions revert instead\n * of returning `false` on failure. This behavior is nonetheless conventional\n * and does not conflict with the expectations of ERC20 applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\n mapping (address => uint256) private _balances;\n\n mapping (address => mapping (address => uint256)) private _allowances;\n\n uint256 private _totalSupply;\n\n string private _name;\n string private _symbol;\n\n /**\n * @dev Sets the values for {name} and {symbol}.\n *\n * The defaut value of {decimals} is 18. To select a different value for\n * {decimals} you should overload it.\n *\n * All two of these values are immutable: they can only be set once during\n * construction.\n */\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\n __Context_init_unchained();\n __ERC20_init_unchained(name_, symbol_);\n }\n\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\n _name = name_;\n _symbol = symbol_;\n }\n\n /**\n * @dev Returns the name of the token.\n */\n function name() public view virtual override returns (string memory) {\n return _name;\n }\n\n /**\n * @dev Returns the symbol of the token, usually a shorter version of the\n * name.\n */\n function symbol() public view virtual override returns (string memory) {\n return _symbol;\n }\n\n /**\n * @dev Returns the number of decimals used to get its user representation.\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\n *\n * Tokens usually opt for a value of 18, imitating the relationship between\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\n * overridden;\n *\n * NOTE: This information is only used for _display_ purposes: it in\n * no way affects any of the arithmetic of the contract, including\n * {IERC20-balanceOf} and {IERC20-transfer}.\n */\n function decimals() public view virtual override returns (uint8) {\n return 18;\n }\n\n /**\n * @dev See {IERC20-totalSupply}.\n */\n function totalSupply() public view virtual override returns (uint256) {\n return _totalSupply;\n }\n\n /**\n * @dev See {IERC20-balanceOf}.\n */\n function balanceOf(address account) public view virtual override returns (uint256) {\n return _balances[account];\n }\n\n /**\n * @dev See {IERC20-transfer}.\n *\n * Requirements:\n *\n * - `recipient` cannot be the zero address.\n * - the caller must have a balance of at least `amount`.\n */\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\n _transfer(_msgSender(), recipient, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-allowance}.\n */\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\n return _allowances[owner][spender];\n }\n\n /**\n * @dev See {IERC20-approve}.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\n _approve(_msgSender(), spender, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-transferFrom}.\n *\n * Emits an {Approval} event indicating the updated allowance. This is not\n * required by the EIP. See the note at the beginning of {ERC20}.\n *\n * Requirements:\n *\n * - `sender` and `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n * - the caller must have allowance for ``sender``'s tokens of at least\n * `amount`.\n */\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\n _transfer(sender, recipient, amount);\n\n uint256 currentAllowance = _allowances[sender][_msgSender()];\n require(currentAllowance >= amount, \"ERC20: transfer amount exceeds allowance\");\n _approve(sender, _msgSender(), currentAllowance - amount);\n\n return true;\n }\n\n /**\n * @dev Atomically increases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\n return true;\n }\n\n /**\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `spender` must have allowance for the caller of at least\n * `subtractedValue`.\n */\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n uint256 currentAllowance = _allowances[_msgSender()][spender];\n require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\n\n return true;\n }\n\n /**\n * @dev Moves tokens `amount` from `sender` to `recipient`.\n *\n * This is internal function is equivalent to {transfer}, and can be used to\n * e.g. implement automatic token fees, slashing mechanisms, etc.\n *\n * Emits a {Transfer} event.\n *\n * Requirements:\n *\n * - `sender` cannot be the zero address.\n * - `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n */\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\n require(sender != address(0), \"ERC20: transfer from the zero address\");\n require(recipient != address(0), \"ERC20: transfer to the zero address\");\n\n _beforeTokenTransfer(sender, recipient, amount);\n\n uint256 senderBalance = _balances[sender];\n require(senderBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n _balances[sender] = senderBalance - amount;\n _balances[recipient] += amount;\n\n emit Transfer(sender, recipient, amount);\n }\n\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n * the total supply.\n *\n * Emits a {Transfer} event with `from` set to the zero address.\n *\n * Requirements:\n *\n * - `to` cannot be the zero address.\n */\n function _mint(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: mint to the zero address\");\n\n _beforeTokenTransfer(address(0), account, amount);\n\n _totalSupply += amount;\n _balances[account] += amount;\n emit Transfer(address(0), account, amount);\n }\n\n /**\n * @dev Destroys `amount` tokens from `account`, reducing the\n * total supply.\n *\n * Emits a {Transfer} event with `to` set to the zero address.\n *\n * Requirements:\n *\n * - `account` cannot be the zero address.\n * - `account` must have at least `amount` tokens.\n */\n function _burn(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: burn from the zero address\");\n\n _beforeTokenTransfer(account, address(0), amount);\n\n uint256 accountBalance = _balances[account];\n require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n _balances[account] = accountBalance - amount;\n _totalSupply -= amount;\n\n emit Transfer(account, address(0), amount);\n }\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n *\n * This internal function is equivalent to `approve`, and can be used to\n * e.g. set automatic allowances for certain subsystems, etc.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `owner` cannot be the zero address.\n * - `spender` cannot be the zero address.\n */\n function _approve(address owner, address spender, uint256 amount) internal virtual {\n require(owner != address(0), \"ERC20: approve from the zero address\");\n require(spender != address(0), \"ERC20: approve to the zero address\");\n\n _allowances[owner][spender] = amount;\n emit Approval(owner, spender, amount);\n }\n\n /**\n * @dev Hook that is called before any transfer of tokens. This includes\n * minting and burning.\n *\n * Calling conditions:\n *\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n * will be to transferred to `to`.\n * - when `from` is zero, `amount` tokens will be minted for `to`.\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n * - `from` and `to` are never both zero.\n *\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n */\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\n uint256[45] private __gap;\n}\n" + }, + "contracts/contexts2/access-control/roles/RolesFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { RolesMods } from \"./RolesMods.sol\";\nimport { RolesLib } from \"./RolesLib.sol\";\nimport { ADMIN } from \"../../../shared/roles.sol\";\n\ncontract RolesFacet is RolesMods {\n /**\n * @notice Checks if an account has a specific role.\n * @param role Encoding of the role to check.\n * @param account Address to check the {role} for.\n */\n function hasRole(bytes32 role, address account)\n external\n view\n returns (bool)\n {\n return RolesLib.hasRole(role, account);\n }\n\n /**\n * @notice Grants an account a new role.\n * @param role Encoding of the role to give.\n * @param account Address to give the {role} to.\n *\n * Requirements:\n * - Sender must be role admin.\n */\n function grantRole(bytes32 role, address account)\n external\n authorized(ADMIN, msg.sender)\n {\n RolesLib.grantRole(role, account);\n }\n\n /**\n * @notice Removes a role from an account.\n * @param role Encoding of the role to remove.\n * @param account Address to remove the {role} from.\n *\n * Requirements:\n * - Sender must be role admin.\n */\n function revokeRole(bytes32 role, address account)\n external\n authorized(ADMIN, msg.sender)\n {\n RolesLib.revokeRole(role, account);\n }\n\n /**\n * @notice Removes a role from the sender.\n * @param role Encoding of the role to remove.\n */\n function renounceRole(bytes32 role) external {\n RolesLib.revokeRole(role, msg.sender);\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20Upgradeable {\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address recipient, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\n\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20Upgradeable.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\n /**\n * @dev Returns the name of the token.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the symbol of the token.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the decimals places of the token.\n */\n function decimals() external view returns (uint8);\n}\n" + }, + "contracts/shared/libraries/NumbersLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/**\n * @dev Utility library for uint256 numbers\n *\n * @author develop@teller.finance\n */\nlibrary NumbersLib {\n /**\n * @dev It represents 100% with 2 decimal places.\n */\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\n\n /**\n * @notice Returns a percentage value of a number.\n * @param self The number to get a percentage of.\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\n */\n function percent(uint256 self, uint16 percentage)\n internal\n pure\n returns (uint256)\n {\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\n }\n\n function percent(int256 self, uint256 percentage)\n internal\n pure\n returns (int256)\n {\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\n }\n\n /**\n * @notice it returns the absolute number of a specified parameter\n * @param self the number to be returned in it's absolute \n * @return the absolute number\n */\n function abs(int256 self) internal pure returns (uint256) {\n return self >= 0 ? uint256(self) : uint256(-1 * self);\n }\n\n /**\n * @notice Returns a ratio percentage of {num1} to {num2}.\n * @param num1 The number used to get the ratio for.\n * @param num2 The number used to get the ratio from.\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\n */\n function ratioOf(uint256 num1, uint256 num2)\n internal\n pure\n returns (uint16)\n {\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\n }\n}\n" + }, + "contracts/storage/market.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport { Counters } from \"@openzeppelin/contracts/utils/Counters.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\nimport \"../shared/libraries/NumbersList.sol\";\n\n// Interfaces\nimport { ILoansEscrow } from \"../escrow/escrow/ILoansEscrow.sol\";\nimport { ICollateralEscrow } from \"../market/collateral/ICollateralEscrow.sol\";\nimport { ITToken } from \"../lending/ttoken/ITToken.sol\";\n\n// DEPRECATED\nstruct LoanTerms {\n // Max size the loan max be taken out with\n uint256 maxLoanAmount;\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\n uint32 termsExpiry;\n}\n\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\n\nstruct Loan {\n // Account that owns the loan\n address payable borrower;\n // The asset lent out for the loan\n address lendingToken;\n // The token used as collateral for the loan\n address collateralToken;\n // The total amount of the loan size taken out\n uint256 borrowedAmount;\n // The id of the loan for internal tracking\n uint128 id;\n // How long in seconds until the loan must be repaid\n uint32 duration;\n // The timestamp at which the loan became active\n uint32 loanStartTime;\n // The interest rate given for repaying the loan\n uint16 interestRate;\n // Ratio used to determine amount of collateral required based on the collateral asset price\n uint16 collateralRatio;\n // The status of the loan\n LoanStatus status;\n}\n\nstruct LoanDebt {\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\n uint256 principalOwed;\n // The total interest owed by the borrower for the loan, reduces on loan repayments\n uint256 interestOwed;\n}\n\nstruct LoanRequest {\n LoanUserRequest request;\n LoanConsensusResponse[] responses;\n}\n\n/**\n * @notice Borrower request object to take out a loan\n * @param borrower The wallet address of the borrower\n * @param assetAddress The address of the asset for the requested loan\n * @param amount The amount of tokens requested by the borrower for the loan\n * @param requestNonce The nonce of the borrower wallet address required for authentication\n * @param duration The length of time in seconds that the loan has been requested for\n * @param requestTime The timestamp at which the loan was requested\n */\nstruct LoanUserRequest {\n address payable borrower;\n address assetAddress;\n uint256 amount;\n uint32 requestNonce;\n uint32 duration;\n uint32 requestTime;\n}\n\n/**\n * @notice Borrower response object to take out a loan\n * @param signer The wallet address of the signer validating the interest request of the lender\n * @param assetAddress The address of the asset for the requested loan\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\n * @param responseTime The timestamp at which the response was sent\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\n * @param signature The signature generated by the signer in the format of the above Signature struct\n */\nstruct LoanConsensusResponse {\n address signer;\n address assetAddress;\n uint256 maxLoanAmount;\n uint32 responseTime;\n uint16 interestRate;\n uint16 collateralRatio;\n Signature signature;\n}\n\n/**\n * @notice Represents a user signature\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\n */\nstruct Signature {\n uint8 v;\n bytes32 r;\n bytes32 s;\n}\n\nstruct MarketStorage {\n // Holds the index for the next loan ID\n Counters.Counter loanIDCounter;\n // Maps loanIDs to loan data\n mapping(uint256 => Loan) loans;\n // Maps loanID to loan debt (total owed left)\n mapping(uint256 => LoanDebt) loanDebt;\n // Maps loanID to loan terms\n mapping(uint256 => LoanTerms) _loanTerms; // DEPRECATED: DO NOT REMOVE\n // Maps loanIDs to escrow address to list of held tokens\n mapping(uint256 => ILoansEscrow) loanEscrows;\n // Maps loanIDs to list of tokens owned by a loan escrow\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\n mapping(address => ICollateralEscrow) collateralEscrows;\n // Maps accounts to owned loan IDs\n mapping(address => uint128[]) borrowerLoans;\n // Maps lending token to overall amount of interest collected from loans\n mapping(address => ITToken) tTokens;\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\n mapping(address => EnumerableSet.AddressSet) signers;\n // Maps lending token to list of allowed collateral tokens\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\n}\n\nbytes32 constant MARKET_STORAGE_POS = keccak256(\"teller.market.storage\");\n\nlibrary MarketStorageLib {\n function store() internal pure returns (MarketStorage storage s) {\n bytes32 pos = MARKET_STORAGE_POS;\n assembly {\n s.slot := pos\n }\n }\n}\n" + }, + "contracts/shared/libraries/NumbersList.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/utils/math/SafeMath.sol\";\nimport \"./NumbersLib.sol\";\n\n/**\n * @dev Utility library of inline functions on NumbersList.Values\n *\n * @author develop@teller.finance\n */\nlibrary NumbersList {\n using NumbersLib for uint256;\n\n // Holds values to calculate the threshold of a list of numbers\n struct Values {\n uint256 count; // The total number of numbers added\n uint256 max; // The maximum number that was added\n uint256 min; // The minimum number that was added\n uint256 sum; // The total sum of the numbers that were added\n }\n\n /**\n * @dev Add to the sum while keeping track of min and max values\n * @param self The Value this function was called on\n * @param newValue Number to increment sum by\n */\n function addValue(Values memory self, uint256 newValue) internal pure {\n if (self.max < newValue) {\n self.max = newValue;\n }\n if (self.min > newValue || self.count == 0) {\n self.min = newValue;\n }\n self.sum = self.sum + (newValue);\n self.count = self.count + 1;\n }\n\n /**\n * @param self The Value this function was called on\n * @return the number of times the sum has updated\n */\n function valuesCount(Values memory self) internal pure returns (uint256) {\n return self.count;\n }\n\n /**\n * @dev Checks if the sum has been changed\n * @param self The Value this function was called on\n * @return boolean\n */\n function isEmpty(Values memory self) internal pure returns (bool) {\n return valuesCount(self) == 0;\n }\n\n /**\n * @param self The Value this function was called on\n * @return the average number that was used to calculate the sum\n */\n function getAverage(Values memory self) internal pure returns (uint256) {\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\n }\n\n /**\n * @dev Checks if the min and max numbers are within the acceptable tolerance\n * @param self The Value this function was called on\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\n * @return boolean\n */\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\n internal\n pure\n returns (bool)\n {\n if (isEmpty(self)) {\n return false;\n }\n uint256 average = getAverage(self);\n uint256 toleranceAmount = average.percent(tolerancePercentage);\n\n uint256 minTolerance = average - toleranceAmount;\n if (self.min < minTolerance) {\n return false;\n }\n\n uint256 maxTolerance = average + toleranceAmount;\n if (self.max > maxTolerance) {\n return false;\n }\n return true;\n }\n}\n" + }, + "contracts/escrow/escrow/ILoansEscrow.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface ILoansEscrow {\n function init() external;\n\n /**\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\n * @param dappAddress address of the target contract address\n * @param dappData encoded abi of the function in our contract we want to call\n * @return the called data in bytes\n */\n function callDapp(address dappAddress, bytes calldata dappData)\n external\n returns (bytes memory);\n\n /**\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\n * @param token address of the respective ERC20 token to approve for the spender\n * @param spender address of the respective spender who is approved by the token contract\n */\n function setTokenAllowance(address token, address spender) external;\n\n /**\n * @notice it allows user to claim their escrow tokens\n * @dev only the owner (TellerDiamond) can make this call on behalf of the users\n * @param token address of the respective token contract to claim tokens from\n * @param to address where the tokens should be transferred to\n * @param amount uint256 amount of tokens to be claimed\n */\n function claimToken(\n address token,\n address to,\n uint256 amount\n ) external;\n}\n" + }, + "contracts/market/collateral/ICollateralEscrow.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface ICollateralEscrow {\n /**\n * @notice it initializes an escrow\n * @param tokenAddress the address of the collateral token to be stored\n * @param isWETH check if it's wrapped Ethereum\n */\n function init(address tokenAddress, bool isWETH) external;\n\n /**\n * @notice it deposits an amount of the respective collateral token into the escrow\n * @param loanID the ID of the loan\n * @param amount the amount of collateral tokens to be deposited\n */\n function deposit(uint256 loanID, uint256 amount) external payable;\n\n /**\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\n * @dev only the TellerDiamond can make this call on behalf of the borrower\n * @param loanID identifier of the loan\n * @param amount number of collateral tokens to send\n * @param receiver payable address to transfer money to\n */\n function withdraw(\n uint256 loanID,\n uint256 amount,\n address payable receiver\n ) external;\n\n /**\n * @notice it returns the supply of the respective loan\n * @param loanID the respective loan ID\n * @return supply_ the amount in collateral of the respective loan\n */\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\n\n /**\n * @notice it returns the total supply of the collateral token held by the contract\n * @return supply_ the total amount of collateral\n */\n function totalSupply() external view returns (uint256 supply_);\n}\n" + }, + "contracts/market/libraries/LibLoans.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport { LibEscrow } from \"../../escrow/libraries/LibEscrow.sol\";\nimport { NumbersLib } from \"../../shared/libraries/NumbersLib.sol\";\nimport {\n PlatformSettingsLib\n} from \"../../settings/platform/libraries/PlatformSettingsLib.sol\";\nimport { PriceAggLib } from \"../../price-aggregator/PriceAggLib.sol\";\n\n// Storage\nimport {\n MarketStorageLib,\n MarketStorage,\n Loan,\n LoanStatus,\n LoanDebt,\n LoanTerms\n} from \"../../storage/market.sol\";\n\nlibrary LibLoans {\n using NumbersLib for int256;\n using NumbersLib for uint256;\n\n bytes32 internal constant ID = keccak256(\"LOANS\");\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\n\n function s() internal pure returns (MarketStorage storage) {\n return MarketStorageLib.store();\n }\n\n /**\n * @notice it returns the loan\n * @param loanID the ID of the respective loan\n * @return l_ the loan \n */\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\n l_ = s().loans[loanID];\n }\n\n /**\n * @notice it returns the loan debt from a respective loan\n * @param loanID the ID of the respective loan\n * @return d_ the loan debt from a respective loan\n */\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\n d_ = s().loanDebt[loanID];\n }\n\n // DEPRECATED\n function terms(uint256 loanID)\n internal\n view\n returns (LoanTerms storage t_)\n {\n t_ = s()._loanTerms[loanID];\n }\n\n /**\n * @notice Returns the total amount owed for a specified loan.\n * @param loanID The loan ID to get the total amount owed.\n * @return owed_ uint256 The total owed amount.\n */\n function getTotalOwed(uint256 loanID)\n internal\n view\n returns (uint256 owed_)\n {\n if (loan(loanID).status == LoanStatus.Active) {\n owed_ = debt(loanID).principalOwed + (debt(loanID).interestOwed);\n }\n }\n\n /**\n * @notice Returns the amount of interest owed for a given loan and loan amount.\n * @param loanID The loan ID to get the owed interest.\n * @param amountBorrow The principal of the loan to take out.\n * @return uint256 The interest owed.\n */\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\n internal\n view\n returns (uint256)\n {\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\n }\n \n function getCollateralNeeded(uint256 loanID)\n internal\n view\n returns (uint256 _needed)\n {\n (, _needed, ) = getCollateralNeededInfo(loanID);\n }\n\n /**\n * @notice it returns the total collateral needed in lending tokens, in collateral tokens and in escrowed loan values\n * @param loanID the loanID to get the total collateral needed\n * @return neededInLendingTokens total collateral needed in lending tokens\n * @return neededInCollateralTokens total collateral needed in collateral tokens\n * @return escrowLoanValue total collateral needed in loan value\n */\n function getCollateralNeededInfo(uint256 loanID)\n internal\n view\n returns (\n uint256 neededInLendingTokens,\n uint256 neededInCollateralTokens,\n uint256 escrowLoanValue\n )\n {\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\n loanID\n );\n\n // check if needed lending tokens is zero. if true, then needed collateral tokens is zero. else,\n if (neededInLendingTokens == 0) {\n neededInCollateralTokens = 0;\n } else {\n neededInCollateralTokens = PriceAggLib.valueFor(\n loan(loanID).lendingToken,\n loan(loanID).collateralToken,\n neededInLendingTokens\n );\n }\n }\n\n /**\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\n * @param loanID The loan ID to get needed collateral info for.\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\n */\n function getCollateralNeededInTokens(uint256 loanID)\n internal\n view\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\n {\n if (loan(loanID).collateralRatio == 0) {\n return (0, 0);\n }\n\n /*\n The collateral to principal owed ratio is the sum of:\n * collateral buffer percent\n * loan interest rate\n * liquidation reward percent\n * X factor of additional collateral\n */\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\n if (loan(loanID).status == LoanStatus.TermsSet) {\n neededInLendingTokens = loan(loanID).borrowedAmount.percent(\n loan(loanID).collateralRatio\n );\n } else if (loan(loanID).status == LoanStatus.Active) {\n uint16 requiredRatio =\n loan(loanID).collateralRatio -\n getInterestRatio(loanID) -\n uint16(PlatformSettingsLib.getCollateralBufferValue());\n\n neededInLendingTokens =\n debt(loanID).principalOwed +\n debt(loanID).interestOwed;\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\n if (\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\n ) {\n neededInLendingTokens -= escrowLoanValue;\n }\n neededInLendingTokens = neededInLendingTokens.percent(\n requiredRatio\n );\n }\n }\n\n /**\n * @notice check if a loan can go to end of auction with a collateral ratio\n * @return bool checking if collateralRatio is >= the over collateralized buffer value\n */\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\n internal\n view\n returns (bool)\n {\n return\n collateralRatio >=\n PlatformSettingsLib.getOverCollateralizedBufferValue();\n }\n\n /**\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\n * @notice There is a minimum threshold of 1%.\n * @dev The interest rate is APY (annual percentage yield).\n * @param loanID The loan ID to get the interest rate for.\n */\n function getInterestRatio(uint256 loanID)\n internal\n view\n returns (uint16 ratio_)\n {\n ratio_ = uint16(\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\n SECONDS_PER_YEAR\n );\n\n if (ratio_ == 0) {\n ratio_ = 1;\n }\n }\n}\n" + }, + "contracts/market/libraries/LibCollateral.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Interfaces\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\nimport { ICollateralEscrow } from \"../collateral/ICollateralEscrow.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../storage/app.sol\";\nimport { MarketStorageLib } from \"../../storage/market.sol\";\n\nlibrary LibCollateral {\n /**\n * @notice This event is emitted when collateral has been deposited for the loan\n * @param loanID ID of the loan for which collateral was deposited\n * @param depositor Account that deposited funds\n * @param amount Amount of collateral deposited\n */\n event CollateralDeposited(\n uint256 indexed loanID,\n address indexed depositor,\n uint256 amount\n );\n\n /**\n * @notice This event is emitted when collateral has been withdrawn\n * @param loanID ID of loan from which collateral was withdrawn\n * @param receiver Account that received funds\n * @param amount Value of collateral withdrawn\n */\n event CollateralWithdrawn(\n uint256 indexed loanID,\n address indexed receiver,\n uint256 amount\n );\n\n /**\n * @notice it gets MarketStorage's collateral escrow using the loanID\n * @param loanID the loanID to be used\n * @return c_ which is the collateral escrow\n */\n function e(uint256 loanID) internal view returns (ICollateralEscrow c_) {\n c_ = MarketStorageLib.store().collateralEscrows[\n MarketStorageLib.store().loans[loanID].collateralToken\n ];\n }\n\n function e(address token) internal view returns (ICollateralEscrow c_) {\n c_ = MarketStorageLib.store().collateralEscrows[token];\n }\n\n /**\n * @notice it deposits an amount of collateral into a collateral escrow's address of a respective loan\n * @param loanID the respective loan ID\n * @param amount the amount of collateral to deposit\n */\n function deposit(uint256 loanID, uint256 amount) internal {\n e(loanID).deposit{ value: amount }(loanID, amount);\n\n emit CollateralDeposited(loanID, msg.sender, amount);\n }\n\n /**\n * @notice it withdraws an amount from the collateral escrow\n * @param loanID the respective loanID to withdraw from\n * @param amount the number of collateral tokens to withdraw\n * @param receiver the address who receives the withdrawal\n */\n function withdraw(\n uint256 loanID,\n uint256 amount,\n address payable receiver\n ) internal {\n e(loanID).withdraw(loanID, amount, receiver);\n\n emit CollateralWithdrawn(loanID, receiver, amount);\n }\n\n /**\n * @notice it withdraws the entire supply in collateral of a respective loan to an address\n * @param loanID the respective loan's ID\n * @param receiver the address of the receiver to withdraw tokens from\n */\n function withdrawAll(uint256 loanID, address payable receiver) internal {\n withdraw(loanID, e(loanID).loanSupply(loanID), receiver);\n }\n\n /**\n * @notice it initializes a new escrow collateral to hold collateral tokens\n * @param token address of the collateral token it holds\n */\n function createEscrow(address token) internal {\n // Check if collateral escrow exists\n if (address(e(token)) == address(0)) {\n // Create escrow\n address escrow =\n AppStorageLib.store().collateralEscrowBeacon.cloneProxy(\"\");\n ICollateralEscrow(escrow).init(\n token,\n // Check if collateral token is WETH\n token == AppStorageLib.store().assetAddresses[\"WETH\"]\n );\n\n // Set max allowance\n IERC20(token).approve(escrow, type(uint256).max);\n // Save escrow address for loan\n MarketStorageLib.store().collateralEscrows[\n token\n ] = ICollateralEscrow(escrow);\n }\n }\n}\n" + }, + "contracts/market/libraries/LibConsensus.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AppStorageLib } from \"../../storage/app.sol\";\nimport {\n MarketStorageLib,\n MarketStorage,\n LoanRequest,\n LoanUserRequest,\n LoanConsensusResponse,\n Signature\n} from \"../../storage/market.sol\";\nimport { NumbersLib } from \"../../shared/libraries/NumbersLib.sol\";\nimport { NumbersList } from \"../../shared/libraries/NumbersList.sol\";\nimport {\n PlatformSettingsLib\n} from \"../../settings/platform/libraries/PlatformSettingsLib.sol\";\nimport { ECDSA } from \"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\";\nimport { RolesLib } from \"../../contexts2/access-control/roles/RolesLib.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\nlibrary LibConsensus {\n using NumbersList for NumbersList.Values;\n\n /**\n * @notice Represents loan terms based on consensus values\n * @param interestRate The consensus value for the interest rate based on all the loan responses from the signers\n * @param collateralRatio The consensus value for the ratio of collateral to loan amount required for the loan, based on all the loan responses from the signers\n * @param maxLoanAmount The consensus value for the largest amount of tokens that can be taken out in the loan, based on all the loan responses from the signers\n */\n struct AccruedLoanTerms {\n NumbersList.Values interestRate;\n NumbersList.Values collateralRatio;\n NumbersList.Values maxLoanAmount;\n }\n\n function s() private pure returns (MarketStorage storage) {\n return MarketStorageLib.store();\n }\n\n /**\n * @notice it processes a loan terms by doing multiple checks on the LoanRequest request and LoanResponse[] responses\n * @param request LoanRequest is the borrower request object to take out a loan\n * @return interestRate the borrower needs to pay back\n * @return collateralRatio the ratio of collateral the borrower needs to put up for the loan with an underlying asset\n * @return maxLoanAmount the borrower is entitled for\n */\n function processLoanTerms(LoanRequest calldata request)\n internal\n view\n returns (\n uint16 interestRate,\n uint16 collateralRatio,\n uint256 maxLoanAmount\n )\n {\n // get the signers from the asset address\n EnumerableSet.AddressSet storage signers =\n s().signers[request.request.assetAddress];\n\n require(\n uint256(\n NumbersLib.ratioOf(\n request.responses.length,\n EnumerableSet.length(signers)\n )\n ) >= PlatformSettingsLib.getRequiredSubmissionsPercentageValue(),\n \"Teller: insufficient signer responses\"\n );\n \n _validateLoanRequest(\n request.request.borrower,\n request.request.requestNonce\n );\n\n uint32 chainId = _getChainId();\n bytes32 requestHash = _hashRequest(request.request, chainId);\n\n // create term submissions for every response ...\n AccruedLoanTerms memory termSubmissions;\n\n for (uint256 i = 0; i < request.responses.length; i++) {\n LoanConsensusResponse memory response = request.responses[i];\n\n // check if the signers contains the response's signer\n require(\n EnumerableSet.contains(signers, response.signer),\n \"Teller: invalid signer\"\n );\n\n // check if the request's asset address equates to the response's asset address\n require(\n response.assetAddress == request.request.assetAddress,\n \"Teller: consensus address mismatch\"\n );\n\n // check if consensus response has expired\n require(\n uint256(response.responseTime) >=\n block.timestamp -\n PlatformSettingsLib.getTermsExpiryTimeValue(),\n \"Teller: consensus response expired\"\n );\n\n // check if the signature of hashed response data matches\n require(\n _signatureValid(\n response.signature,\n _hashResponse(requestHash, response, chainId),\n response.signer\n ),\n \"Teller: response signature invalid\"\n );\n\n // TODO: use a local AddressArrayLib instead to save gas\n for (uint8 j = 0; j < i; j++) {\n require(\n response.signer != request.responses[j].signer,\n \"Teller: dup signer response\"\n );\n }\n\n termSubmissions.interestRate.addValue(response.interestRate);\n termSubmissions.collateralRatio.addValue(response.collateralRatio);\n termSubmissions.maxLoanAmount.addValue(response.maxLoanAmount);\n }\n\n // get maximum tolerance value in order to receive the interestRate, collateralRatio and maxLoanAmount\n uint16 tolerance =\n uint16(PlatformSettingsLib.getMaximumToleranceValue());\n interestRate = uint16(\n _getConsensus(termSubmissions.interestRate, tolerance)\n );\n collateralRatio = uint16(\n _getConsensus(termSubmissions.collateralRatio, tolerance)\n );\n maxLoanAmount = _getConsensus(termSubmissions.maxLoanAmount, tolerance);\n }\n\n /**\n * @dev Checks if the nonce provided in the request is equal to the borrower's number of loans.\n * @dev Also verifies if the borrower has taken out a loan recently (rate limit).\n * @param borrower the borrower's address.\n * @param nonce the nonce included in the loan request.\n */\n function _validateLoanRequest(address borrower, uint256 nonce)\n private\n view\n {\n uint128[] storage borrowerLoans = s().borrowerLoans[borrower];\n uint256 numberOfLoans = borrowerLoans.length;\n\n require(nonce == numberOfLoans, \"Teller: bad request nonce\");\n\n // In case it is the first time that borrower requests loan terms, we don't\n // validate the rate limit.\n if (numberOfLoans == 0) {\n return;\n }\n\n require(\n uint256(\n s().loans[uint256(borrowerLoans[numberOfLoans - 1])]\n .loanStartTime\n ) +\n PlatformSettingsLib.getRequestLoanTermsRateLimitValue() <=\n block.timestamp,\n \"Teller: loan terms rate limit reached\"\n );\n }\n\n /**\n * @notice Gets the current chain id using the opcode 'chainid()'.\n * @return id_ The current chain id.\n */\n function _getChainId() private view returns (uint32 id_) {\n // silence state mutability warning without generating bytecode.\n // see https://github.com/ethereum/solidity/issues/2691\n assembly {\n id_ := chainid()\n }\n }\n\n /**\n * @notice Generates a hash for the loan request\n * @param request Struct of the protocol loan request\n * @return bytes32 Hash of the loan request\n */\n function _hashRequest(LoanUserRequest memory request, uint32 chainId)\n private\n pure\n returns (bytes32)\n {\n return\n keccak256(\n abi.encode(\n request.borrower,\n request.assetAddress,\n request.amount,\n request.requestNonce,\n request.duration,\n request.requestTime,\n chainId\n )\n );\n }\n\n /**\n * @notice Generates a hash for the loan response\n * @param requestHash Hash of the loan request\n * @param response Structs of the protocol loan responses\n * @return bytes32 Hash of the loan response\n */\n function _hashResponse(\n bytes32 requestHash,\n LoanConsensusResponse memory response,\n uint32 chainId\n ) internal pure returns (bytes32) {\n return\n keccak256(\n abi.encode(\n response.assetAddress,\n response.maxLoanAmount,\n requestHash,\n response.responseTime,\n response.interestRate,\n response.collateralRatio,\n chainId\n )\n );\n }\n\n /**\n * @notice It validates whether a signature is valid or not.\n * @param signature signature to validate.\n * @param dataHash used to recover the signer.\n * @param expectedSigner the expected signer address.\n * @return true if the expected signer is equal to the signer. Otherwise it returns false.\n */\n function _signatureValid(\n Signature memory signature,\n bytes32 dataHash,\n address expectedSigner\n ) internal pure returns (bool) {\n return\n expectedSigner ==\n ECDSA.recover(\n keccak256(\n abi.encodePacked(\n \"\\x19Ethereum Signed Message:\\n32\",\n dataHash\n )\n ),\n signature.v,\n signature.r,\n signature.s\n );\n }\n\n /**\n * @notice Gets the consensus value for a list of values (uint values).\n * @notice The values must be in a maximum tolerance range.\n * @return the consensus value.\n */\n function _getConsensus(NumbersList.Values memory values, uint16 tolerance)\n internal\n pure\n returns (uint256)\n {\n require(\n values.isWithinTolerance(tolerance),\n \"Teller: consensus response values too varied\"\n );\n\n return values.getAverage();\n }\n}\n" + }, + "contracts/settings/asset/libraries/MaxDebtRatioLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../../shared/libraries/CacheLib.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions for MaxDebtRatio asset setting.\n *\n * @author develop@teller.finance\n */\nlibrary MaxDebtRatioLib {\n bytes32 private constant NAME = keccak256(\"MaxDebtRatio\");\n\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n function get(address asset) internal view returns (uint16) {\n return uint16(s(asset).uints[NAME]);\n }\n\n function set(address asset, uint16 newValue) internal {\n s(asset).uints[NAME] = uint256(newValue);\n }\n}\n" + }, + "@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IBeacon.sol\";\nimport \"../Proxy.sol\";\nimport \"../ERC1967/ERC1967Upgrade.sol\";\n\n/**\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\n *\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\n * conflict with the storage layout of the implementation behind the proxy.\n *\n * _Available since v3.4._\n */\ncontract BeaconProxy is Proxy, ERC1967Upgrade {\n /**\n * @dev Initializes the proxy with `beacon`.\n *\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\n * constructor.\n *\n * Requirements:\n *\n * - `beacon` must be a contract with the interface {IBeacon}.\n */\n constructor(address beacon, bytes memory data) payable {\n assert(_BEACON_SLOT == bytes32(uint256(keccak256(\"eip1967.proxy.beacon\")) - 1));\n _upgradeBeaconToAndCall(beacon, data, false);\n }\n\n /**\n * @dev Returns the current beacon address.\n */\n function _beacon() internal view virtual returns (address) {\n return _getBeacon();\n }\n\n /**\n * @dev Returns the current implementation address of the associated beacon.\n */\n function _implementation() internal view virtual override returns (address) {\n return IBeacon(_getBeacon()).implementation();\n }\n\n /**\n * @dev Changes the proxy to use a new beacon. Deprecated: see {_upgradeBeaconToAndCall}.\n *\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\n *\n * Requirements:\n *\n * - `beacon` must be a contract.\n * - The implementation returned by `beacon` must be a contract.\n */\n function _setBeacon(address beacon, bytes memory data) internal virtual {\n _upgradeBeaconToAndCall(beacon, data, false);\n }\n}\n" + }, + "contracts/escrow/libraries/LibEscrow.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport { LibDapps } from \"../dapps/libraries/LibDapps.sol\";\nimport { LibLoans } from \"../../market/libraries/LibLoans.sol\";\nimport { PriceAggLib } from \"../../price-aggregator/PriceAggLib.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\n// Interfaces\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { ILoansEscrow } from \"../escrow/ILoansEscrow.sol\";\n\n// Storage\nimport { MarketStorageLib, MarketStorage } from \"../../storage/market.sol\";\n\nlibrary LibEscrow {\n function s() internal pure returns (MarketStorage storage) {\n return MarketStorageLib.store();\n }\n\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\n e_ = s().loanEscrows[loanID];\n }\n\n function exists(uint256 loanID) internal view returns (bool) {\n return address(e(loanID)) != address(0);\n }\n\n /**\n * @notice It returns a list of tokens owned by a loan escrow\n * @param loanID uint256 index used to return our token list\n * @return t_ which is a list of tokens\n */\n function getEscrowTokens(uint256 loanID)\n internal\n view\n returns (EnumerableSet.AddressSet storage t_)\n {\n t_ = s().escrowTokens[loanID];\n }\n\n /**\n * @notice It returns the balance of a respective token in a loan escrow\n * @param loanID uint256 index used to point to our loan escrow\n * @param token address of respective token to give us the balance of in our loan escrow\n * @return uint256 balance of respective token returned in an escrow loan\n */\n function balanceOf(uint256 loanID, address token)\n internal\n view\n returns (uint256)\n {\n return exists(loanID) ? IERC20(token).balanceOf(address(e(loanID))) : 0;\n }\n\n /**\n * @notice Adds or removes tokens held by the Escrow contract\n * @param loanID The loan ID to update the token list for\n * @param tokenAddress The token address to be added or removed\n */\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\n // Skip if is lending token\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\n\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\n if (balanceOf(loanID, tokenAddress) > 0) {\n if (!contains) {\n EnumerableSet.add(tokens, tokenAddress);\n }\n } else if (contains) {\n EnumerableSet.remove(tokens, tokenAddress);\n }\n }\n\n /**\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\n * @param loanID The loan ID to calculate value for\n * @return value_ Escrow total value denoted in the lending token.\n */\n function calculateTotalValue(uint256 loanID)\n internal\n view\n returns (uint256 value_)\n {\n if (!exists(loanID)) {\n return 0;\n }\n\n address lendingToken = LibLoans.loan(loanID).lendingToken;\n value_ += balanceOf(loanID, lendingToken);\n\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\n if (EnumerableSet.length(tokens) > 0) {\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\n uint256 tokenBal =\n balanceOf(loanID, EnumerableSet.at(tokens, i));\n value_ += PriceAggLib.valueFor(\n EnumerableSet.at(tokens, i),\n lendingToken,\n tokenBal\n );\n }\n }\n }\n}\n" + }, + "contracts/price-aggregator/PriceAggLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { PriceAggFacet } from \"./PriceAggFacet.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../storage/app.sol\";\n\n/**\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\n */\nlibrary PriceAggLib {\n /**\n * @notice It calculates the value of one token amount into another\n * @param src the source token\n * @param dst the destination token\n * @param srcAmount the amount of source token\n * @return value_ the returned value of src in dst\n */\n function valueFor(\n address src,\n address dst,\n uint256 srcAmount\n ) internal view returns (uint256 value_) {\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\n }\n\n /**\n * @notice It returns the price of the token pair as given from Compound.\n * @dev if no compound price is calculated, then it checks Chainlink price Aggregator\n * @param src the address of the source token\n * @param dst the address of the desitnation token\n * @return price_ gets the price of src in dst\n */\n function priceFor(address src, address dst)\n internal\n view\n returns (int256 price_)\n {\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\n }\n}\n" + }, + "contracts/escrow/dapps/libraries/LibDapps.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Interfaces\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { IAToken } from \"../interfaces/IAToken.sol\";\nimport { IAaveLendingPool } from \"../interfaces/IAaveLendingPool.sol\";\nimport {\n IAaveLendingPoolAddressesProvider\n} from \"../interfaces/IAaveLendingPoolAddressesProvider.sol\";\nimport {\n IUniswapV2Router\n} from \"../../../shared/interfaces/IUniswapV2Router.sol\";\nimport { IVault } from \"../interfaces/IVault.sol\";\n\n// Libraries\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\n// Storage\nimport { MarketStorageLib, MarketStorage } from \"../../../storage/market.sol\";\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\nlibrary LibDapps {\n function s() internal pure returns (MarketStorage storage) {\n return MarketStorageLib.store();\n }\n\n /**\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\n @return IAaveLendingPool instance address\n */\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\n return\n IAaveLendingPool(\n IAaveLendingPoolAddressesProvider(\n 0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5\n )\n .getLendingPool()\n ); // LP address provider contract is immutable and the address will never change\n }\n\n /**\n @notice Grabs the aToken instance from the lending pool\n @param tokenAddress The underlying asset address to get the aToken for\n @return IAToken instance\n */\n function getAToken(address tokenAddress) internal view returns (IAToken) {\n return\n IAToken(\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\n );\n }\n\n /**\n @notice Grabs the yVault address for a token from the asset settings\n @param tokenAddress The underlying token address for the associated yVault\n @return yVault instance\n */\n function getYVault(address tokenAddress) internal view returns (IVault) {\n return\n IVault(\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\n keccak256(\"yVaultAddress\")\n ]\n );\n }\n}\n" + }, + "contracts/escrow/dapps/interfaces/IAToken.sol": { + "content": "// SPDX-License-Identifier: agpl-3.0\npragma solidity ^0.8.0;\n\ninterface IAToken {\n /**\n * @dev Mints `amount` aTokens to `user`\n * @param user The address receiving the minted tokens\n * @param amount The amount of tokens getting minted\n * @param index The new liquidity index of the reserve\n * @return `true` if the the previous balance of the user was 0\n */\n function mint(\n address user,\n uint256 amount,\n uint256 index\n ) external returns (bool);\n\n /**\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\n * @param user The owner of the aTokens, getting them burned\n * @param receiverOfUnderlying The address that will receive the underlying\n * @param amount The amount being burned\n * @param index The new liquidity index of the reserve\n **/\n function burn(\n address user,\n address receiverOfUnderlying,\n uint256 amount,\n uint256 index\n ) external;\n\n /**\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\n * assets in borrow(), withdraw() and flashLoan()\n * @param user The recipient of the aTokens\n * @param amount The amount getting transferred\n * @return The amount transferred\n **/\n function transferUnderlyingTo(address user, uint256 amount)\n external\n returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender)\n external\n view\n returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\n * @param user The user whose balance is calculated\n * @return The scaled balance of the user\n **/\n function scaledBalanceOf(address user) external view returns (uint256);\n\n /**\n * @dev Returns the scaled balance of the user and the scaled total supply.\n * @param user The address of the user\n * @return The scaled balance of the user\n * @return The scaled balance and the scaled total supply\n **/\n function getScaledUserBalanceAndSupply(address user)\n external\n view\n returns (uint256, uint256);\n\n /**\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\n * @return The scaled total supply\n **/\n function scaledTotalSupply() external view returns (uint256);\n}\n" + }, + "contracts/escrow/dapps/interfaces/IAaveLendingPool.sol": { + "content": "// SPDX-License-Identifier: agpl-3.0\npragma solidity ^0.8.0;\n\nimport \"./IAaveLendingPoolAddressesProvider.sol\";\nimport \"./DataTypes.sol\";\n\ninterface IAaveLendingPool {\n /**\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\n * @param asset The address of the underlying asset to deposit\n * @param amount The amount to be deposited\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\n * is a different wallet\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\n * 0 if the action is executed directly by the user, without any middle-man\n **/\n function deposit(\n address asset,\n uint256 amount,\n address onBehalfOf,\n uint16 referralCode\n ) external;\n\n /**\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\n * @param asset The address of the underlying asset to withdraw\n * @param amount The underlying amount to be withdrawn\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\n * @param to Address that will receive the underlying, same as msg.sender if the user\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\n * different wallet\n * @return The final amount withdrawn\n **/\n function withdraw(\n address asset,\n uint256 amount,\n address to\n ) external returns (uint256);\n\n /**\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\n * corresponding debt token (StableDebtToken or VariableDebtToken)\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\n * @param asset The address of the underlying asset to borrow\n * @param amount The amount to be borrowed\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\n * 0 if the action is executed directly by the user, without any middle-man\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\n * if he has been given credit delegation allowance\n **/\n function borrow(\n address asset,\n uint256 amount,\n uint256 interestRateMode,\n uint16 referralCode,\n address onBehalfOf\n ) external;\n\n /**\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\n * @param asset The address of the borrowed underlying asset previously borrowed\n * @param amount The amount to repay\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\n * other borrower whose debt should be removed\n * @return The final amount repaid\n **/\n function repay(\n address asset,\n uint256 amount,\n uint256 rateMode,\n address onBehalfOf\n ) external returns (uint256);\n\n /**\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\n * @param asset The address of the underlying asset borrowed\n * @param rateMode The rate mode that the user wants to swap to\n **/\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\n\n /**\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\n * - Users can be rebalanced if the following conditions are satisfied:\n * 1. Usage ratio is above 95%\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\n * borrowed at a stable rate and depositors are not earning enough\n * @param asset The address of the underlying asset borrowed\n * @param user The address of the user to be rebalanced\n **/\n function rebalanceStableBorrowRate(address asset, address user) external;\n\n /**\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\n * @param asset The address of the underlying asset deposited\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\n **/\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\n external;\n\n /**\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\n * @param user The address of the borrower getting liquidated\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\n * to receive the underlying collateral asset directly\n **/\n function liquidationCall(\n address collateralAsset,\n address debtAsset,\n address user,\n uint256 debtToCover,\n bool receiveAToken\n ) external;\n\n /**\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\n * as long as the amount taken plus a fee is returned.\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\n * For further details please visit https://developers.aave.com\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\n * @param assets The addresses of the assets being flash-borrowed\n * @param amounts The amounts amounts being flash-borrowed\n * @param modes Types of the debt to open if the flash loan is not returned:\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\n * @param params Variadic packed params to pass to the receiver as extra information\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\n * 0 if the action is executed directly by the user, without any middle-man\n **/\n function flashLoan(\n address receiverAddress,\n address[] calldata assets,\n uint256[] calldata amounts,\n uint256[] calldata modes,\n address onBehalfOf,\n bytes calldata params,\n uint16 referralCode\n ) external;\n\n /**\n * @dev Returns the user account data across all the reserves\n * @param user The address of the user\n * @return totalCollateralETH the total collateral in ETH of the user\n * @return totalDebtETH the total debt in ETH of the user\n * @return availableBorrowsETH the borrowing power left of the user\n * @return currentLiquidationThreshold the liquidation threshold of the user\n * @return ltv the loan to value of the user\n * @return healthFactor the current health factor of the user\n **/\n function getUserAccountData(address user)\n external\n view\n returns (\n uint256 totalCollateralETH,\n uint256 totalDebtETH,\n uint256 availableBorrowsETH,\n uint256 currentLiquidationThreshold,\n uint256 ltv,\n uint256 healthFactor\n );\n\n /**\n * @dev Returns the configuration of the reserve\n * @param asset The address of the underlying asset of the reserve\n * @return The configuration of the reserve\n **/\n function getConfiguration(address asset)\n external\n view\n returns (DataTypes.ReserveConfigurationMap memory);\n\n /**\n * @dev Returns the configuration of the user across all the reserves\n * @param user The user address\n * @return The configuration of the user\n **/\n function getUserConfiguration(address user)\n external\n view\n returns (DataTypes.UserConfigurationMap memory);\n\n /**\n * @dev Returns the normalized income normalized income of the reserve\n * @param asset The address of the underlying asset of the reserve\n * @return The reserve's normalized income\n */\n function getReserveNormalizedIncome(address asset)\n external\n view\n returns (uint256);\n\n /**\n * @dev Returns the normalized variable debt per unit of asset\n * @param asset The address of the underlying asset of the reserve\n * @return The reserve normalized variable debt\n */\n function getReserveNormalizedVariableDebt(address asset)\n external\n view\n returns (uint256);\n\n /**\n * @dev Returns the state and configuration of the reserve\n * @param asset The address of the underlying asset of the reserve\n * @return The state of the reserve\n **/\n function getReserveData(address asset)\n external\n view\n returns (DataTypes.ReserveData memory);\n\n function finalizeTransfer(\n address asset,\n address from,\n address to,\n uint256 amount,\n uint256 balanceFromAfter,\n uint256 balanceToBefore\n ) external;\n\n function getReservesList() external view returns (address[] memory);\n\n function getAddressesProvider()\n external\n view\n returns (IAaveLendingPoolAddressesProvider);\n\n function paused() external view returns (bool);\n}\n" + }, + "contracts/escrow/dapps/interfaces/IAaveLendingPoolAddressesProvider.sol": { + "content": "// SPDX-License-Identifier: agpl-3.0\npragma solidity ^0.8.0;\n\n/**\n * @title LendingPoolAddressesProvider contract\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\n * - Owned by the Aave Governance\n * @author Aave\n **/\ninterface IAaveLendingPoolAddressesProvider {\n function getMarketId() external view returns (string memory);\n\n function getAddress(bytes32 id) external view returns (address);\n\n function getLendingPool() external view returns (address);\n\n function getPriceOracle() external view returns (address);\n\n function getLendingRateOracle() external view returns (address);\n}\n" + }, + "contracts/escrow/dapps/interfaces/IVault.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/**\n @notice This interface defines the different functions available for a Yearn Vault\n @author develop@teller.finance\n */\n\ninterface IVault {\n /**\n @notice Returns the unwrapped native token address that the Vault takes as deposit\n @return The address of the unwrapped token\n */\n function token() external view returns (address);\n\n /**\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\n @return The name of the wrapped token\n */\n function name() external view returns (string memory);\n\n /**\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\n @return The symbol of the wrapped token\n */\n function symbol() external view returns (string memory);\n\n /**\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\n @return The number of decimals for the token\n */\n function decimals() external view returns (uint8);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n @notice Returns the address of the Vault's controller\n @return The address of the controller contract\n */\n function controller() external view returns (address);\n\n /**\n @notice Returns the address of the Vault's governance contract\n @return The contract address\n */\n function governance() external view returns (address);\n\n /**\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\n @return The token price\n */\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\n\n /**\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\n @return The token price\n */\n function getPricePerShare() external view returns (uint256); // v2 vaults\n\n /**\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\n @param amountToDeposit The amount of tokens to deposit\n */\n function deposit(uint256 amountToDeposit) external;\n\n /**\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\n */\n function depositAll() external;\n\n /**\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\n @param amountToWithdraw The amount to withdraw\n */\n function withdraw(uint256 amountToWithdraw) external;\n\n /**\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\n */\n function withdrawAll() external;\n}\n" + }, + "contracts/escrow/dapps/interfaces/DataTypes.sol": { + "content": "// SPDX-License-Identifier: agpl-3.0\npragma solidity ^0.8.0;\n\nlibrary DataTypes {\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\n struct ReserveData {\n //stores the reserve configuration\n ReserveConfigurationMap configuration;\n //the liquidity index. Expressed in ray\n uint128 liquidityIndex;\n //variable borrow index. Expressed in ray\n uint128 variableBorrowIndex;\n //the current supply rate. Expressed in ray\n uint128 currentLiquidityRate;\n //the current variable borrow rate. Expressed in ray\n uint128 currentVariableBorrowRate;\n //the current stable borrow rate. Expressed in ray\n uint128 currentStableBorrowRate;\n uint40 lastUpdateTimestamp;\n //tokens addresses\n address aTokenAddress;\n address stableDebtTokenAddress;\n address variableDebtTokenAddress;\n //address of the interest rate strategy\n address interestRateStrategyAddress;\n //the id of the reserve. Represents the position in the list of the active reserves\n uint8 id;\n }\n\n struct ReserveConfigurationMap {\n //bit 0-15: LTV\n //bit 16-31: Liq. threshold\n //bit 32-47: Liq. bonus\n //bit 48-55: Decimals\n //bit 56: Reserve is active\n //bit 57: reserve is frozen\n //bit 58: borrowing is enabled\n //bit 59: stable rate borrowing enabled\n //bit 60-63: reserved\n //bit 64-79: reserve factor\n uint256 data;\n }\n\n struct UserConfigurationMap {\n uint256 data;\n }\n\n enum InterestRateMode { NONE, STABLE, VARIABLE }\n}\n" + }, + "@openzeppelin/contracts/utils/cryptography/ECDSA.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\n *\n * These functions can be used to verify that a message was signed by the holder\n * of the private keys of a given address.\n */\nlibrary ECDSA {\n /**\n * @dev Returns the address that signed a hashed message (`hash`) with\n * `signature`. This address can then be used for verification purposes.\n *\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\n * this function rejects them by requiring the `s` value to be in the lower\n * half order, and the `v` value to be either 27 or 28.\n *\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n * verification to be secure: it is possible to craft signatures that\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n * this is by receiving a hash of the original message (which may otherwise\n * be too long), and then calling {toEthSignedMessageHash} on it.\n */\n function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\n // Divide the signature in r, s and v variables\n bytes32 r;\n bytes32 s;\n uint8 v;\n\n // Check the signature length\n // - case 65: r,s,v signature (standard)\n // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._\n if (signature.length == 65) {\n // ecrecover takes the signature parameters, and the only way to get them\n // currently is to use assembly.\n // solhint-disable-next-line no-inline-assembly\n assembly {\n r := mload(add(signature, 0x20))\n s := mload(add(signature, 0x40))\n v := byte(0, mload(add(signature, 0x60)))\n }\n } else if (signature.length == 64) {\n // ecrecover takes the signature parameters, and the only way to get them\n // currently is to use assembly.\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let vs := mload(add(signature, 0x40))\n r := mload(add(signature, 0x20))\n s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)\n v := add(shr(255, vs), 27)\n }\n } else {\n revert(\"ECDSA: invalid signature length\");\n }\n\n return recover(hash, v, r, s);\n }\n\n /**\n * @dev Overload of {ECDSA-recover} that receives the `v`,\n * `r` and `s` signature fields separately.\n */\n function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {\n // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n //\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n // these malleable signatures as well.\n require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, \"ECDSA: invalid signature 's' value\");\n require(v == 27 || v == 28, \"ECDSA: invalid signature 'v' value\");\n\n // If the signature is valid (and not malleable), return the signer address\n address signer = ecrecover(hash, v, r, s);\n require(signer != address(0), \"ECDSA: invalid signature\");\n\n return signer;\n }\n\n /**\n * @dev Returns an Ethereum Signed Message, created from a `hash`. This\n * produces hash corresponding to the one signed with the\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\n * JSON-RPC method as part of EIP-191.\n *\n * See {recover}.\n */\n function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {\n // 32 is the length in bytes of hash,\n // enforced by the type signature above\n return keccak256(abi.encodePacked(\"\\x19Ethereum Signed Message:\\n32\", hash));\n }\n\n /**\n * @dev Returns an Ethereum Signed Typed Data, created from a\n * `domainSeparator` and a `structHash`. This produces hash corresponding\n * to the one signed with the\n * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\n * JSON-RPC method as part of EIP-712.\n *\n * See {recover}.\n */\n function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {\n return keccak256(abi.encodePacked(\"\\x19\\x01\", domainSeparator, structHash));\n }\n}\n" + }, + "@openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.2;\n\nimport \"../beacon/IBeacon.sol\";\nimport \"../../utils/Address.sol\";\nimport \"../../utils/StorageSlot.sol\";\n\n/**\n * @dev This abstract contract provides getters and event emitting update functions for\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\n *\n * _Available since v4.1._\n *\n * @custom:oz-upgrades-unsafe-allow delegatecall\n */\nabstract contract ERC1967Upgrade {\n // This is the keccak-256 hash of \"eip1967.proxy.rollback\" subtracted by 1\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\n\n /**\n * @dev Storage slot with the address of the current implementation.\n * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n /**\n * @dev Emitted when the implementation is upgraded.\n */\n event Upgraded(address indexed implementation);\n\n /**\n * @dev Returns the current implementation address.\n */\n function _getImplementation() internal view returns (address) {\n return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the EIP1967 implementation slot.\n */\n function _setImplementation(address newImplementation) private {\n require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n }\n\n /**\n * @dev Perform implementation upgrade\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeTo(address newImplementation) internal {\n _setImplementation(newImplementation);\n emit Upgraded(newImplementation);\n }\n\n /**\n * @dev Perform implementation upgrade with additional setup call.\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {\n _setImplementation(newImplementation);\n emit Upgraded(newImplementation);\n if (data.length > 0 || forceCall) {\n Address.functionDelegateCall(newImplementation, data);\n }\n }\n\n /**\n * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeToAndCallSecure(address newImplementation, bytes memory data, bool forceCall) internal {\n address oldImplementation = _getImplementation();\n\n // Initial upgrade and setup call\n _setImplementation(newImplementation);\n if (data.length > 0 || forceCall) {\n Address.functionDelegateCall(newImplementation, data);\n }\n\n // Perform rollback test if not already in progress\n StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);\n if (!rollbackTesting.value) {\n // Trigger rollback using upgradeTo from the new implementation\n rollbackTesting.value = true;\n Address.functionDelegateCall(\n newImplementation,\n abi.encodeWithSignature(\n \"upgradeTo(address)\",\n oldImplementation\n )\n );\n rollbackTesting.value = false;\n // Check rollback was effective\n require(oldImplementation == _getImplementation(), \"ERC1967Upgrade: upgrade breaks further upgrades\");\n // Finally reset to the new implementation and log the upgrade\n _setImplementation(newImplementation);\n emit Upgraded(newImplementation);\n }\n }\n\n /**\n * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\n * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\n *\n * Emits a {BeaconUpgraded} event.\n */\n function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {\n _setBeacon(newBeacon);\n emit BeaconUpgraded(newBeacon);\n if (data.length > 0 || forceCall) {\n Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\n }\n }\n\n /**\n * @dev Storage slot with the admin of the contract.\n * This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\n\n /**\n * @dev Emitted when the admin account has changed.\n */\n event AdminChanged(address previousAdmin, address newAdmin);\n\n /**\n * @dev Returns the current admin.\n */\n function _getAdmin() internal view returns (address) {\n return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the EIP1967 admin slot.\n */\n function _setAdmin(address newAdmin) private {\n require(newAdmin != address(0), \"ERC1967: new admin is the zero address\");\n StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\n }\n\n /**\n * @dev Changes the admin of the proxy.\n *\n * Emits an {AdminChanged} event.\n */\n function _changeAdmin(address newAdmin) internal {\n emit AdminChanged(_getAdmin(), newAdmin);\n _setAdmin(newAdmin);\n }\n\n /**\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\n */\n bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\n\n /**\n * @dev Emitted when the beacon is upgraded.\n */\n event BeaconUpgraded(address indexed beacon);\n\n /**\n * @dev Returns the current beacon.\n */\n function _getBeacon() internal view returns (address) {\n return StorageSlot.getAddressSlot(_BEACON_SLOT).value;\n }\n\n /**\n * @dev Stores a new beacon in the EIP1967 beacon slot.\n */\n function _setBeacon(address newBeacon) private {\n require(\n Address.isContract(newBeacon),\n \"ERC1967: new beacon is not a contract\"\n );\n require(\n Address.isContract(IBeacon(newBeacon).implementation()),\n \"ERC1967: beacon implementation is not a contract\"\n );\n StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;\n }\n}\n" + }, + "@openzeppelin/contracts/utils/StorageSlot.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC1967 implementation slot:\n * ```\n * contract ERC1967 {\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n * function _getImplementation() internal view returns (address) {\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n * }\n *\n * function _setImplementation(address newImplementation) internal {\n * require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n * }\n * }\n * ```\n *\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\n */\nlibrary StorageSlot {\n struct AddressSlot {\n address value;\n }\n\n struct BooleanSlot {\n bool value;\n }\n\n struct Bytes32Slot {\n bytes32 value;\n }\n\n struct Uint256Slot {\n uint256 value;\n }\n\n /**\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n */\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\n */\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\n */\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\n */\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n assembly {\n r.slot := slot\n }\n }\n}\n" + }, + "contracts/escrow/EscrowClaimTokens.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { PausableMods } from \"../settings/pausable/PausableMods.sol\";\n\n// Interfaces\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\n// Storage\nimport { MarketStorageLib, LoanStatus } from \"../storage/market.sol\";\n\n// Libraries\nimport { LibLoans } from \"../market/libraries/LibLoans.sol\";\nimport { LibEscrow } from \"./libraries/LibEscrow.sol\";\n\n/**\n * @notice Contains functionality to claim tokens that are in an escrow contract for a loan.\n */\ncontract EscrowClaimTokens is PausableMods {\n /**\n * @notice Notifies when the Escrow's tokens have been claimed.\n * @param recipient address where the tokens where sent to.\n */\n event TokensClaimed(address recipient);\n\n /**\n * @notice Sends the tokens owned by this escrow to the owner.\n * @param loanID The id of the loan being used.\n */\n function claimTokens(uint256 loanID) external paused(\"\", false) {\n require(\n LibLoans.loan(loanID).borrower == msg.sender,\n \"Teller: claim not borrower\"\n );\n require(\n LibLoans.loan(loanID).status == LoanStatus.Closed,\n \"Teller: loan not closed\"\n );\n\n __claimEscrowTokens(loanID);\n }\n\n function __claimEscrowTokens(uint256 loanID) internal {\n __claimToken(loanID, LibLoans.loan(loanID).lendingToken);\n\n EnumerableSet.AddressSet storage tokens =\n MarketStorageLib.store().escrowTokens[loanID];\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\n __claimToken(loanID, EnumerableSet.at(tokens, i));\n }\n\n emit TokensClaimed(msg.sender);\n }\n\n function __claimToken(uint256 loanID, address token) private {\n uint256 balance = LibEscrow.balanceOf(loanID, token);\n if (balance > 0) {\n LibEscrow.e(loanID).claimToken(\n token,\n LibLoans.loan(loanID).borrower,\n balance\n );\n }\n }\n}\n" + }, + "contracts/escrow/dapps/DappMods.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport { LibLoans } from \"../../market/libraries/LibLoans.sol\";\nimport {\n PlatformSettingsLib\n} from \"../../settings/platform/libraries/PlatformSettingsLib.sol\";\n\nabstract contract DappMods {\n /**\n * @notice it checks if the caller to a respective loan escrow is the borrower\n * @param loanID uint256 of the respective loan escrow\n */\n modifier onlyBorrower(uint256 loanID) {\n require(\n msg.sender == LibLoans.loan(loanID).borrower,\n \"Teller: dapp not loan borrower\"\n );\n _;\n }\n \n /**\n * @notice checks if the respective loan escrow is secure\n * @param loanID uint256 of the respective loan escrow\n */\n modifier onlySecured(uint256 loanID) {\n require(\n LibLoans.loan(loanID).collateralRatio >=\n PlatformSettingsLib.getCollateralBufferValue(),\n \"Teller: dapp loan not secured\"\n );\n _;\n }\n}\n" + }, + "contracts/escrow/dapps/libraries/LibCompound.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nlibrary LibCompound {\n // Compound error code for no errors\n uint256 constant NO_ERROR = 0;\n\n // Compound error code when caller does not have sufficient balance in the ERC-20 contract to complete the desired action.\n uint256 constant TOKEN_INSUFFICIENT_BALANCE = 13;\n}\n" + }, + "contracts/escrow/dapps/libraries/LibUniswap.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Interfaces\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport {\n IUniswapV2Router\n} from \"../../../shared/interfaces/IUniswapV2Router.sol\";\n\n// Libraries\nimport {\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\n\nlibrary LibUniswap {\n IUniswapV2Router constant ROUTER =\n IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);\n\n /**\n * @notice Swaps tokens for tokens on Uniswap.\n * @dev {path} must have at least 2 token addresses\n * @param path An array of token addresses.\n * @param sourceAmount amount of source token to swap.\n * @param minDestination The minimum amount of output tokens that must be received for the transaction not to revert.\n * @return amounts is the resulting number of tokens swapped for\n */\n function swap(\n address[] memory path,\n uint256 sourceAmount,\n uint256 minDestination\n ) internal returns (uint256) {\n SafeERC20.safeIncreaseAllowance(\n IERC20(path[0]),\n address(ROUTER),\n sourceAmount\n );\n uint256[] memory amounts =\n ROUTER.swapExactTokensForTokens(\n sourceAmount,\n minDestination,\n path,\n address(this),\n block.timestamp\n );\n\n return amounts[amounts.length - 1];\n }\n}\n" + }, + "contracts/escrow/escrow/LoansEscrow_V1.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\n\n// Interfaces\nimport { ILoansEscrow } from \"./ILoansEscrow.sol\";\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { ICErc20 } from \"../../shared/interfaces/ICErc20.sol\";\n\n// Libraries\nimport {\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport { Address } from \"@openzeppelin/contracts/utils/Address.sol\";\n\n// Proxy\nimport {\n InitializeableBeaconProxy\n} from \"../../shared/proxy/beacon/InitializeableBeaconProxy.sol\";\nimport { IBeacon } from \"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\";\n\ncontract LoansEscrow_V1 is ILoansEscrow {\n address public owner;\n\n modifier onlyOwner {\n require(owner == msg.sender, \"Teller: loan escrow not owner\");\n _;\n }\n\n function init() external override {\n require(owner == address(0), \"Teller: loan escrow already initialized\");\n owner = msg.sender;\n }\n\n /**\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\n * @param dappAddress address of the target contract address\n * @param dappData encoded abi of the function in our contract we want to call\n * @return resData_ the called data in\n */\n function callDapp(address dappAddress, bytes calldata dappData)\n external\n override\n onlyOwner\n returns (bytes memory resData_)\n {\n resData_ = Address.functionCall(\n dappAddress,\n dappData,\n \"Teller: dapp call failed\"\n );\n }\n\n /**\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\n * @param token address of the respective ERC20 token to approve for the spender\n * @param spender address of the respective spender who is approved by the token contract\n */\n function setTokenAllowance(address token, address spender)\n external\n override\n onlyOwner\n {\n IERC20(token).approve(spender, type(uint256).max);\n }\n\n /**\n * @notice it allows user to claim their escrow tokens\n * @dev only the owner (TellerDiamond) can make this call on behalf of their users\n * @param token address of the respective token contract to claim tokens from\n * @param to address where the tokens should be transferred to\n * @param amount uint256 amount of tokens to be claimed\n */\n function claimToken(\n address token,\n address to,\n uint256 amount\n ) external override onlyOwner {\n SafeERC20.safeTransfer(IERC20(token), to, amount);\n }\n}\n" + }, + "contracts/market/collateral/CollateralEscrow_V1.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\";\n\n// Interfaces\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { ICollateralEscrow } from \"./ICollateralEscrow.sol\";\nimport { IWETH } from \"../../shared/interfaces/IWETH.sol\";\n\n// Libraries\nimport {\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport { Address } from \"@openzeppelin/contracts/utils/Address.sol\";\n\ncontract CollateralEscrow_V1 is OwnableUpgradeable, ICollateralEscrow {\n mapping(uint256 => uint256) internal _balances; // loanID -> collateral\n address public collateralToken;\n bool internal _isWETH;\n\n /**\n * @notice it initializes an escrow\n * @param tokenAddress the address of the collateral token to be stored\n * @param isWETH check if it's wrapped Ethereum\n */\n function init(address tokenAddress, bool isWETH) external override {\n require(\n tokenAddress != address(0),\n \"Teller escrow: collateral token address 0\"\n );\n\n OwnableUpgradeable.__Ownable_init();\n collateralToken = tokenAddress;\n _isWETH = isWETH;\n }\n\n /**\n * @notice it deposits an amount of the respective collateral token into the escrow\n * @param loanID the ID of the loan\n * @param amount the amount of collateral tokens to be deposited\n */\n function deposit(uint256 loanID, uint256 amount)\n external\n payable\n override\n onlyOwner\n {\n if (_isWETH && msg.value > 0) {\n require(msg.value == amount, \"Teller: incorrect eth deposit\");\n IWETH(collateralToken).deposit{ value: msg.value }();\n } else {\n SafeERC20.safeTransferFrom(\n IERC20(collateralToken),\n msg.sender,\n address(this),\n amount\n );\n }\n\n _balances[loanID] += amount;\n }\n\n /**\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\n * @dev only the TellerDiamond can make this call on behalf of the borrower\n * @param loanID identifier of the loan\n * @param amount number of collateral tokens to send\n * @param receiver payable address to transfer money to\n */\n function withdraw(\n uint256 loanID,\n uint256 amount,\n address payable receiver\n ) external override onlyOwner {\n require(\n _balances[loanID] >= amount,\n \"Teller escrow: Insufficient collateral balance\"\n );\n\n SafeERC20.safeTransfer(IERC20(collateralToken), receiver, amount);\n _balances[loanID] -= amount;\n }\n\n /**\n * @notice it returns the supply of collateral of the respective loan\n * @param loanID the respective loan ID\n * @return supply_ the amount in collateral of the respective loan\n */\n function loanSupply(uint256 loanID)\n external\n view\n override\n returns (uint256 supply_)\n {\n supply_ = _balances[loanID];\n }\n\n /**\n * @notice it returns the total supply of the collateral token held by the contract\n * @return supply_ the total amount of collateral\n */\n function totalSupply() external view override returns (uint256 supply_) {\n supply_ = IERC20(collateralToken).balanceOf(address(this));\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\n address private _owner;\n\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Initializes the contract setting the deployer as the initial owner.\n */\n function __Ownable_init() internal initializer {\n __Context_init_unchained();\n __Ownable_init_unchained();\n }\n\n function __Ownable_init_unchained() internal initializer {\n address msgSender = _msgSender();\n _owner = msgSender;\n emit OwnershipTransferred(address(0), msgSender);\n }\n\n /**\n * @dev Returns the address of the current owner.\n */\n function owner() public view virtual returns (address) {\n return _owner;\n }\n\n /**\n * @dev Throws if called by any account other than the owner.\n */\n modifier onlyOwner() {\n require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n _;\n }\n\n /**\n * @dev Leaves the contract without owner. It will not be possible to call\n * `onlyOwner` functions anymore. Can only be called by the current owner.\n *\n * NOTE: Renouncing ownership will leave the contract without an owner,\n * thereby removing any functionality that is only available to the owner.\n */\n function renounceOwnership() public virtual onlyOwner {\n emit OwnershipTransferred(_owner, address(0));\n _owner = address(0);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) public virtual onlyOwner {\n require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n emit OwnershipTransferred(_owner, newOwner);\n _owner = newOwner;\n }\n uint256[49] private __gap;\n}\n" + }, + "contracts/shared/interfaces/IWETH.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/**\n * @notice It is the interface of functions that we use for the canonical WETH contract.\n *\n * @author develop@teller.finance\n */\ninterface IWETH {\n /**\n * @notice It withdraws ETH from the contract by sending it to the caller and reducing the caller's internal balance of WETH.\n * @param amount The amount of ETH to withdraw.\n */\n function withdraw(uint256 amount) external;\n\n /**\n * @notice It deposits ETH into the contract and increases the caller's internal balance of WETH.\n */\n function deposit() external payable;\n\n /**\n * @notice It gets the ETH deposit balance of an {account}.\n * @param account Address to get balance of.\n */\n function balanceOf(address account) external view returns (uint256);\n}\n" + }, + "contracts/lending/ttoken/TToken_V1.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport {\n CONTROLLER,\n ADMIN,\n EXCHANGE_RATE_FACTOR,\n ONE_HUNDRED_PERCENT\n} from \"./data.sol\";\nimport { ITTokenStrategy } from \"./strategies/ITTokenStrategy.sol\";\nimport { ERC20 } from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\n\n// Utils\nimport { Address } from \"@openzeppelin/contracts/utils/Address.sol\";\n\n// Interfaces\nimport { ITToken } from \"./ITToken.sol\";\nimport { ICErc20 } from \"../../shared/interfaces/ICErc20.sol\";\n\n// Libraries\nimport {\n IERC20,\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport {\n ERC165Checker\n} from \"@openzeppelin/contracts/utils/introspection/ERC165Checker.sol\";\nimport { RolesLib } from \"../../contexts2/access-control/roles/RolesLib.sol\";\nimport { NumbersLib } from \"../../shared/libraries/NumbersLib.sol\";\n\n// Storage\nimport \"./storage.sol\" as Storage;\n\n/**\n * @notice This contract represents a lending pool for an asset within Teller protocol.\n * @author develop@teller.finance\n */\ncontract TToken_V1 is ITToken {\n function() pure returns (Storage.Store storage) private constant s =\n Storage.store;\n\n /* Modifiers */\n\n /**\n * @notice Checks if the LP is restricted or has the CONTROLLER role.\n *\n * The LP being restricted means that only the Teller protocol may\n * lend/borrow funds.\n */\n modifier notRestricted {\n require(\n !s().restricted || RolesLib.hasRole(CONTROLLER, _msgSender()),\n \"Teller: platform restricted\"\n );\n _;\n }\n\n /* Public Functions */\n\n /**\n * @notice it returns the decimal places of the respective TToken\n * @return decimals of the token\n */\n function decimals() public view override returns (uint8) {\n return s().decimals;\n }\n\n /**\n * @notice The token that is the underlying assets for this Teller token.\n * @return ERC20 token that is the underl\n */\n function underlying() public view override returns (ERC20) {\n return s().underlying;\n }\n\n /**\n * @notice The balance of an {account} denoted in underlying value.\n * @param account Address to calculate the underlying balance.\n * @return balance_ the balance of the account\n */\n function balanceOfUnderlying(address account)\n public\n override\n returns (uint256)\n {\n return _valueInUnderlying(balanceOf(account), exchangeRate());\n }\n\n /**\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\n * @return rate_ The current exchange rate.\n */\n function exchangeRate() public override returns (uint256 rate_) {\n if (totalSupply() == 0) {\n return EXCHANGE_RATE_FACTOR;\n }\n\n rate_ = (currentTVL() * EXCHANGE_RATE_FACTOR) / totalSupply();\n }\n\n /**\n * @notice It calculates the total supply of the underlying asset.\n * @return totalSupply_ the total supply denoted in the underlying asset.\n */\n function totalUnderlyingSupply() public override returns (uint256) {\n bytes memory data =\n _delegateStrategy(\n abi.encodeWithSelector(\n ITTokenStrategy.totalUnderlyingSupply.selector\n )\n );\n return abi.decode(data, (uint256));\n }\n\n /**\n * @notice It calculates the market state values across a given markets.\n * @notice Returns values that represent the global state across the market.\n * @return totalSupplied Total amount of the underlying asset supplied.\n * @return totalBorrowed Total amount borrowed through loans.\n * @return totalRepaid The total amount repaid till the current timestamp.\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\n * @return totalOnLoan Total amount currently deployed in loans.\n */\n function getMarketState()\n external\n override\n returns (\n uint256 totalSupplied,\n uint256 totalBorrowed,\n uint256 totalRepaid,\n uint256 totalInterestRepaid,\n uint256 totalOnLoan\n )\n {\n totalSupplied = totalUnderlyingSupply();\n totalBorrowed = s().totalBorrowed;\n totalRepaid = s().totalRepaid;\n totalInterestRepaid = s().totalInterestRepaid;\n totalOnLoan = totalBorrowed - totalRepaid;\n }\n\n /**\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\n * @return tvl_ The value locked in the pool.\n *\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\n */\n function currentTVL() public override returns (uint256 tvl_) {\n tvl_ += totalUnderlyingSupply();\n tvl_ += s().totalBorrowed;\n tvl_ -= s().totalRepaid;\n }\n\n /**\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\n * @param newLoanAmount the new loan amount to consider the StD ratio.\n * @return ratio_ Whether debt ratio for lending pool is valid.\n */\n function debtRatioFor(uint256 newLoanAmount)\n external\n override\n returns (uint16 ratio_)\n {\n uint256 onLoan = s().totalBorrowed - s().totalRepaid;\n uint256 supplied = totalUnderlyingSupply() + onLoan;\n if (supplied > 0) {\n ratio_ = NumbersLib.ratioOf(onLoan + newLoanAmount, supplied);\n }\n }\n\n /**\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\n * @param recipient The account to send the funds to.\n * @param amount Funds requested to fulfil the loan.\n */\n function fundLoan(address recipient, uint256 amount)\n external\n override\n authorized(CONTROLLER, _msgSender())\n {\n // If TToken is not holding enough funds to cover the loan, call the strategy to try to withdraw\n uint256 balance = s().underlying.balanceOf(address(this));\n if (balance < amount) {\n _delegateStrategy(\n abi.encodeWithSelector(\n ITTokenStrategy.withdraw.selector,\n amount - balance\n )\n );\n }\n\n // Increase total borrowed amount\n s().totalBorrowed += amount;\n\n // Transfer tokens to recipient\n SafeERC20.safeTransfer(s().underlying, recipient, amount);\n }\n\n /**\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\n * @param interestAmount Interest value paid into the pool from a loan.\n */\n function repayLoan(uint256 amount, uint256 interestAmount)\n external\n override\n authorized(CONTROLLER, _msgSender())\n {\n s().totalRepaid += amount;\n s().totalInterestRepaid += interestAmount;\n }\n\n /**\n * @notice Deposit underlying token amount into LP and mint tokens.\n * @param amount The amount of underlying tokens to use to mint.\n * @return Amount of TTokens minted.\n */\n function mint(uint256 amount)\n external\n override\n notRestricted\n returns (uint256)\n {\n require(amount > 0, \"Teller: cannot mint 0\");\n require(\n amount <= s().underlying.balanceOf(_msgSender()),\n \"Teller: insufficient underlying\"\n );\n\n // Calculate amount of tokens to mint\n uint256 mintAmount = _valueOfUnderlying(amount, exchangeRate());\n\n // Transfer tokens from lender\n SafeERC20.safeTransferFrom(\n s().underlying,\n _msgSender(),\n address(this),\n amount\n );\n\n // Mint Teller token value of underlying\n _mint(_msgSender(), mintAmount);\n\n emit Mint(_msgSender(), mintAmount, amount);\n\n return mintAmount;\n }\n\n /**\n * @notice Redeem supplied Teller token underlying value.\n * @param amount The amount of Teller tokens to redeem.\n */\n function redeem(uint256 amount) external override {\n require(amount > 0, \"Teller: cannot withdraw 0\");\n require(\n amount <= balanceOf(_msgSender()),\n \"Teller: redeem amount exceeds balance\"\n );\n\n // Accrue interest and calculate exchange rate\n uint256 underlyingAmount = _valueInUnderlying(amount, exchangeRate());\n require(\n underlyingAmount <= totalUnderlyingSupply(),\n \"Teller: redeem ttoken lp not enough supply\"\n );\n\n // Burn Teller Tokens and transfer underlying\n _redeem(amount, underlyingAmount);\n }\n\n /**\n * @notice Redeem supplied underlying value.\n * @param amount The amount of underlying tokens to redeem.\n */\n function redeemUnderlying(uint256 amount) external override {\n require(amount > 0, \"Teller: cannot withdraw 0\");\n require(\n amount <= totalUnderlyingSupply(),\n \"Teller: redeem ttoken lp not enough supply\"\n );\n\n // Accrue interest and calculate exchange rate\n uint256 rate = exchangeRate();\n uint256 tokenValue = _valueOfUnderlying(amount, rate);\n\n // Make sure sender has adequate balance\n require(\n tokenValue <= balanceOf(_msgSender()),\n \"Teller: redeem amount exceeds balance\"\n );\n\n // Burn Teller Tokens and transfer underlying\n _redeem(tokenValue, amount);\n }\n\n /**\n * @dev Redeem an {amount} of Teller Tokens and transfers {underlyingAmount} to the caller.\n * @param amount Total amount of Teller Tokens to burn.\n * @param underlyingAmount Total amount of underlying asset tokens to transfer to caller.\n *\n * This function should only be called by {redeem} and {redeemUnderlying} after the exchange\n * rate and both token values have been calculated to use.\n */\n function _redeem(uint256 amount, uint256 underlyingAmount) internal {\n // Burn Teller tokens\n _burn(_msgSender(), amount);\n\n // Make sure enough funds are available to redeem\n _delegateStrategy(\n abi.encodeWithSelector(\n ITTokenStrategy.withdraw.selector,\n underlyingAmount\n )\n );\n\n // Transfer funds back to lender\n SafeERC20.safeTransfer(s().underlying, _msgSender(), underlyingAmount);\n\n emit Redeem(_msgSender(), amount, underlyingAmount);\n }\n\n /**\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\n *\n * See {TTokenStrategy}.\n */\n function rebalance() public override {\n _delegateStrategy(\n abi.encodeWithSelector(ITTokenStrategy.rebalance.selector)\n );\n }\n\n /**\n * @notice Sets a new strategy to use for balancing funds.\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\n * @param initData Optional data to initialize the strategy.\n *\n * Requirements:\n * - Sender must have ADMIN role\n */\n function setStrategy(address strategy, bytes calldata initData)\n external\n override\n authorized(ADMIN, _msgSender())\n {\n require(\n ERC165Checker.supportsInterface(\n strategy,\n type(ITTokenStrategy).interfaceId\n ),\n \"Teller: strategy does not support ITTokenStrategy\"\n );\n s().strategy = strategy;\n if (initData.length > 0) {\n _delegateStrategy(initData);\n }\n }\n\n /**\n * @notice Gets the strategy used for balancing funds.\n * @return address of the strategy contract\n */\n function getStrategy() external view override returns (address) {\n return s().strategy;\n }\n\n /**\n * @notice Sets the restricted state of the platform.\n * @param state boolean value that resembles the platform's state\n */\n function restrict(bool state)\n public\n override\n authorized(ADMIN, _msgSender())\n {\n s().restricted = state;\n }\n\n /**\n * @notice it initializes the Teller Token\n * @param admin address of the admin to the respective Teller Token\n * @param underlying address of the ERC20 token\n */\n function initialize(address admin, address underlying)\n external\n override\n initializer\n {\n require(\n Address.isContract(msg.sender),\n \"Teller: controller not contract\"\n );\n require(\n Address.isContract(underlying),\n \"Teller: underlying token not contract\"\n );\n\n RolesLib.grantRole(CONTROLLER, msg.sender);\n RolesLib.grantRole(ADMIN, admin);\n\n s().underlying = ERC20(underlying);\n __ERC20_init(\n string(abi.encodePacked(\"Teller \", s().underlying.name())),\n string(abi.encodePacked(\"t\", s().underlying.symbol()))\n );\n s().decimals = s().underlying.decimals();\n // Platform restricted by default\n s().restricted = true;\n }\n\n /**\n * @notice it retrieves the value of the underlying token\n * @param amount the amount of tokens to calculate the value of\n * @param rate the exchangeRate() to divide with the amount * exchange_rate_factor\n * @return value_ the underlying value of the token amount\n */\n function _valueOfUnderlying(uint256 amount, uint256 rate)\n internal\n pure\n returns (uint256 value_)\n {\n value_ = (amount * EXCHANGE_RATE_FACTOR) / rate;\n }\n\n /**\n * @notice it retrives the value in the underlying tokens\n * \n */\n function _valueInUnderlying(uint256 amount, uint256 rate)\n internal\n pure\n returns (uint256 value_)\n {\n value_ = (amount * (rate)) / EXCHANGE_RATE_FACTOR;\n }\n\n /**\n * @notice Delegates data to call on the strategy contract.\n * @param callData Data to call the strategy contract with.\n *\n * Requirements:\n * - Sender must have ADMIN role\n */\n function _delegateStrategy(bytes memory callData)\n internal\n returns (bytes memory)\n {\n return Address.functionDelegateCall(s().strategy, callData);\n }\n}\n" + }, + "contracts/lending/ttoken/data.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Role ID used to pull funds for the asset it manages (i.e. TellerDiamond)\nbytes32 constant CONTROLLER = keccak256(\"CONTROLLER\");\n// Role ID used to for accounts to call special methods that modify its state\nbytes32 constant ADMIN = keccak256(\"ADMIN\");\n\nuint256 constant EXCHANGE_RATE_FACTOR = 1e18;\nuint256 constant ONE_HUNDRED_PERCENT = 10000;\n" + }, + "contracts/lending/ttoken/strategies/ITTokenStrategy.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface ITTokenStrategy {\n event StrategyRebalanced(\n string indexed strategyName,\n address indexed sender\n );\n\n /**\n * @notice it returns the total supply of an underlying asset in a Teller token.\n * @return uint256 the underlying supply\n */\n function totalUnderlyingSupply() external returns (uint256);\n\n /**\n * @notice it rebalances the underlying asset held by the Teller Token.\n *\n */\n function rebalance() external;\n\n /**\n * @notice it withdraws amount of tokens in a pool\n * @param amount amount to withdraw\n */\n\n function withdraw(uint256 amount) external;\n}\n" + }, + "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165.sol\";\n\n/**\n * @dev Library used to query support of an interface declared via {IERC165}.\n *\n * Note that these functions return the actual result of the query: they do not\n * `revert` if an interface is not supported. It is up to the caller to decide\n * what to do in these cases.\n */\nlibrary ERC165Checker {\n // As per the EIP-165 spec, no interface should ever match 0xffffffff\n bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;\n\n /**\n * @dev Returns true if `account` supports the {IERC165} interface,\n */\n function supportsERC165(address account) internal view returns (bool) {\n // Any contract that implements ERC165 must explicitly indicate support of\n // InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid\n return _supportsERC165Interface(account, type(IERC165).interfaceId) &&\n !_supportsERC165Interface(account, _INTERFACE_ID_INVALID);\n }\n\n /**\n * @dev Returns true if `account` supports the interface defined by\n * `interfaceId`. Support for {IERC165} itself is queried automatically.\n *\n * See {IERC165-supportsInterface}.\n */\n function supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) {\n // query support of both ERC165 as per the spec and support of _interfaceId\n return supportsERC165(account) &&\n _supportsERC165Interface(account, interfaceId);\n }\n\n /**\n * @dev Returns a boolean array where each value corresponds to the\n * interfaces passed in and whether they're supported or not. This allows\n * you to batch check interfaces for a contract where your expectation\n * is that some interfaces may not be supported.\n *\n * See {IERC165-supportsInterface}.\n *\n * _Available since v3.4._\n */\n function getSupportedInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool[] memory) {\n // an array of booleans corresponding to interfaceIds and whether they're supported or not\n bool[] memory interfaceIdsSupported = new bool[](interfaceIds.length);\n\n // query support of ERC165 itself\n if (supportsERC165(account)) {\n // query support of each interface in interfaceIds\n for (uint256 i = 0; i < interfaceIds.length; i++) {\n interfaceIdsSupported[i] = _supportsERC165Interface(account, interfaceIds[i]);\n }\n }\n\n return interfaceIdsSupported;\n }\n\n /**\n * @dev Returns true if `account` supports all the interfaces defined in\n * `interfaceIds`. Support for {IERC165} itself is queried automatically.\n *\n * Batch-querying can lead to gas savings by skipping repeated checks for\n * {IERC165} support.\n *\n * See {IERC165-supportsInterface}.\n */\n function supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) {\n // query support of ERC165 itself\n if (!supportsERC165(account)) {\n return false;\n }\n\n // query support of each interface in _interfaceIds\n for (uint256 i = 0; i < interfaceIds.length; i++) {\n if (!_supportsERC165Interface(account, interfaceIds[i])) {\n return false;\n }\n }\n\n // all interfaces supported\n return true;\n }\n\n /**\n * @notice Query if a contract implements an interface, does not check ERC165 support\n * @param account The address of the contract to query for support of an interface\n * @param interfaceId The interface identifier, as specified in ERC-165\n * @return true if the contract at account indicates support of the interface with\n * identifier interfaceId, false otherwise\n * @dev Assumes that account contains a contract that supports ERC165, otherwise\n * the behavior of this method is undefined. This precondition can be checked\n * with {supportsERC165}.\n * Interface identification is specified in ERC-165.\n */\n function _supportsERC165Interface(address account, bytes4 interfaceId) private view returns (bool) {\n bytes memory encodedParams = abi.encodeWithSelector(IERC165(account).supportsInterface.selector, interfaceId);\n (bool success, bytes memory result) = account.staticcall{ gas: 30000 }(encodedParams);\n if (result.length < 32) return false;\n return success && abi.decode(result, (bool));\n }\n}\n" + }, + "contracts/lending/ttoken/storage.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { ERC20, IERC20 } from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\n\nstruct Store {\n ERC20 underlying;\n address strategy;\n uint256 totalBorrowed;\n uint256 totalRepaid;\n uint256 totalInterestRepaid;\n uint8 decimals;\n bool restricted;\n}\n\nbytes32 constant POSITION = keccak256(\"ttoken.storage.position\");\n\n/**\n * @notice it saves the Store struct in a hashed slot\n */\nfunction store() pure returns (Store storage s_) {\n bytes32 position = POSITION;\n assembly {\n s_.slot := position\n }\n}\n" + }, + "contracts/lending/ttoken/strategies/compound/TTokenCompoundStrategy_1.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// contracts\nimport {\n RolesMods\n} from \"../../../../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN } from \"../../data.sol\";\n\n// Interfaces\nimport { ICErc20 } from \"../../../../shared/interfaces/ICErc20.sol\";\nimport { TTokenStrategy } from \"../TTokenStrategy.sol\";\n\n// Libraries\nimport {\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport { NumbersLib } from \"../../../../shared/libraries/NumbersLib.sol\";\n\n// Storage\nimport \"../../storage.sol\" as TokenStorage;\nimport \"./storage.sol\" as CompoundStorage;\n\ncontract TTokenCompoundStrategy_1 is RolesMods, TTokenStrategy {\n /**\n * @dev it creates a reference to the TToken storage\n */\n function() pure returns (TokenStorage.Store storage)\n private constant tokenStore = TokenStorage.store;\n\n /**\n * @dev it creates a reference to the Compound storage\n */\n function() pure returns (CompoundStorage.Store storage)\n private constant compoundStore = CompoundStorage.store;\n\n string public constant NAME = \"CompoundStrategy_1\";\n\n /* External Functions */\n\n /**\n * @notice it returns the total supply of an underlying asset in a Teller token.\n * @return uint256 the underlying supply\n */\n function totalUnderlyingSupply() external override returns (uint256) {\n return\n tokenStore().underlying.balanceOf(address(this)) +\n compoundStore().cToken.balanceOfUnderlying(address(this));\n }\n\n /**\n * @notice Rebalances the underlying asset held by the Teller Token.\n *\n * This strategy looks at the ratio of held underlying asset balance and balance deposited into\n * Compound. Based on the store {balanceRatioMin} and {balanceRatioMax} values, will deposit\n * (storedRatio > balanceRatioMax) or withdraw to keep the ratio within that range.\n */\n function rebalance() public override {\n (uint256 storedBal, uint256 compoundBal, uint16 storedRatio) =\n _getBalanceInfo();\n if (storedRatio > compoundStore().balanceRatioMax) {\n // Calculate median ratio to rebalance to\n uint16 medianRatio =\n (compoundStore().balanceRatioMax +\n compoundStore().balanceRatioMin) / 2;\n uint256 requiredBal =\n NumbersLib.percent(storedBal + compoundBal, medianRatio);\n uint256 amountToDeposit = storedBal - requiredBal;\n\n // Allow Compound to take underlying tokens\n SafeERC20.safeIncreaseAllowance(\n tokenStore().underlying,\n address(compoundStore().cToken),\n amountToDeposit\n );\n\n // Deposit tokens into Compound\n compoundStore().cToken.mint(amountToDeposit);\n\n emit StrategyRebalanced(NAME, msg.sender);\n } else if (storedRatio < compoundStore().balanceRatioMin) {\n // Withdraw tokens from Compound\n _withdraw(0, storedBal, compoundBal, storedRatio);\n\n emit StrategyRebalanced(NAME, msg.sender);\n }\n }\n\n /**\n * @notice Rebalances the TToken funds by indicating a minimum {amount} of underlying tokens that must be present\n * after the call.\n * @notice If the minimum amount is present, no rebalance happens.\n * @param amount Amount of underlying tokens that must be available.\n */\n function withdraw(uint256 amount) external override {\n (uint256 storedBal, uint256 compoundBal, uint16 storedRatio) =\n _getBalanceInfo();\n if (storedBal < amount) {\n _withdraw(amount, storedBal, compoundBal, storedRatio);\n }\n }\n\n /**\n * @notice it gets balances and the current ratio of the underlying asset stored on the TToken.\n * @return storedBalance_ returns the total stored balance of the current underlying token\n * @return compoundBalance_ returns the total stored balance\n * @return storedRatio_ ratio of current storedBalance_ over storedBalance_ and compoundBalance_\n */\n function _getBalanceInfo()\n internal\n returns (\n uint256 storedBalance_,\n uint256 compoundBalance_,\n uint16 storedRatio_\n )\n {\n storedBalance_ = tokenStore().underlying.balanceOf(address(this));\n compoundBalance_ = compoundStore().cToken.balanceOfUnderlying(\n address(this)\n );\n storedRatio_ = NumbersLib.ratioOf(\n storedBalance_,\n storedBalance_ + compoundBalance_\n );\n }\n\n /**\n * @notice it rebalances funds stored on the TToken by indicating an extra {amount} to withdraw.\n */\n function _withdraw(\n uint256 amount,\n uint256 storedBal,\n uint256 compoundBal,\n uint16 storedRatio\n ) internal {\n // Calculate amount to rebalance\n uint16 medianRatio =\n (compoundStore().balanceRatioMax +\n compoundStore().balanceRatioMin) / 2;\n uint256 requiredBal =\n NumbersLib.percent(\n storedBal + compoundBal - amount,\n medianRatio - storedRatio\n );\n uint256 redeemAmount = requiredBal - storedBal + amount;\n // Withdraw tokens from Compound if needed\n compoundStore().cToken.redeemUnderlying(redeemAmount);\n }\n\n /**\n * @notice Sets the Compound token that should be used to manage the underlying Teller Token asset.\n * @param cTokenAddress Address of the Compound token that has the same underlying asset as the TToken.\n * @param balanceRatioMin Percentage indicating the _ limit of underlying token balance should remain on the TToken\n * @param balanceRatioMax Percentage indicating the _ limit of underlying token balance should remain on the TToken\n */\n function init(\n address cTokenAddress,\n uint16 balanceRatioMin,\n uint16 balanceRatioMax\n ) external {\n compoundStore().cToken = ICErc20(cTokenAddress);\n compoundStore().balanceRatioMin = balanceRatioMin;\n compoundStore().balanceRatioMax = balanceRatioMax;\n }\n}\n" + }, + "contracts/lending/ttoken/strategies/TTokenStrategy.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { ERC165 } from \"@openzeppelin/contracts/utils/introspection/ERC165.sol\";\nimport { ITTokenStrategy } from \"./ITTokenStrategy.sol\";\n\nabstract contract TTokenStrategy is ITTokenStrategy, ERC165 {\n /**\n * @notice it checks if interface is supported according to the ERC165 standard\n * @param interfaceId Id of the interface in question\n */\n function supportsInterface(bytes4 interfaceId)\n public\n view\n override\n returns (bool)\n {\n return\n ERC165.supportsInterface(interfaceId) ||\n interfaceId == type(ITTokenStrategy).interfaceId;\n }\n}\n" + }, + "contracts/lending/ttoken/strategies/compound/storage.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { ICErc20 } from \"../../../../shared/interfaces/ICErc20.sol\";\n\nstruct Store {\n ICErc20 cToken;\n uint16 balanceRatioMax;\n uint16 balanceRatioMin;\n}\n\nbytes32 constant POSITION = keccak256(\n \"ttoken.strategy.compound.storage.position\"\n);\n\nfunction store() pure returns (Store storage s_) {\n bytes32 position = POSITION;\n assembly {\n s_.slot := position\n }\n}\n" + }, + "@openzeppelin/contracts/utils/introspection/ERC165.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n *\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\n */\nabstract contract ERC165 is IERC165 {\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return interfaceId == type(IERC165).interfaceId;\n }\n}\n" + }, + "contracts/settings/asset/libraries/AssetYVaultLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../../shared/libraries/CacheLib.sol\";\nimport { IVault } from \"../../../escrow/dapps/interfaces/IVault.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions for Yearn vault asset setting.\n *\n * @author develop@teller.finance\n */\nlibrary AssetYVaultLib {\n bytes32 private constant NAME = keccak256(\"yVault\");\n\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n function get(address asset) internal view returns (IVault) {\n return IVault(s(asset).addresses[NAME]);\n }\n\n function set(address asset, address newValue) internal {\n s(asset).addresses[NAME] = newValue;\n }\n}\n" + }, + "contracts/escrow/dapps/YearnFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Storage\nimport { DappMods } from \"./DappMods.sol\";\nimport { PausableMods } from \"../../settings/pausable/PausableMods.sol\";\nimport { LibDapps } from \"./libraries/LibDapps.sol\";\nimport { LibEscrow } from \"../libraries/LibEscrow.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport { IVault } from \"./interfaces/IVault.sol\";\n\ncontract YearnFacet is PausableMods, DappMods {\n using SafeERC20 for IERC20;\n\n /**\n @notice This event is emitted when a yVault deposit is invoked successfully\n @param iVault The address of the yVault\n @param amount The amount of funds to deposit\n @param tokenBalanceBeforeDeposit The balance of tokens held after depositing\n @param tokenBalanceAfterDeposit The balance of tokens held after depositing\n */\n event YearnDeposited(\n address tokenAddress,\n address iVault,\n uint256 amount,\n uint256 tokenBalanceBeforeDeposit,\n uint256 tokenBalanceAfterDeposit\n );\n\n /**\n @notice This event is emitted when a yVault withdraw is invoked successfully\n @param underlyingToken The address of the underlying token of the vault\n @param iVault The address of the yVault\n @param amount The amount of funds to withdraw\n @param tokenBalanceBeforeWithdrawal The balance of tokens held before withdrawal\n @param tokenBalanceAfterWithdrawal The balance of tokens held after withdrawal\n */\n event YearnWithdrawn(\n address underlyingToken,\n address iVault,\n uint256 amount,\n uint256 tokenBalanceBeforeWithdrawal,\n uint256 tokenBalanceAfterWithdrawal\n );\n\n /**\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\n @param loanID The id of the loan being used\n @param tokenAddress The address of the token being deposited\n @param amount The amount of tokens to be deposited into the vault\n */\n function yearnDeposit(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n IVault iVault = LibDapps.getYVault(tokenAddress);\n uint256 tokenBalanceBeforeDeposit = iVault.balanceOf(address(this));\n IERC20(tokenAddress).safeApprove(address(iVault), amount);\n\n bytes memory callData = abi.encode(IVault.deposit.selector, amount);\n LibDapps.s().loanEscrows[loanID].callDapp(address(iVault), callData);\n\n uint256 tokenBalanceAfterDeposit = iVault.balanceOf(address(this));\n require(\n tokenBalanceAfterDeposit > tokenBalanceBeforeDeposit,\n \"YEARN_BALANCE_NOT_INCREASED\"\n );\n\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n LibEscrow.tokenUpdated(loanID, address(iVault));\n\n emit YearnDeposited(\n tokenAddress,\n address(iVault),\n amount,\n tokenBalanceBeforeDeposit,\n tokenBalanceAfterDeposit\n );\n }\n\n /**\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\n @param loanID the id of the loan being used\n @param tokenAddress The address of the token being deposited\n @param amount The amount of tokens to be deposited into the vault\n */\n function yearnWithdraw(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n IVault iVault = LibDapps.getYVault(tokenAddress);\n uint256 price = iVault.getPricePerShare();\n uint256 shares = amount / price;\n uint256 tokenBalanceBeforeWithdrawal =\n IERC20(tokenAddress).balanceOf(address(this));\n require(\n shares >= iVault.balanceOf(address(this)),\n \"INSUFFICIENT_DEPOSIT\"\n );\n\n bytes memory callData = abi.encode(IVault.withdraw.selector, shares);\n LibDapps.s().loanEscrows[loanID].callDapp(address(iVault), callData);\n\n uint256 tokenBalanceAfterWithdrawal =\n IERC20(tokenAddress).balanceOf(address(this));\n require(\n tokenBalanceAfterWithdrawal > tokenBalanceBeforeWithdrawal,\n \"WITHDRAWAL_UNSUCCESSFUL\"\n );\n\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n LibEscrow.tokenUpdated(loanID, address(iVault));\n\n emit YearnWithdrawn(\n iVault.token(),\n address(iVault),\n amount,\n tokenBalanceBeforeWithdrawal,\n tokenBalanceAfterWithdrawal\n );\n }\n\n /**\n @notice Redeems all funds from a yVault from a previous deposit\n @param loanID the id of the loan being used\n @param tokenAddress The address of the token being deposited\n */\n function yearnWithdrawAll(uint256 loanID, address tokenAddress)\n public\n paused(\"\", false)\n onlyBorrower(loanID)\n {\n IVault iVault = LibDapps.getYVault(tokenAddress);\n uint256 tokenBalanceBeforeWithdrawal =\n IERC20(tokenAddress).balanceOf(address(this));\n\n bytes memory callData = abi.encode(IVault.withdrawAll.selector);\n LibDapps.s().loanEscrows[loanID].callDapp(address(iVault), callData);\n\n uint256 tokenBalanceAfterWithdrawal =\n IERC20(tokenAddress).balanceOf(address(this));\n require(\n tokenBalanceAfterWithdrawal > tokenBalanceBeforeWithdrawal,\n \"WITHDRAWAL_UNSUCCESSFUL\"\n );\n\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n LibEscrow.tokenUpdated(loanID, address(iVault));\n\n emit YearnWithdrawn(\n iVault.token(),\n address(iVault),\n tokenBalanceBeforeWithdrawal,\n tokenBalanceBeforeWithdrawal,\n tokenBalanceAfterWithdrawal\n );\n }\n}\n" + }, + "contracts/escrow/dapps/PoolTogetherFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Storage\nimport { DappMods } from \"./DappMods.sol\";\nimport { PausableMods } from \"../../settings/pausable/PausableMods.sol\";\nimport { LibDapps } from \"./libraries/LibDapps.sol\";\nimport { LibEscrow } from \"../libraries/LibEscrow.sol\";\nimport {\n AssetPPoolLib\n} from \"../../settings/asset/libraries/AssetPPoolLib.sol\";\nimport { PoolTogetherLib } from \"./libraries/PoolTogetherLib.sol\";\nimport { PrizePoolInterface } from \"./interfaces/PrizePoolInterface.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\n\ncontract PoolTogetherFacet is PausableMods, DappMods {\n using SafeERC20 for IERC20;\n /**\n * @notice This event is emitted every time Pool Together depositTo is invoked successfully.\n * @param tokenAddress address of the underlying token.\n * @param ticketAddress pool ticket token address.\n * @param amount amount of tokens deposited.\n * @param tokenBalance underlying token balance after depositing.\n * @param creditBalanceAfter pool together credit after depositing.\n */\n event PoolTogetherDeposited(\n address indexed tokenAddress,\n address indexed ticketAddress,\n uint256 amount,\n uint256 tokenBalance,\n uint256 creditBalanceAfter\n );\n\n /**\n * @notice This event is emitted every time Pool Together withdrawInstantlyFrom is invoked successfully.\n * @param tokenAddress address of the underlying token.\n * @param ticketAddress pool ticket token address.\n * @param amount amount of tokens to Redeem.\n * @param tokenBalance underlying token balance after Redeem.\n * @param creditBalanceAfter pool together credit after depositing.\n */\n event PoolTogetherWithdrawal(\n address indexed tokenAddress,\n address indexed ticketAddress,\n uint256 amount,\n uint256 tokenBalance,\n uint256 creditBalanceAfter\n );\n\n /**\n * @notice This function deposits the users funds into a Pool Together Prize Pool for a ticket.\n * @param loanID id of the loan being used in the dapp\n * @param tokenAddress address of the token.\n * @param amount of tokens to deposit.\n */\n function poolTogetherDepositTicket(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n require(\n LibEscrow.balanceOf(loanID, tokenAddress) >= amount,\n \"POOL_INSUFFICIENT_UNDERLYING\"\n );\n\n PrizePoolInterface prizePool = AssetPPoolLib.get(tokenAddress);\n\n address ticketAddress = PoolTogetherLib.getTicketAddress(tokenAddress);\n uint256 balanceBefore = LibEscrow.balanceOf(loanID, ticketAddress);\n IERC20(tokenAddress).safeApprove(address(prizePool), amount);\n\n bytes memory callData =\n abi.encode(\n PrizePoolInterface.depositTo.selector,\n address(this),\n amount,\n ticketAddress,\n address(this)\n );\n LibDapps.s().loanEscrows[loanID].callDapp(address(prizePool), callData);\n\n uint256 balanceAfter = LibEscrow.balanceOf(loanID, ticketAddress);\n require(balanceAfter > balanceBefore, \"DEPOSIT_ERROR\");\n\n LibEscrow.tokenUpdated(loanID, address(ticketAddress));\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n\n emit PoolTogetherDeposited(\n tokenAddress,\n ticketAddress,\n amount,\n balanceBefore,\n balanceAfter\n );\n }\n\n /**\n * @notice This function withdraws the users funds from a Pool Together Prize Pool.\n * @param loanID id of the loan being used in the dapp\n * @param tokenAddress address of the token.\n * @param amount The amount of tokens to withdraw.\n */\n function poolTogetherWithdraw(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n PrizePoolInterface prizePool = AssetPPoolLib.get(tokenAddress);\n\n address ticketAddress = PoolTogetherLib.getTicketAddress(tokenAddress);\n uint256 balanceBefore = LibEscrow.balanceOf(loanID, ticketAddress);\n\n (\n uint256 maxExitFee, /* uint256 burnedCredit */\n\n ) =\n prizePool.calculateEarlyExitFee(\n address(this),\n ticketAddress,\n amount\n );\n\n bytes memory callData =\n abi.encode(\n PrizePoolInterface.withdrawInstantlyFrom.selector,\n address(this),\n amount,\n ticketAddress,\n maxExitFee\n );\n LibDapps.s().loanEscrows[loanID].callDapp(address(prizePool), callData);\n\n uint256 balanceAfter = LibEscrow.balanceOf(loanID, ticketAddress);\n require(balanceAfter < balanceBefore, \"WITHDRAW_ERROR\");\n\n LibEscrow.tokenUpdated(loanID, address(ticketAddress));\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n\n emit PoolTogetherWithdrawal(\n tokenAddress,\n ticketAddress,\n amount,\n balanceBefore,\n balanceAfter\n );\n }\n\n /**\n * @notice This function withdraws the users funds from a Pool Together Prize Pool.\n * @param loanID id of the loan being used in the dapp\n * @param tokenAddress address of the token.\n */\n function poolTogetherWithdrawAll(uint256 loanID, address tokenAddress)\n public\n paused(\"\", false)\n onlyBorrower(loanID)\n {\n PrizePoolInterface prizePool = AssetPPoolLib.get(tokenAddress);\n\n address ticketAddress = PoolTogetherLib.getTicketAddress(tokenAddress);\n\n uint256 balanceBefore = LibEscrow.balanceOf(loanID, ticketAddress);\n\n (uint256 maxExitFee, ) =\n prizePool.calculateEarlyExitFee(\n address(this),\n ticketAddress,\n balanceBefore\n );\n\n bytes memory callData =\n abi.encode(\n PrizePoolInterface.withdrawInstantlyFrom.selector,\n address(this),\n balanceBefore,\n ticketAddress,\n maxExitFee\n );\n LibDapps.s().loanEscrows[loanID].callDapp(address(prizePool), callData);\n\n uint256 balanceAfter = LibEscrow.balanceOf(loanID, ticketAddress);\n require(balanceAfter < balanceBefore, \"WITHDRAW_ERROR\");\n\n LibEscrow.tokenUpdated(loanID, address(ticketAddress));\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n\n emit PoolTogetherWithdrawal(\n tokenAddress,\n ticketAddress,\n balanceBefore,\n LibEscrow.balanceOf(loanID, tokenAddress),\n balanceAfter\n );\n }\n}\n" + }, + "contracts/settings/asset/libraries/AssetPPoolLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../../shared/libraries/CacheLib.sol\";\nimport {\n PrizePoolInterface\n} from \"../../../escrow/dapps/interfaces/PrizePoolInterface.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions for Pool together asset setting.\n *\n * @author develop@teller.finance\n */\nlibrary AssetPPoolLib {\n bytes32 private constant NAME = keccak256(\"pPoolAddress\");\n\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n function get(address asset) internal view returns (PrizePoolInterface) {\n return PrizePoolInterface(s(asset).addresses[NAME]);\n }\n\n function set(address asset, address newValue) internal {\n s(asset).addresses[NAME] = newValue;\n }\n}\n" + }, + "contracts/escrow/dapps/libraries/PoolTogetherLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Interfaces\nimport {\n AssetPPoolLib\n} from \"../../../settings/asset/libraries/AssetPPoolLib.sol\";\n\nlibrary PoolTogetherLib {\n /**\n * @notice Grabs the controlled ticket token address for the prize pool\n * @notice The pool underlying address must match the supplied token address.\n * @param tokenAddress The token address to get the cToken for.\n * @return The address of the ticket token contract.\n */\n function getTicketAddress(address tokenAddress)\n internal\n view\n returns (address)\n {\n return AssetPPoolLib.get(tokenAddress).tokens()[1];\n }\n}\n" + }, + "contracts/escrow/dapps/interfaces/PrizePoolInterface.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title Escrows assets and deposits them into a yield source. Exposes interest to Prize Strategy. Users deposit and withdraw from this contract to participate in Prize Pool.\n/// @notice Accounting is managed using Controlled Tokens, whose mint and burn functions can only be called by this contract.\n/// @dev Must be inherited to provide specific yield-bearing asset control, such as Compound cTokens\ninterface PrizePoolInterface {\n /// @notice Deposit assets into the Prize Pool in exchange for tokens\n /// @param to The address receiving the newly minted tokens\n /// @param amount The amount of assets to deposit\n /// @param controlledToken The address of the type of token the user is minting\n /// @param referrer The referrer of the deposit\n function depositTo(\n address to,\n uint256 amount,\n address controlledToken,\n address referrer\n ) external;\n\n /// @notice Withdraw assets from the Prize Pool instantly. A fairness fee may be charged for an early exit.\n /// @param from The address to redeem tokens from.\n /// @param amount The amount of tokens to redeem for assets.\n /// @param controlledToken The address of the token to redeem (i.e. ticket or sponsorship)\n /// @param maximumExitFee The maximum exit fee the caller is willing to pay. This should be pre-calculated by the calculateExitFee() fxn.\n /// @return The actual exit fee paid\n function withdrawInstantlyFrom(\n address from,\n uint256 amount,\n address controlledToken,\n uint256 maximumExitFee\n ) external returns (uint256);\n\n /// @notice Returns the balance that is available to award.\n /// @dev captureAwardBalance() should be called first\n /// @return The total amount of assets to be awarded for the current prize\n function awardBalance() external view returns (uint256);\n\n /// @notice Calculates the early exit fee for the given amount\n /// @param from The user who is withdrawing\n /// @param controlledToken The type of collateral being withdrawn\n /// @param amount The amount of collateral to be withdrawn\n /// @return exitFee The exit fee\n /// @return burnedCredit The user's credit that was burned\n function calculateEarlyExitFee(\n address from,\n address controlledToken,\n uint256 amount\n ) external returns (uint256 exitFee, uint256 burnedCredit);\n\n /// @notice Estimates the amount of time it will take for a given amount of funds to accrue the given amount of credit.\n /// @param _principal The principal amount on which interest is accruing\n /// @param _interest The amount of interest that must accrue\n /// @return durationSeconds The duration of time it will take to accrue the given amount of interest, in seconds.\n function estimateCreditAccrualTime(\n address _controlledToken,\n uint256 _principal,\n uint256 _interest\n ) external view returns (uint256 durationSeconds);\n\n /// @notice Returns the credit balance for a given user. Not that this includes both minted credit and pending credit.\n /// @param user The user whose credit balance should be returned\n /// @return The balance of the users credit\n function balanceOfCredit(address user, address controlledToken)\n external\n returns (uint256);\n\n /// @notice Returns the credit rate of a controlled token\n /// @param controlledToken The controlled token to retrieve the credit rates for\n /// @return creditLimitMantissa The credit limit fraction. This number is used to calculate both the credit limit and early exit fee.\n /// @return creditRateMantissa The credit rate. This is the amount of tokens that accrue per second.\n function creditPlanOf(address controlledToken)\n external\n view\n returns (uint128 creditLimitMantissa, uint128 creditRateMantissa);\n\n /// @dev Returns the address of the underlying ERC20 asset\n /// @return The address of the asset\n function token() external view returns (address);\n\n /// @notice An array of the Tokens controlled by the Prize Pool (ie. Tickets, Sponsorship)\n /// @return An array of controlled token addresses\n function tokens() external view returns (address[] memory);\n\n /// @notice The total of all controlled tokens and timelock.\n /// @return The current total of all tokens and timelock.\n function accountedBalance() external view returns (uint256);\n}\n" + }, + "contracts/nft/distributor/internal/distributor.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../store.sol\";\n\n// Libraries\nimport \"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\";\n\n// Utils\nimport { ClaimNFTRequest } from \"../data.sol\";\n\ncontract int_distributor_NFT_v1 is sto_NFTDistributor {\n /**\n * @notice It checks the merkle root for a tier if it has already been claimed.\n * @param merkleIndex Index of the tier.\n * @param nodeIndex Index of the node in the merkle root.\n */\n function _setClaimed(uint256 merkleIndex, uint256 nodeIndex) internal {\n uint256 claimedWordIndex = nodeIndex / 256;\n uint256 claimedBitIndex = nodeIndex % 256;\n distributorStore().claimedBitMap[merkleIndex][claimedWordIndex] =\n distributorStore().claimedBitMap[merkleIndex][claimedWordIndex] |\n (1 << claimedBitIndex);\n }\n\n /**\n * @notice It checks the merkle root for a tier if it has already been claimed.\n * @param merkleIndex Index of the tier.\n * @param nodeIndex Index of the node in the merkle root.\n * @return claimed_ returns a boolean to check if the tier has already been claimed\n */\n function _isClaimed(uint256 merkleIndex, uint256 nodeIndex)\n internal\n view\n returns (bool)\n {\n uint256 claimedWordIndex = nodeIndex / 256;\n uint256 claimedBitIndex = nodeIndex % 256;\n uint256 claimedWord =\n distributorStore().claimedBitMap[merkleIndex][claimedWordIndex];\n uint256 mask = (1 << claimedBitIndex);\n return claimedWord & mask == mask;\n }\n\n /**\n * @notice it verifies the request's merkle proof with the merkle root in order to claim an NFT\n * @param account the account's address to be hashed and verified with the claim\n * @param request the request with the merkle proof to verify\n */\n function _verifyProof(address account, ClaimNFTRequest memory request)\n internal\n view\n returns (bool verified)\n {\n verified = MerkleProof.verify(\n request.merkleProof,\n distributorStore().merkleRoots[request.merkleIndex].merkleRoot,\n keccak256(\n abi.encodePacked(request.nodeIndex, account, request.amount)\n )\n );\n }\n}\n" + }, + "contracts/nft/distributor/external/distributor.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../store.sol\";\nimport \"../internal/distributor.sol\";\n\ncontract ext_distributor_NFT_v1 is sto_NFTDistributor, int_distributor_NFT_v1 {\n /**\n * @notice It gets the TellerNFT diamond instance used to mint.\n * @return nft_ return the NFT instance\n */\n function nft() external view returns (ITellerNFT nft_) {\n nft_ = distributorStore().nft;\n }\n\n /**\n * @notice It gets the merkle roots for NFTs it can distribute.\n * @return roots_ returns the merkle\n */\n function getMerkleRoots()\n external\n view\n returns (MerkleRoot[] memory roots_)\n {\n roots_ = distributorStore().merkleRoots;\n }\n\n /**\n * @notice It checks the merkle root for a tier if it has already been claimed.\n * @param merkleIndex Index of the tier.\n * @param nodeIndex Index of the node in the merkle root.\n * @return claimed_ returns a boolean to check if the tier has already been claimed\n */\n function isClaimed(uint256 merkleIndex, uint256 nodeIndex)\n external\n view\n returns (bool claimed_)\n {\n claimed_ = _isClaimed(merkleIndex, nodeIndex);\n }\n}\n\ncontract ext_distributor_NFT is ext_distributor_NFT_v1 {}\n" + }, + "contracts/nft/distributor/entry/claim.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../store.sol\";\nimport \"../../../contexts/access-control/modifiers/authorized.sol\";\n\nimport \"../internal/distributor.sol\";\n\n// Utils\nimport { ClaimNFTRequest, ADMIN, DistributorEvents } from \"../data.sol\";\n\ncontract ent_claim_NFTDistributor_v1 is\n sto_NFTDistributor,\n int_distributor_NFT_v1,\n mod_authorized_AccessControl_v1\n{\n /**\n * @notice Claims TellerNFTs for a given verifiable merkle proofs for each tier.\n * @param account The address to claim NFTs on behalf.\n * @param requests An array requests data generated from the merkle tree.\n *\n * Requirements:\n * - Node in the merkle root must not be claimed already\n * - Proof of the node must match the merkle tree\n */\n function claim(address account, ClaimNFTRequest[] calldata requests)\n external\n {\n for (uint256 i; i < requests.length; i++) {\n require(\n !_isClaimed(requests[i].merkleIndex, requests[i].nodeIndex),\n \"TellerNFT Distributor: already claimed\"\n );\n require(\n _verifyProof(account, requests[i]),\n \"TellerNFT Distributor: invalid proof\"\n );\n\n // Mark it claimed and send the token.\n _setClaimed(requests[i].merkleIndex, requests[i].nodeIndex);\n uint256 tierIndex =\n distributorStore().merkleRoots[requests[i].merkleIndex]\n .tierIndex;\n for (uint256 j; j < requests[i].amount; j++) {\n distributorStore().nft.mint(tierIndex, account);\n }\n\n //Find the newly minted tokens and add to memory\n uint256[] memory postOwnedTokens =\n distributorStore().nft.getOwnedTokens(account);\n\n uint256[] memory newlyMintedTokenIds =\n new uint256[](requests[i].amount);\n\n uint256 offset = postOwnedTokens.length - requests[i].amount;\n\n for (uint256 k; k < requests[i].amount; k++) {\n newlyMintedTokenIds[k] = postOwnedTokens[k + offset];\n }\n\n //For each newly minted token, set the tier index in the Dictionary contract\n distributorStore().dictionary.setTokenTierForTokenIds(\n newlyMintedTokenIds,\n tierIndex\n );\n }\n\n emit DistributorEvents.Claimed(account);\n }\n\n function setNFTDictionaryAddress(address dictionary)\n external\n authorized(ADMIN, msg.sender)\n {\n distributorStore().dictionary = TellerNFTDictionary(dictionary);\n }\n}\n" + }, + "contracts/nft/distributor/entry/add-merkle.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../store.sol\";\nimport \"../../../contexts/access-control/modifiers/authorized.sol\";\n\n// Utils\nimport { DistributorEvents, ADMIN, MerkleRoot } from \"../data.sol\";\n\ncontract ent_addMerkle_NFTDistributor_v1 is\n sto_NFTDistributor,\n mod_authorized_AccessControl_v1\n{\n /**\n * @notice Adds a new merkle to be able to claim NFTs.\n * @param tierIndex Index of NFT tier to assign merkle for.\n * @param merkleRoot The merkle root to assign to the new tier.\n *\n * Requirements:\n * - Caller must be an admin\n */\n function addMerkle(uint256 tierIndex, bytes32 merkleRoot)\n external\n authorized(ADMIN, msg.sender)\n {\n MerkleRoot storage merkle = distributorStore().merkleRoots.push();\n merkle.tierIndex = tierIndex;\n merkle.merkleRoot = merkleRoot;\n\n emit DistributorEvents.MerkleAdded(\n distributorStore().merkleRoots.length - 1\n );\n }\n}\n" + }, + "contracts/contexts2/access-control/ownership/OwnerLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlStorageLib, AccessControlStorage } from \"../storage.sol\";\n\nlibrary OwnerLib {\n function s() private pure returns (AccessControlStorage storage) {\n return AccessControlStorageLib.store();\n }\n\n /**\n * @dev Emitted when {owner} is set for {account}.\n */\n event OwnerSet(address indexed account, address indexed owner);\n\n /**\n * @dev Emitted when new {owner} is given ownership of {account}.\n */\n event OwnerTransferred(\n address indexed account,\n address indexed owner,\n address indexed prevOwner\n );\n\n /**\n * @notice Gets the owner for an address.\n * @param account Address to check ownership of.\n */\n function ownerOf(address account) internal view returns (address) {\n return AccessControlStorageLib.store().owners[account];\n }\n\n /**\n * @notice Sets an owner for an address.\n * @dev Should only use when circumventing admin checking.\n * @param account Address to set ownership of.\n * @param owner Address to set ownership of {account} to.\n */\n function setOwner(address account, address owner) internal {\n s().owners[account] = owner;\n emit OwnerSet(account, owner);\n }\n\n /**\n * @notice Transfers ownership of an address.\n * @dev Should only use when circumventing admin checking.\n * @param account Address to transfer ownership of.\n * @param newOwner Address to transfer ownership of {account} to.\n */\n function transferOwner(address account, address newOwner) internal {\n s().owners[account] = newOwner;\n emit OwnerTransferred(account, newOwner, msg.sender);\n }\n}\n" + }, + "contracts/contexts2/access-control/ownership/OwnerMods.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { OwnerLib } from \"./OwnerLib.sol\";\n\nabstract contract OwnerMods {\n modifier onlyOwner(address addr) {\n require(\n OwnerLib.ownerOf(addr) == msg.sender,\n \"AccessControl: not owner\"\n );\n _;\n }\n}\n" + }, + "contracts/contexts2/access-control/ownership/OwnerFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlStorageLib } from \"../storage.sol\";\nimport { OwnerLib } from \"./OwnerLib.sol\";\nimport { RolesMods } from \"../roles/RolesMods.sol\";\nimport { ADMIN } from \"../../../shared/roles.sol\";\n\ncontract OwnerFacet is RolesMods {\n /**\n * @notice Sets an owner for an address.\n * @param account Address to set ownership of.\n * @param owner Address to set ownership of {account} to.\n *\n * Requirements:\n * - Sender must be role admin.\n */\n function setOwner(address account, address owner)\n external\n authorized(ADMIN, msg.sender)\n {\n require(\n OwnerLib.ownerOf(account) == address(0),\n \"AccessControl: owner already set\"\n );\n OwnerLib.setOwner(account, owner);\n }\n\n /**\n * @notice Transfers ownership of an address.\n * @param account Address to transfer ownership of.\n * @param owner Address to transfer ownership of {account} to.\n *\n * Requirements:\n * - Sender must be role admin.\n */\n function transferOwner(address account, address owner)\n external\n authorized(ADMIN, msg.sender)\n {\n require(\n OwnerLib.ownerOf(account) == msg.sender,\n \"AccessControl: not owner\"\n );\n OwnerLib.transferOwner(account, owner);\n }\n}\n" + }, + "contracts/escrow/dapps/AaveFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Storage\nimport { DappMods } from \"./DappMods.sol\";\nimport { PausableMods } from \"../../settings/pausable/PausableMods.sol\";\nimport { LibDapps } from \"./libraries/LibDapps.sol\";\nimport { LibEscrow } from \"../libraries/LibEscrow.sol\";\nimport { IAToken } from \"./interfaces/IAToken.sol\";\nimport { IAaveLendingPool } from \"./interfaces/IAaveLendingPool.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\n\ncontract AaveFacet is PausableMods, DappMods {\n using SafeERC20 for IERC20;\n /**\n @notice This event is emitted every time Aave deposit is invoked successfully.\n @param tokenAddress address of the underlying token.\n @param aTokenAddress aave token address.\n @param amount amount of tokens to Deposit.\n @param aTokenBalanceBeforeDeposit aTokens balance after Deposit.\n @param aTokenBalanceAfterDeposit aTokens balance after Deposit.\n */\n event AaveDeposited(\n address indexed tokenAddress,\n address indexed aTokenAddress,\n uint256 amount,\n uint256 aTokenBalanceBeforeDeposit,\n uint256 aTokenBalanceAfterDeposit\n );\n\n /**\n @notice This event is emitted every time Aave redeem is invoked successfully.\n @param tokenAddress address of the underlying token.\n @param aTokenAddress aave token address.\n @param amount amount of tokens to Withdrawal.\n @param aTokenBalanceBeforeDeposit aTokens balance after Withdrawal.\n @param aTokenBalanceAfterWithdrawal aTokens balance after Withdrawal.\n */\n event AaveWithdrawn(\n address indexed tokenAddress,\n address indexed aTokenAddress,\n uint256 amount,\n uint256 aTokenBalanceBeforeDeposit,\n uint256 aTokenBalanceAfterWithdrawal\n );\n\n /**\n @notice The deposit, the aToken needs to be approved to have access to the token balance\n @param loanID id of the loan being used in the dapp\n @param tokenAddress address of the token\n @param amount amount of tokens to deposit\n */\n function aaveDeposit(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n IAaveLendingPool aaveLendingPool = LibDapps.getAaveLendingPool();\n IAToken aToken = LibDapps.getAToken(tokenAddress);\n uint256 aTokenBalanceBeforeDeposit = aToken.balanceOf(address(this));\n IERC20(tokenAddress).safeApprove(address(aaveLendingPool), amount);\n\n bytes memory callData =\n abi.encode(\n IAaveLendingPool.deposit.selector,\n tokenAddress,\n amount,\n address(this),\n 0\n );\n LibDapps.s().loanEscrows[loanID].callDapp(\n address(aaveLendingPool),\n callData\n );\n\n uint256 aTokenBalanceAfterDeposit = aToken.balanceOf(address(this));\n require(\n aTokenBalanceAfterDeposit > aTokenBalanceBeforeDeposit,\n \"AAVE_BALANCE_NOT_INCREASED\"\n );\n\n LibEscrow.tokenUpdated(loanID, address(aToken));\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n\n emit AaveDeposited(\n tokenAddress,\n address(aToken),\n amount,\n aTokenBalanceBeforeDeposit,\n aTokenBalanceAfterDeposit\n );\n }\n\n /**\n @notice This function withdraws the user's aTokens for a specific amount\n @param loanID id of the loan being used in the dapp\n @param tokenAddress address of the token\n @param amount amount of the underlying tokens to withdraw\n */\n function aaveWithdraw(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n IAToken aToken = LibDapps.getAToken(tokenAddress);\n IAaveLendingPool aaveLendingPool = LibDapps.getAaveLendingPool();\n uint256 aTokenBalanceBeforeWithdraw = aToken.balanceOf(address(this));\n require(\n aTokenBalanceBeforeWithdraw >= amount,\n \"NO_BALANCE_TO_WITHDRAW\"\n );\n\n bytes memory callData =\n abi.encode(\n IAaveLendingPool.withdraw.selector,\n tokenAddress,\n amount,\n address(this)\n );\n LibDapps.s().loanEscrows[loanID].callDapp(\n address(aaveLendingPool),\n callData\n );\n\n uint256 aTokenBalanceAfterWithdraw = aToken.balanceOf(address(this));\n require(\n aTokenBalanceAfterWithdraw < aTokenBalanceBeforeWithdraw,\n \"AAVE_WITHDRAWAL_ERROR\"\n );\n\n LibEscrow.tokenUpdated(loanID, address(aToken));\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n\n emit AaveWithdrawn(\n tokenAddress,\n address(aToken),\n amount,\n aTokenBalanceBeforeWithdraw,\n aTokenBalanceAfterWithdraw\n );\n }\n\n /**\n @notice This function withdraws all the user's aTokens from previous deposits\n @param loanID id of the loan being used in the dapp\n @param tokenAddress address of the token\n */\n function aaveWithdrawAll(uint256 loanID, address tokenAddress)\n public\n paused(\"\", false)\n onlyBorrower(loanID)\n {\n IAToken aToken = LibDapps.getAToken(tokenAddress);\n\n uint256 aTokenBalanceBeforeWithdraw = aToken.balanceOf(address(this));\n require(aTokenBalanceBeforeWithdraw >= 0, \"NO_BALANCE_TO_WITHDRAW\");\n\n IAaveLendingPool aaveLendingPool = LibDapps.getAaveLendingPool();\n\n bytes memory callData =\n abi.encode(\n IAaveLendingPool.withdraw.selector,\n tokenAddress,\n aTokenBalanceBeforeWithdraw,\n address(this)\n );\n LibDapps.s().loanEscrows[loanID].callDapp(\n address(aaveLendingPool),\n callData\n );\n\n uint256 aTokenBalanceAfterWithdraw = aToken.balanceOf(address(this));\n require(aTokenBalanceAfterWithdraw == 0, \"AAVE_WITHDRAWAL_ERROR\");\n\n LibEscrow.tokenUpdated(loanID, address(aToken));\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n\n emit AaveWithdrawn(\n tokenAddress,\n address(aToken),\n aTokenBalanceBeforeWithdraw,\n aTokenBalanceBeforeWithdraw,\n aTokenBalanceAfterWithdraw\n );\n }\n}\n" + }, + "contracts/settings/asset/libraries/AssetATokenLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../../shared/libraries/CacheLib.sol\";\nimport { IAToken } from \"../../../escrow/dapps/interfaces/IAToken.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions for Aave asset setting.\n *\n * @author develop@teller.finance\n */\nlibrary AssetATokenLib {\n bytes32 private constant NAME = keccak256(\"aToken\");\n\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n function get(address asset) internal view returns (IAToken) {\n return IAToken(s(asset).addresses[NAME]);\n }\n\n function set(address asset, address newValue) internal {\n s(asset).addresses[NAME] = newValue;\n }\n}\n" + }, + "contracts/shared/facets/DiamondLoupeFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/******************************************************************************\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\n/******************************************************************************/\n\nimport { LibDiamond } from \"../libraries/LibDiamond.sol\";\nimport { IDiamondLoupe } from \"../interfaces/IDiamondLoupe.sol\";\nimport {\n IERC165\n} from \"@openzeppelin/contracts/utils/introspection/IERC165.sol\";\n\ncontract DiamondLoupeFacet is IDiamondLoupe, IERC165 {\n // Diamond Loupe Functions\n ////////////////////////////////////////////////////////////////////\n /// These functions are expected to be called frequently by tools.\n //\n // struct Facet {\n // address facetAddress;\n // bytes4[] functionSelectors;\n // }\n\n /// @notice Gets all facets and their selectors.\n /// @return facets_ Facet\n function facets() external view override returns (Facet[] memory facets_) {\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\n uint256 numFacets = ds.facetAddresses.length;\n facets_ = new Facet[](numFacets);\n for (uint256 i; i < numFacets; i++) {\n address facetAddress_ = ds.facetAddresses[i];\n facets_[i].facetAddress = facetAddress_;\n facets_[i].functionSelectors = ds.facetFunctionSelectors[\n facetAddress_\n ]\n .functionSelectors;\n }\n }\n\n /// @notice Gets all the function selectors provided by a facet.\n /// @param _facet The facet address.\n /// @return facetFunctionSelectors_\n function facetFunctionSelectors(address _facet)\n external\n view\n override\n returns (bytes4[] memory facetFunctionSelectors_)\n {\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\n facetFunctionSelectors_ = ds.facetFunctionSelectors[_facet]\n .functionSelectors;\n }\n\n /// @notice Get all the facet addresses used by a diamond.\n /// @return facetAddresses_\n function facetAddresses()\n external\n view\n override\n returns (address[] memory facetAddresses_)\n {\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\n facetAddresses_ = ds.facetAddresses;\n }\n\n /// @notice Gets the facet that supports the given selector.\n /// @dev If facet is not found return address(0).\n /// @param _functionSelector The function selector.\n /// @return facetAddress_ The facet address.\n function facetAddress(bytes4 _functionSelector)\n external\n view\n override\n returns (address facetAddress_)\n {\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\n facetAddress_ = ds.selectorToFacetAndPosition[_functionSelector]\n .facetAddress;\n }\n\n // This implements ERC-165.\n function supportsInterface(bytes4 _interfaceId)\n external\n view\n override\n returns (bool)\n {\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\n return ds.supportedInterfaces[_interfaceId];\n }\n}\n" + }, + "contracts/shared/libraries/LibDiamond.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/******************************************************************************\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\n/******************************************************************************/\n\nimport { IDiamondCut } from \"../interfaces/IDiamondCut.sol\";\nimport { IDiamondLoupe } from \"../interfaces/IDiamondLoupe.sol\";\nimport {\n IERC165\n} from \"@openzeppelin/contracts/utils/introspection/IERC165.sol\";\nimport { IERC173 } from \"../interfaces/IERC173.sol\";\nimport { LibMeta } from \"./LibMeta.sol\";\n\nlibrary LibDiamond {\n bytes32 constant DIAMOND_STORAGE_POSITION =\n keccak256(\"diamond.standard.diamond.storage\");\n\n struct FacetAddressAndPosition {\n address facetAddress;\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\n }\n\n struct FacetFunctionSelectors {\n bytes4[] functionSelectors;\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\n }\n\n struct DiamondStorage {\n // maps function selector to the facet address and\n // the position of the selector in the facetFunctionSelectors.selectors array\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\n // maps facet addresses to function selectors\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\n // facet addresses\n address[] facetAddresses;\n // Used to query if a contract implements an interface.\n // Used to implement ERC-165.\n mapping(bytes4 => bool) supportedInterfaces;\n // owner of the contract\n address contractOwner;\n }\n\n function diamondStorage()\n internal\n pure\n returns (DiamondStorage storage ds)\n {\n bytes32 position = DIAMOND_STORAGE_POSITION;\n assembly {\n ds.slot := position\n }\n }\n\n event OwnershipTransferred(\n address indexed previousOwner,\n address indexed newOwner\n );\n\n function setContractOwner(address _newOwner) internal {\n DiamondStorage storage ds = diamondStorage();\n address previousOwner = ds.contractOwner;\n ds.contractOwner = _newOwner;\n emit OwnershipTransferred(previousOwner, _newOwner);\n }\n\n function contractOwner() internal view returns (address contractOwner_) {\n contractOwner_ = diamondStorage().contractOwner;\n }\n\n function enforceIsContractOwner() internal view {\n require(\n LibMeta.msgSender() == diamondStorage().contractOwner,\n \"LibDiamond: Must be contract owner\"\n );\n }\n\n event DiamondCut(\n IDiamondCut.FacetCut[] _diamondCut,\n address _init,\n bytes _calldata\n );\n\n function addDiamondFunctions(\n address _diamondCutFacet,\n address _diamondLoupeFacet,\n address _ownershipFacet\n ) internal {\n IDiamondCut.FacetCut[] memory cut = new IDiamondCut.FacetCut[](3);\n bytes4[] memory functionSelectors = new bytes4[](1);\n functionSelectors[0] = IDiamondCut.diamondCut.selector;\n cut[0] = IDiamondCut.FacetCut({\n facetAddress: _diamondCutFacet,\n action: IDiamondCut.FacetCutAction.Add,\n functionSelectors: functionSelectors\n });\n functionSelectors = new bytes4[](5);\n functionSelectors[0] = IDiamondLoupe.facets.selector;\n functionSelectors[1] = IDiamondLoupe.facetFunctionSelectors.selector;\n functionSelectors[2] = IDiamondLoupe.facetAddresses.selector;\n functionSelectors[3] = IDiamondLoupe.facetAddress.selector;\n functionSelectors[4] = IERC165.supportsInterface.selector;\n cut[1] = IDiamondCut.FacetCut({\n facetAddress: _diamondLoupeFacet,\n action: IDiamondCut.FacetCutAction.Add,\n functionSelectors: functionSelectors\n });\n functionSelectors = new bytes4[](2);\n functionSelectors[0] = IERC173.transferOwnership.selector;\n functionSelectors[1] = IERC173.owner.selector;\n cut[2] = IDiamondCut.FacetCut({\n facetAddress: _ownershipFacet,\n action: IDiamondCut.FacetCutAction.Add,\n functionSelectors: functionSelectors\n });\n diamondCut(cut, address(0), \"\");\n }\n\n // Internal function version of diamondCut\n function diamondCut(\n IDiamondCut.FacetCut[] memory _diamondCut,\n address _init,\n bytes memory _calldata\n ) internal {\n for (\n uint256 facetIndex;\n facetIndex < _diamondCut.length;\n facetIndex++\n ) {\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\n if (action == IDiamondCut.FacetCutAction.Add) {\n addFunctions(\n _diamondCut[facetIndex].facetAddress,\n _diamondCut[facetIndex].functionSelectors\n );\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\n replaceFunctions(\n _diamondCut[facetIndex].facetAddress,\n _diamondCut[facetIndex].functionSelectors\n );\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\n removeFunctions(\n _diamondCut[facetIndex].facetAddress,\n _diamondCut[facetIndex].functionSelectors\n );\n } else {\n revert(\"LibDiamondCut: Incorrect FacetCutAction\");\n }\n }\n emit DiamondCut(_diamondCut, _init, _calldata);\n initializeDiamondCut(_init, _calldata);\n }\n\n function addFunctions(\n address _facetAddress,\n bytes4[] memory _functionSelectors\n ) internal {\n require(\n _functionSelectors.length > 0,\n \"LibDiamondCut: No selectors in facet to cut\"\n );\n DiamondStorage storage ds = diamondStorage();\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\n require(\n _facetAddress != address(0),\n \"LibDiamondCut: Add facet can't be address(0)\"\n );\n uint16 selectorPosition =\n uint16(\n ds.facetFunctionSelectors[_facetAddress]\n .functionSelectors\n .length\n );\n // add new facet address if it does not exist\n if (selectorPosition == 0) {\n enforceHasContractCode(\n _facetAddress,\n \"LibDiamondCut: New facet has no code\"\n );\n ds.facetFunctionSelectors[_facetAddress]\n .facetAddressPosition = uint16(ds.facetAddresses.length);\n ds.facetAddresses.push(_facetAddress);\n }\n for (\n uint256 selectorIndex;\n selectorIndex < _functionSelectors.length;\n selectorIndex++\n ) {\n bytes4 selector = _functionSelectors[selectorIndex];\n address oldFacetAddress =\n ds.selectorToFacetAndPosition[selector].facetAddress;\n require(\n oldFacetAddress == address(0),\n \"LibDiamondCut: Can't add function that already exists\"\n );\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(\n selector\n );\n ds.selectorToFacetAndPosition[selector]\n .facetAddress = _facetAddress;\n ds.selectorToFacetAndPosition[selector]\n .functionSelectorPosition = selectorPosition;\n selectorPosition++;\n }\n }\n\n function replaceFunctions(\n address _facetAddress,\n bytes4[] memory _functionSelectors\n ) internal {\n require(\n _functionSelectors.length > 0,\n \"LibDiamondCut: No selectors in facet to cut\"\n );\n DiamondStorage storage ds = diamondStorage();\n require(\n _facetAddress != address(0),\n \"LibDiamondCut: Add facet can't be address(0)\"\n );\n uint16 selectorPosition =\n uint16(\n ds.facetFunctionSelectors[_facetAddress]\n .functionSelectors\n .length\n );\n // add new facet address if it does not exist\n if (selectorPosition == 0) {\n enforceHasContractCode(\n _facetAddress,\n \"LibDiamondCut: New facet has no code\"\n );\n ds.facetFunctionSelectors[_facetAddress]\n .facetAddressPosition = uint16(ds.facetAddresses.length);\n ds.facetAddresses.push(_facetAddress);\n }\n for (\n uint256 selectorIndex;\n selectorIndex < _functionSelectors.length;\n selectorIndex++\n ) {\n bytes4 selector = _functionSelectors[selectorIndex];\n address oldFacetAddress =\n ds.selectorToFacetAndPosition[selector].facetAddress;\n require(\n oldFacetAddress != _facetAddress,\n \"LibDiamondCut: Can't replace function with same function\"\n );\n removeFunction(oldFacetAddress, selector);\n // add function\n ds.selectorToFacetAndPosition[selector]\n .functionSelectorPosition = selectorPosition;\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(\n selector\n );\n ds.selectorToFacetAndPosition[selector]\n .facetAddress = _facetAddress;\n selectorPosition++;\n }\n }\n\n function removeFunctions(\n address _facetAddress,\n bytes4[] memory _functionSelectors\n ) internal {\n require(\n _functionSelectors.length > 0,\n \"LibDiamondCut: No selectors in facet to cut\"\n );\n DiamondStorage storage ds = diamondStorage();\n // if function does not exist then do nothing and return\n require(\n _facetAddress == address(0),\n \"LibDiamondCut: Remove facet address must be address(0)\"\n );\n for (\n uint256 selectorIndex;\n selectorIndex < _functionSelectors.length;\n selectorIndex++\n ) {\n bytes4 selector = _functionSelectors[selectorIndex];\n address oldFacetAddress =\n ds.selectorToFacetAndPosition[selector].facetAddress;\n removeFunction(oldFacetAddress, selector);\n }\n }\n\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\n DiamondStorage storage ds = diamondStorage();\n require(\n _facetAddress != address(0),\n \"LibDiamondCut: Can't remove function that doesn't exist\"\n );\n // an immutable function is a function defined directly in a diamond\n require(\n _facetAddress != address(this),\n \"LibDiamondCut: Can't remove immutable function\"\n );\n // replace selector with last selector, then delete last selector\n uint256 selectorPosition =\n ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\n uint256 lastSelectorPosition =\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.length -\n 1;\n // if not the same then replace _selector with lastSelector\n if (selectorPosition != lastSelectorPosition) {\n bytes4 lastSelector =\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[\n lastSelectorPosition\n ];\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[\n selectorPosition\n ] = lastSelector;\n ds.selectorToFacetAndPosition[lastSelector]\n .functionSelectorPosition = uint16(selectorPosition);\n }\n // delete the last selector\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\n delete ds.selectorToFacetAndPosition[_selector];\n\n // if no more selectors for facet address then delete the facet address\n if (lastSelectorPosition == 0) {\n // replace facet address with last facet address and delete last facet address\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\n uint256 facetAddressPosition =\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\n if (facetAddressPosition != lastFacetAddressPosition) {\n address lastFacetAddress =\n ds.facetAddresses[lastFacetAddressPosition];\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\n ds.facetFunctionSelectors[lastFacetAddress]\n .facetAddressPosition = uint16(facetAddressPosition);\n }\n ds.facetAddresses.pop();\n delete ds.facetFunctionSelectors[_facetAddress]\n .facetAddressPosition;\n }\n }\n\n function initializeDiamondCut(address _init, bytes memory _calldata)\n internal\n {\n if (_init == address(0)) {\n require(\n _calldata.length == 0,\n \"LibDiamondCut: _init is address(0) but_calldata is not empty\"\n );\n } else {\n require(\n _calldata.length > 0,\n \"LibDiamondCut: _calldata is empty but _init is not address(0)\"\n );\n if (_init != address(this)) {\n enforceHasContractCode(\n _init,\n \"LibDiamondCut: _init address has no code\"\n );\n }\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\n if (success == false) {\n if (error.length > 0) {\n // bubble up the error\n revert(string(error));\n } else {\n revert(\"LibDiamondCut: _init function reverted\");\n }\n }\n }\n }\n\n function enforceHasContractCode(\n address _contract,\n string memory _errorMessage\n ) internal view {\n uint256 contractSize;\n assembly {\n contractSize := extcodesize(_contract)\n }\n require(contractSize != 0, _errorMessage);\n }\n}\n" + }, + "contracts/shared/interfaces/IERC173.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title ERC-173 Contract Ownership Standard\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\n/* is ERC165 */\ninterface IERC173 {\n /// @notice Get the address of the owner\n /// @return owner_ The address of the owner.\n function owner() external view returns (address owner_);\n\n /**\n * @notice Set the address of the new owner of the contract\n * @dev Set _newOwner to address(0) to renounce any ownership.\n * @param _newOwner The address of the new owner of the contract\n */\n function transferOwnership(address _newOwner) external;\n}\n" + }, + "contracts/shared/libraries/LibMeta.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nlibrary LibMeta {\n function getChainID() internal view returns (uint256 id) {\n assembly {\n id := chainid()\n }\n }\n\n function msgSender() internal view returns (address sender_) {\n if (msg.sender == address(this)) {\n bytes memory array = msg.data;\n uint256 index = msg.data.length;\n assembly {\n // Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those.\n sender_ := and(\n mload(add(array, index)),\n 0xffffffffffffffffffffffffffffffffffffffff\n )\n }\n } else {\n sender_ = msg.sender;\n }\n }\n}\n" + }, + "contracts/shared/facets/OwnershipFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { LibDiamond } from \"../libraries/LibDiamond.sol\";\nimport { IERC173 } from \"../interfaces/IERC173.sol\";\n\ncontract OwnershipFacet is IERC173 {\n function transferOwnership(address _newOwner) external override {\n LibDiamond.enforceIsContractOwner();\n LibDiamond.setContractOwner(_newOwner);\n }\n\n function owner() external view override returns (address owner_) {\n owner_ = LibDiamond.contractOwner();\n }\n}\n" + }, + "contracts/shared/facets/DiamondCutFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/******************************************************************************\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\n/******************************************************************************/\n\nimport { IDiamondCut } from \"../interfaces/IDiamondCut.sol\";\nimport { LibDiamond } from \"../libraries/LibDiamond.sol\";\n\ncontract DiamondCutFacet is IDiamondCut {\n /// @notice Add/replace/remove any number of functions and optionally execute\n /// a function with delegatecall\n /// @param _diamondCut Contains the facet addresses and function selectors\n /// @param _init The address of the contract or facet to execute _calldata\n /// @param _calldata A function call, including function selector and arguments\n /// _calldata is executed with delegatecall on _init\n function diamondCut(\n FacetCut[] calldata _diamondCut,\n address _init,\n bytes calldata _calldata\n ) external override {\n LibDiamond.enforceIsContractOwner();\n LibDiamond.diamondCut(_diamondCut, _init, _calldata);\n }\n}\n" + }, + "contracts/contexts/access-control/internal/authorize.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./has-role.sol\";\n\nabstract contract int_authorize_AccessControl_v1 is\n int_hasRole_AccessControl_v1\n{\n function authorize(bytes32 role, address account) internal view {\n require(_hasRole(role, account), \"UNAUTHORIZED\");\n }\n}\n" + }, + "contracts/contexts/access-control/external/has-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { int_hasRole_AccessControl_v1 } from \"../internal/has-role.sol\";\n\ncontract ext_hasRole_AccessControl_V1 is int_hasRole_AccessControl_v1 {\n function hasRole(bytes32 role, address account)\n external\n view\n returns (bool hasRole_)\n {\n hasRole_ = _hasRole(role, account);\n }\n}\n\ncontract ext_hasRole_AccessControl is ext_hasRole_AccessControl_V1 {}\n" + }, + "contracts/contexts/access-control/external/index.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./has-role.sol\";\n" + }, + "contracts/contexts/access-control/external/admin-role-for.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {\n int_adminRoleFor_AccessControl_v1\n} from \"../internal/admin-role-for.sol\";\n\ncontract ext_adminRoleFor_AccessControl_V1 is\n int_adminRoleFor_AccessControl_v1\n{\n function adminRoleFor(bytes32 role)\n external\n view\n returns (bytes32 adminRoleFor_)\n {\n adminRoleFor_ = _adminRoleFor(role);\n }\n}\n\ncontract ext_adminRoleFor_AccessControl is int_adminRoleFor_AccessControl_v1 {}\n" + } + }, + "settings": { + "optimizer": { + "enabled": true, + "runs": 200 + }, + "outputSelection": { + "*": { + "*": [ + "abi", + "evm.bytecode", + "evm.deployedBytecode", + "evm.methodIdentifiers", + "metadata", + "devdoc", + "userdoc", + "storageLayout", + "evm.gasEstimates" + ], + "": ["ast"] + } + }, + "metadata": { + "useLiteralContent": true + } + } +} diff --git a/deployments/mainnet/.latestDeploymentBlock b/deployments/mainnet/.latestDeploymentBlock index fb4809c4e..cd6f52f51 100644 --- a/deployments/mainnet/.latestDeploymentBlock +++ b/deployments/mainnet/.latestDeploymentBlock @@ -1 +1 @@ -12647881 \ No newline at end of file +12814356 \ No newline at end of file diff --git a/deployments/mainnet/RepayFacet.json b/deployments/mainnet/RepayFacet.json index 5ec81692e..85df7d24d 100644 --- a/deployments/mainnet/RepayFacet.json +++ b/deployments/mainnet/RepayFacet.json @@ -1,5 +1,5 @@ { - "address": "0x2057f8DD4bcC637edBF716fdaF7DCCC86E588082", + "address": "0xb43707f26D6356ae753E9C92d3C94D23c70c4057", "abi": [ { "anonymous": false, @@ -176,27 +176,27 @@ } ], "artifactName": "RepayFacet", - "transactionHash": "0xbc046955004f24a9f4ea605bb77c6020b23c6b2b54e5ba826957510e2f0b5f21", + "transactionHash": "0x6fc8deeabee090fb2b318e67a779ab6b338d82e530d67b7c2bce87f247412e34", "receipt": { "to": null, "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", - "contractAddress": "0x2057f8DD4bcC637edBF716fdaF7DCCC86E588082", - "transactionIndex": 57, - "gasUsed": "1914533", + "contractAddress": "0xb43707f26D6356ae753E9C92d3C94D23c70c4057", + "transactionIndex": 53, + "gasUsed": "1929835", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "blockHash": "0xe9e833314768cf1d9f7397bda5876b51054e45f3658bce460ceb4a797eb109cd", - "transactionHash": "0xbc046955004f24a9f4ea605bb77c6020b23c6b2b54e5ba826957510e2f0b5f21", + "blockHash": "0x44db2b598b0b9f92cea60a129bfc04c9ceb7d63d1f31034dfbfc802c748d1e77", + "transactionHash": "0x6fc8deeabee090fb2b318e67a779ab6b338d82e530d67b7c2bce87f247412e34", "logs": [], - "blockNumber": 12647879, - "cumulativeGasUsed": "6543028", + "blockNumber": 12692218, + "cumulativeGasUsed": "6182104", "status": 1, "byzantium": true }, "args": [], - "solcInputHash": "1389136e56e3a43cff4f2990a46ef548", - "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"liquidator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"reward\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokensIn\",\"type\":\"uint256\"}],\"name\":\"LoanLiquidated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountPaid\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"totalOwed\",\"type\":\"uint256\"}],\"name\":\"LoanRepaid\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"}],\"name\":\"TokensClaimed\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"claimTokens\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"escrowRepay\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLiquidationReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"inLending_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"inCollateral_\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"liquidateLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"repayLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"params\":{\"borrower\":\"Account address of the borrower\",\"liquidator\":\"Account address of the liquidator\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"reward\":\"Value in lending token paid out to liquidator\",\"tokensIn\":\"Percentage of the collateral price paid by the liquidator to the lending pool\"}},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"params\":{\"amountPaid\":\"Amount of the loan paid back\",\"borrower\":\"Account address of the borrower\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"payer\":\"Account address of the payer\",\"totalOwed\":\"Total amount of the loan to be repaid\"}}},\"kind\":\"dev\",\"methods\":{\"claimTokens(uint256)\":{\"params\":{\"loanID\":\"The id of the loan being used.\"}},\"escrowRepay(uint256,uint256)\":{\"details\":\"If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\",\"params\":{\"amount\":\"The amount being repaid.\",\"loanID\":\"The id of the loan being used.\"}},\"getLiquidationReward(uint256)\":{\"params\":{\"loanID\":\"The loan ID to get the info.\"},\"returns\":{\"inCollateral_\":\"The value the liquidator will receive denoted in collateral tokens.\",\"inLending_\":\"The value the liquidator will receive denoted in lending tokens.\"}},\"liquidateLoan(uint256)\":{\"params\":{\"loanID\":\"The ID of the loan to be liquidated\"}},\"repayLoan(uint256,uint256)\":{\"params\":{\"amount\":\"The amount of tokens to pay back to the loan\",\"loanID\":\"The ID of the loan the payment is for\"}}},\"version\":1},\"userdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully liquidated\"},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully repaid\"},\"TokensClaimed(address)\":{\"notice\":\"Notifies when the Escrow's tokens have been claimed.\"}},\"kind\":\"user\",\"methods\":{\"claimTokens(uint256)\":{\"notice\":\"Sends the tokens owned by this escrow to the owner.\"},\"escrowRepay(uint256,uint256)\":{\"notice\":\"Repay this Escrow's loan.\"},\"getLiquidationReward(uint256)\":{\"notice\":\"It gets the current liquidation reward for a given loan.\"},\"liquidateLoan(uint256)\":{\"notice\":\"Liquidate a loan if it is expired or under collateralized\"},\"repayLoan(uint256,uint256)\":{\"notice\":\"Make a payment to a loan\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/market/RepayFacet.sol\":\"RepayFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Trees proofs.\\n *\\n * The proofs can be generated using the JavaScript library\\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\\n *\\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n bytes32 computedHash = leaf;\\n\\n for (uint256 i = 0; i < proof.length; i++) {\\n bytes32 proofElement = proof[i];\\n\\n if (computedHash <= proofElement) {\\n // Hash(current computed hash + current element of the proof)\\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\\n } else {\\n // Hash(current element of the proof + current computed hash)\\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\\n }\\n }\\n\\n // Check if the computed hash (root) is equal to the provided root\\n return computedHash == root;\\n }\\n}\\n\",\"keccak256\":\"0xeee34bfb413657b6cd6c8e1e15c2080ba5ebaac479578515922804346fb63f7c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/reentry/ReentryMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nabstract contract ReentryMods {\\n modifier nonReentry(bytes32 id) {\\n AccessControlStorage storage s = AccessControlStorageLib.store();\\n require(!s.entered[id], \\\"AccessControl: reentered\\\");\\n s.entered[id] = true;\\n _;\\n s.entered[id] = false;\\n }\\n}\\n\",\"keccak256\":\"0x033c1164af25ef7d35a38a60973bf379b1cc603596914ffd85dcbcf0acdb6970\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/EscrowClaimTokens.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\n\\n// Interfaces\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, LoanStatus } from \\\"../storage/market.sol\\\";\\n\\n// Libraries\\nimport { LibLoans } from \\\"../market/libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"./libraries/LibEscrow.sol\\\";\\n\\n/**\\n * @notice Contains functionality to claim tokens that are in an escrow contract for a loan.\\n */\\ncontract EscrowClaimTokens is PausableMods {\\n /**\\n * @notice Notifies when the Escrow's tokens have been claimed.\\n * @param recipient address where the tokens where sent to.\\n */\\n event TokensClaimed(address recipient);\\n\\n /**\\n * @notice Sends the tokens owned by this escrow to the owner.\\n * @param loanID The id of the loan being used.\\n */\\n function claimTokens(uint256 loanID) external paused(\\\"\\\", false) {\\n require(\\n LibLoans.loan(loanID).borrower == msg.sender,\\n \\\"Teller: claim not borrower\\\"\\n );\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Closed,\\n \\\"Teller: loan not closed\\\"\\n );\\n\\n __claimEscrowTokens(loanID);\\n }\\n\\n function __claimEscrowTokens(uint256 loanID) internal {\\n __claimToken(loanID, LibLoans.loan(loanID).lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n __claimToken(loanID, EnumerableSet.at(tokens, i));\\n }\\n\\n emit TokensClaimed(msg.sender);\\n }\\n\\n function __claimToken(uint256 loanID, address token) private {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n if (balance > 0) {\\n LibEscrow.e(loanID).claimToken(\\n token,\\n LibLoans.loan(loanID).borrower,\\n balance\\n );\\n }\\n }\\n}\\n\",\"keccak256\":\"0xae189ea2a13c10f013f255f98ec50f34466c375bd7503275587d6abe5d25696c\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../interfaces/IAToken.sol\\\";\\nimport { IAaveLendingPool } from \\\"../interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x8030b206c87d0073fb7dbebfa2ee8a3e93c479d976d6cdaa0c939f2fedaa1525\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n /**\\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\\n * @param dappAddress address of the target contract address\\n * @param dappData encoded abi of the function in our contract we want to call\\n * @return the called data in bytes\\n */\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n /**\\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\\n * @param token address of the respective ERC20 token to approve for the spender\\n * @param spender address of the respective spender who is approved by the token contract\\n */\\n function setTokenAllowance(address token, address spender) external;\\n\\n /**\\n * @notice it allows user to claim their escrow tokens\\n * @dev only the owner (TellerDiamond) can make this call on behalf of the users\\n * @param token address of the respective token contract to claim tokens from\\n * @param to address where the tokens should be transferred to\\n * @param amount uint256 amount of tokens to be claimed\\n */\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xaf67fc4454ffaa4d2f7e46fe7101876e8ebdb1a5426c30f87b8e18cc573ac019\",\"license\":\"MIT\"},\"contracts/escrow/libraries/LibEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibDapps } from \\\"../dapps/libraries/LibDapps.sol\\\";\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibEscrow {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\\n e_ = s().loanEscrows[loanID];\\n }\\n\\n /**\\n * @notice It returns a list of tokens owned by a loan escrow\\n * @param loanID uint256 index used to return our token list\\n * @return t_ which is a list of tokens \\n */\\n function getEscrowTokens(uint256 loanID)\\n internal\\n view\\n returns (EnumerableSet.AddressSet storage t_)\\n {\\n t_ = s().escrowTokens[loanID];\\n }\\n\\n /**\\n * @notice It returns the balance of a respective token in a loan escrow\\n * @param loanID uint256 index used to point to our loan escrow\\n * @param token address of respective token to give us the balance of in our loan escrow\\n * @return uint256 balance of respective token returned in an escrow loan\\n */\\n function balanceOf(uint256 loanID, address token)\\n internal\\n view\\n returns (uint256)\\n {\\n return IERC20(token).balanceOf(address(e(loanID)));\\n }\\n\\n /**\\n * @notice Adds or removes tokens held by the Escrow contract\\n * @param loanID The loan ID to update the token list for\\n * @param tokenAddress The token address to be added or removed\\n */\\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\\n // Skip if is lending token\\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\\n\\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\\n if (balanceOf(loanID, tokenAddress) > 0) {\\n if (!contains) {\\n EnumerableSet.add(tokens, tokenAddress);\\n }\\n } else if (contains) {\\n EnumerableSet.remove(tokens, tokenAddress);\\n }\\n }\\n\\n /**\\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\\n * @param loanID The loan ID to calculate value for\\n * @return value_ Escrow total value denoted in the lending token.\\n */\\n function calculateTotalValue(uint256 loanID)\\n internal\\n view\\n returns (uint256 value_)\\n {\\n address lendingToken = LibLoans.loan(loanID).lendingToken;\\n value_ += balanceOf(loanID, lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\\n if (EnumerableSet.length(tokens) > 0) {\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n uint256 tokenBal =\\n balanceOf(loanID, EnumerableSet.at(tokens, i));\\n value_ += PriceAggLib.valueFor(\\n EnumerableSet.at(tokens, i),\\n lendingToken,\\n tokenBal\\n );\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x17a7c6b11d6f280948e320525d1e131b89c23f80216918aa070df437a851d915\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when a user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when a user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n * @return ERC20 token\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n * @return balance_ the balance of the account\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice It calculates the total supply of the underlying asset.\\n * @return totalSupply_ the total supply denoted in the underlying asset.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given market.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n \\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfill the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n * @return mintAmount_ the amount minted of the specified token\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n * @return address of the strategy contract\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n * @param state boolean value that resembles the platform's state\\n */\\n function restrict(bool state) external virtual;\\n\\n /**\\n * @notice it initializes the Teller Token\\n * @param admin address of the admin to the respective Teller Token\\n * @param underlying address of the ERC20 token\\n */\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xf30ac4ef491851477ff9a3dd04974ebe74b529c37a3ef4e05798c3f734ceeb3d\",\"license\":\"MIT\"},\"contracts/market/LoanDataFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { Loan, LoanDebt, LoanTerms } from \\\"../storage/market.sol\\\";\\n\\ncontract LoanDataFacet {\\n /**\\n * @notice Returns the information about the given {loanID}.\\n * @param loanID The loan ID to get information for.\\n * @return loan_ The loan data.\\n */\\n function getLoan(uint256 loanID) external view returns (Loan memory loan_) {\\n loan_ = LibLoans.s().loans[loanID];\\n }\\n\\n /**\\n * @notice DEPRECATED\\n * @notice Returns the terms for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanTerms The terms that the loan weer created with.\\n */\\n function getLoanTerms(uint256 loanID)\\n external\\n view\\n returns (LoanTerms memory)\\n {\\n return LibLoans.terms(loanID);\\n }\\n\\n /**\\n * @notice Returns the loan IDs created by the {borrower} account.\\n * @param borrower The account to get loan IDs for.\\n * @return loanIDs The IDs for loans created by the {borrower}\\n */\\n function getBorrowerLoans(address borrower)\\n external\\n view\\n returns (uint128[] memory loanIDs)\\n {\\n return LibLoans.s().borrowerLoans[borrower];\\n }\\n\\n /**\\n * @notice Returns the debt owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanDebt The principal and interest owed amount.\\n */\\n function getDebtOwed(uint256 loanID)\\n external\\n view\\n returns (LoanDebt memory)\\n {\\n return LibLoans.debt(loanID);\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) external view returns (uint256) {\\n return LibLoans.getTotalOwed(loanID);\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n external\\n view\\n returns (uint256)\\n {\\n return LibLoans.getInterestOwedFor(loanID, amountBorrow);\\n }\\n\\n /**\\n * @notice it returns the collateral needed for a loan\\n * @param loanID the identifier of the loan ID to retrieve collateral from\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n external\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n return LibLoans.getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the typed address of a loan escrow\\n * @param loanID the identifier of the respective escrow's loan\\n * @return escrow_ the typed address of the returned ILoanEscrow\\n */\\n function getLoanEscrow(uint256 loanID)\\n external\\n view\\n returns (address escrow_)\\n {\\n escrow_ = address(LibLoans.s().loanEscrows[loanID]);\\n }\\n\\n /**\\n * @notice it returns the escrow's total value by calculating the value all the escrow tokens\\n * @param loanID the identifier of the respective escrow's loan\\n * @return the total value of the loan escrow\\n */\\n function getLoanEscrowValue(uint256 loanID)\\n external\\n view\\n returns (uint256)\\n {\\n return LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n /**\\n * @notice it returns the total escrow tokens held by an escrow\\n * @param loanID the identifier of the respective escrow's loan\\n * @return tokens_ the tokens held at the escrow loan \\n */\\n function getEscrowTokens(uint256 loanID)\\n external\\n view\\n returns (address[] memory tokens_)\\n {\\n EnumerableSet.AddressSet storage escrowTokens =\\n LibEscrow.getEscrowTokens(loanID);\\n tokens_ = new address[](EnumerableSet.length(escrowTokens));\\n for (uint256 i; i < tokens_.length; i++) {\\n tokens_[i] = EnumerableSet.at(escrowTokens, i);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x9a57f5de00ce073af4ffb2f74e7d8a15e56bc017826f2c5a393ef5b64554145f\",\"license\":\"MIT\"},\"contracts/market/RepayFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\nimport {\\n ReentryMods\\n} from \\\"../contexts2/access-control/reentry/ReentryMods.sol\\\";\\nimport { AUTHORIZED } from \\\"../shared/roles.sol\\\";\\nimport { LoanDataFacet } from \\\"./LoanDataFacet.sol\\\";\\nimport { EscrowClaimTokens } from \\\"../escrow/EscrowClaimTokens.sol\\\";\\n\\n// Libraries\\nimport {\\n IERC20,\\n SafeERC20\\n} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibCollateral } from \\\"./libraries/LibCollateral.sol\\\";\\nimport { LibDapps } from \\\"../escrow/dapps/libraries/LibDapps.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { NumbersLib } from \\\"../shared/libraries/NumbersLib.sol\\\";\\nimport { PriceAggLib } from \\\"../price-aggregator/PriceAggLib.sol\\\";\\nimport { NFTLib } from \\\"../nft/libraries/NFTLib.sol\\\";\\n\\n// Interfaces\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus\\n} from \\\"../storage/market.sol\\\";\\n\\ncontract RepayFacet is RolesMods, ReentryMods, PausableMods, EscrowClaimTokens {\\n /**\\n @notice This event is emitted when a loan has been successfully repaid\\n @param loanID ID of loan from which collateral was withdrawn\\n @param borrower Account address of the borrower\\n @param amountPaid Amount of the loan paid back\\n @param payer Account address of the payer\\n @param totalOwed Total amount of the loan to be repaid\\n */\\n event LoanRepaid(\\n uint256 indexed loanID,\\n address indexed borrower,\\n uint256 amountPaid,\\n address payer,\\n uint256 totalOwed\\n );\\n\\n /**\\n * @notice This event is emitted when a loan has been successfully liquidated\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param borrower Account address of the borrower\\n * @param liquidator Account address of the liquidator\\n * @param reward Value in lending token paid out to liquidator\\n * @param tokensIn Percentage of the collateral price paid by the liquidator to the lending pool\\n */\\n event LoanLiquidated(\\n uint256 indexed loanID,\\n address indexed borrower,\\n address liquidator,\\n uint256 reward,\\n uint256 tokensIn\\n );\\n\\n /**\\n * @notice Repay this Escrow's loan.\\n * @dev If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.\\n * @dev Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\\n * @param loanID The id of the loan being used.\\n * @param amount The amount being repaid.\\n */\\n function escrowRepay(uint256 loanID, uint256 amount)\\n external\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n nonReentry(\\\"\\\")\\n {\\n uint256 balance =\\n LibEscrow.balanceOf(loanID, LibLoans.loan(loanID).lendingToken);\\n uint256 totalOwed = LibLoans.getTotalOwed(loanID);\\n // if there isn't enough balance in the escrow, then transfer amount needed to the escrow\\n if (balance < totalOwed && amount > balance) {\\n uint256 amountNeeded =\\n amount > totalOwed ? totalOwed - (balance) : amount - (balance);\\n\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n msg.sender,\\n address(LibEscrow.e(loanID)),\\n amountNeeded\\n );\\n }\\n\\n __repayLoan(loanID, amount, address(LibEscrow.e(loanID)), false);\\n }\\n\\n /**\\n * @notice Make a payment to a loan\\n * @param loanID The ID of the loan the payment is for\\n * @param amount The amount of tokens to pay back to the loan\\n */\\n function repayLoan(uint256 loanID, uint256 amount)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n __repayLoan(loanID, amount, msg.sender, false);\\n }\\n\\n /**\\n * @notice it repays the loan, either from an escrow or from a regular address\\n * @param loanID the identifier of the loan to repay\\n * @param amount the amount to repay the loan\\n * @param sender the address of the sender that wants to pay, can also be a loan escrow\\n * @param isLiquidation is this loan being liquidated?\\n * @return leftToPay_ the amount left to pay for the loan\\n */\\n function __repayLoan(\\n uint256 loanID,\\n uint256 amount,\\n address sender,\\n bool isLiquidation\\n ) private returns (uint256 leftToPay_) {\\n require(amount > 0, \\\"Teller: zero repay\\\");\\n\\n // calculate the actual amount to repay\\n leftToPay_ =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n if (leftToPay_ < amount) {\\n amount = leftToPay_;\\n leftToPay_ = 0;\\n } else {\\n leftToPay_ -= amount;\\n }\\n\\n // Get the Teller token for the loan\\n ITToken tToken =\\n MarketStorageLib.store().tTokens[\\n LibLoans.loan(loanID).lendingToken\\n ];\\n // Transfer funds from an escrow if an escrow is calling it\\n // Otherwise, transfer funds from an account\\n if (address(LibEscrow.e(loanID)) == sender) {\\n LibEscrow.e(loanID).claimToken(\\n LibLoans.loan(loanID).lendingToken,\\n address(tToken),\\n amount\\n );\\n } else {\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n sender,\\n address(tToken),\\n amount\\n );\\n }\\n\\n // Deduct the interest and principal owed\\n uint256 principalPaid;\\n uint256 interestPaid;\\n if (amount < LibLoans.debt(loanID).interestOwed) {\\n interestPaid = amount;\\n LibLoans.debt(loanID).interestOwed -= amount;\\n } else {\\n if (LibLoans.debt(loanID).interestOwed > 0) {\\n interestPaid = LibLoans.debt(loanID).interestOwed;\\n amount -= interestPaid;\\n LibLoans.debt(loanID).interestOwed = 0;\\n }\\n\\n if (amount > 0) {\\n principalPaid = amount;\\n LibLoans.debt(loanID).principalOwed -= amount;\\n }\\n }\\n\\n // Tell the Teller Token value has been deposited back into the pool.\\n tToken.repayLoan(principalPaid, interestPaid);\\n\\n if (isLiquidation) {\\n // Make sure there is nothing left to repay on the loan\\n require(leftToPay_ == 0, \\\"Teller: liquidate partial repay\\\");\\n\\n // Set loan status\\n LibLoans.loan(loanID).status = LoanStatus.Liquidated;\\n\\n // Transfer NFT if linked\\n NFTLib.liquidateNFT(loanID);\\n } else {\\n // if the loan is now fully paid, close it and withdraw borrower collateral\\n if (leftToPay_ == 0) {\\n LibLoans.loan(loanID).status = LoanStatus.Closed;\\n\\n // Check if the loan has a collateral token\\n if (LibLoans.loan(loanID).collateralToken != address(0)) {\\n LibCollateral.withdrawAll(\\n loanID,\\n LibLoans.loan(loanID).borrower\\n );\\n }\\n\\n // Claim tokens in the escrow for the loan if any\\n __claimEscrowTokens(loanID);\\n\\n // Restake any NFTs linked to loan for borrower\\n NFTLib.restakeLinked(loanID, LibLoans.loan(loanID).borrower);\\n }\\n\\n emit LoanRepaid(\\n loanID,\\n LibLoans.loan(loanID).borrower,\\n amount,\\n msg.sender,\\n leftToPay_\\n );\\n }\\n }\\n\\n /**\\n * @notice Liquidate a loan if it is expired or under collateralized\\n * @param loanID The ID of the loan to be liquidated\\n */\\n function liquidateLoan(uint256 loanID)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n uint256 collateralAmount = LibCollateral.e(loanID).loanSupply(loanID);\\n require(\\n RepayLib.isLiquidable(loanID, collateralAmount),\\n \\\"Teller: does not need liquidation\\\"\\n );\\n\\n // Calculate the reward before repaying the loan\\n (uint256 rewardInLending, uint256 collateralInLending) =\\n RepayLib.getLiquidationReward(loanID, collateralAmount);\\n\\n // The liquidator pays the amount still owed on the loan\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n __repayLoan(loanID, amountToLiquidate, msg.sender, true);\\n\\n // Payout the liquidator reward owed\\n if (rewardInLending > 0) {\\n RepayLib.payOutLiquidator(\\n loanID,\\n rewardInLending,\\n collateralInLending,\\n collateralAmount,\\n payable(msg.sender)\\n );\\n }\\n\\n emit LoanLiquidated(\\n loanID,\\n loan.borrower,\\n msg.sender,\\n rewardInLending,\\n amountToLiquidate\\n );\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @return inLending_ The value the liquidator will receive denoted in lending tokens.\\n * @return inCollateral_ The value the liquidator will receive denoted in collateral tokens.\\n */\\n function getLiquidationReward(uint256 loanID)\\n external\\n view\\n returns (uint256 inLending_, uint256 inCollateral_)\\n {\\n (inLending_, ) = RepayLib.getLiquidationReward(\\n loanID,\\n LibCollateral.e(loanID).loanSupply(loanID)\\n );\\n inCollateral_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n inLending_\\n );\\n }\\n}\\n\\nlibrary RepayLib {\\n /**\\n * @notice It checks if a loan can be liquidated.\\n * @param loanID The loan ID to check.\\n * @return true if the loan is liquidable.\\n */\\n function isLiquidable(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (bool)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n // Check if loan can be liquidated\\n if (loan.status != LoanStatus.Active) {\\n return false;\\n }\\n\\n if (loan.collateralRatio > 0) {\\n // If loan has a collateral ratio, check how much is needed\\n (, uint256 neededInCollateral, ) =\\n LoanDataFacet(address(this)).getCollateralNeededInfo(loanID);\\n if (neededInCollateral > collateralAmount) {\\n return true;\\n }\\n }\\n\\n // Otherwise, check if the loan has expired\\n return block.timestamp >= loan.loanStartTime + loan.duration;\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @param collateralAmount The amount of collateral for the {loanID}. Passed in to save gas calling the collateral escrow multiple times.\\n * @return reward_ The value the liquidator will receive denoted in lending tokens.\\n */\\n function getLiquidationReward(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (uint256 reward_, uint256 collateralValue_)\\n {\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n // Max reward is amount repaid on loan plus extra percentage\\n uint256 maxReward =\\n amountToLiquidate +\\n NumbersLib.percent(\\n amountToLiquidate,\\n uint16(PlatformSettingsLib.getLiquidateRewardPercent())\\n );\\n\\n // Calculate available collateral for reward\\n if (collateralAmount > 0) {\\n collateralValue_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).collateralToken,\\n LibLoans.loan(loanID).lendingToken,\\n collateralAmount\\n );\\n reward_ += collateralValue_;\\n }\\n\\n // Calculate loan escrow value if collateral not enough to cover reward\\n if (reward_ < maxReward) {\\n reward_ += LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n // Cap the reward to max\\n if (reward_ > maxReward) {\\n reward_ = maxReward;\\n }\\n }\\n\\n /**\\n * @notice Checks if the loan has an Escrow and claims any tokens then pays out the loan collateral.\\n * @dev See Escrow.claimTokens for more info.\\n * @param loanID The loan ID which is being liquidated\\n * @param rewardInLending The total amount of reward based in the lending token to pay the liquidator\\n * @param collateralInLending The amount of collateral that is available for the loan denoted in lending tokens\\n * @param collateralAmount The amount of collateral that is available for the loan\\n * @param liquidator The address of the liquidator where the liquidation reward will be sent to\\n */\\n function payOutLiquidator(\\n uint256 loanID,\\n uint256 rewardInLending,\\n uint256 collateralInLending,\\n uint256 collateralAmount,\\n address payable liquidator\\n ) internal {\\n // check if loan is liquidated\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Liquidated,\\n \\\"Teller: loan not liquidated\\\"\\n );\\n\\n // if the lending reward is less than the collateral lending tokens, then aggregate\\n // the value for the lending token with the collateral token and send it to the liquidator\\n if (rewardInLending <= collateralInLending) {\\n uint256 rewardInCollateral =\\n PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n rewardInLending\\n );\\n\\n LibCollateral.withdraw(loanID, rewardInCollateral, liquidator);\\n } else {\\n // Payout whats available in the collateral token\\n LibCollateral.withdraw(loanID, collateralAmount, liquidator);\\n\\n // Claim remaining reward value from the loan escrow\\n claimEscrowTokensByValue(\\n loanID,\\n liquidator,\\n rewardInLending - collateralInLending\\n );\\n }\\n }\\n\\n /**\\n * @dev Send the equivalent of tokens owned by the loan escrow (in lending value) to the recipient,\\n * @param loanID The loan ID to clam tokens from\\n * @param recipient address to send the tokens to\\n * @param value The value of escrow held tokens to be claimed based in lending value\\n */\\n function claimEscrowTokensByValue(\\n uint256 loanID,\\n address recipient,\\n uint256 value\\n ) private {\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n uint256 valueLeftToTransfer = value;\\n\\n // Start with the lending token\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n LibLoans.loan(loanID).lendingToken,\\n recipient,\\n valueLeftToTransfer\\n );\\n\\n // Cycle through remaining tokens\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n if (valueLeftToTransfer == 0) {\\n return;\\n }\\n\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n EnumerableSet.at(tokens, i),\\n recipient,\\n valueLeftToTransfer\\n );\\n }\\n }\\n\\n /**\\n * @notice it claims the escrow tokens for the liquidator\\n * @notice it keeps claiming escrow tokens until there aren't anymore tokens or the valueLeftToTransfer is zero\\n * @param loanID the identifier of the escrow loan to claim tokens from\\n * @param token the address of the token asset to claim\\n * @param recipient the address of the recipient to transfer the tokens to\\n * @param valueLeftToTransfer the value left to transfer to the liquidator that is returned back\\n * @return the value left to transfer\\n */\\n function claimEscrowToken(\\n uint256 loanID,\\n address token,\\n address recipient,\\n uint256 valueLeftToTransfer\\n ) private returns (uint256) {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n // get value of token balance in lending value\\n if (balance > 0) {\\n // If token not the lending token, get value of token\\n uint256 balanceInLending;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n balanceInLending = balance;\\n } else {\\n balanceInLending = PriceAggLib.valueFor(\\n token,\\n LibLoans.loan(loanID).lendingToken,\\n balance\\n );\\n }\\n\\n if (balanceInLending <= valueLeftToTransfer) {\\n LibEscrow.e(loanID).claimToken(token, recipient, balance);\\n valueLeftToTransfer -= balanceInLending;\\n } else {\\n // Token balance is more than enough so calculate ratio of balance to transfer\\n uint256 valueToTransfer;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n valueToTransfer = valueLeftToTransfer;\\n } else {\\n valueToTransfer = NumbersLib.percent(\\n balance,\\n NumbersLib.ratioOf(\\n valueLeftToTransfer,\\n balanceInLending\\n )\\n );\\n }\\n\\n LibEscrow.e(loanID).claimToken(\\n token,\\n recipient,\\n valueToTransfer\\n );\\n valueLeftToTransfer = 0;\\n }\\n }\\n return valueLeftToTransfer;\\n }\\n}\\n\",\"keccak256\":\"0xc440b61519f74c4eba549f1f531726b1cd8b3da60ba7654cccd4eb9bd9fd7020\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n /**\\n * @notice it initializes an escrow\\n * @param tokenAddress the address of the collateral token to be stored\\n * @param isWETH check if it's wrapped Ethereum\\n */\\n function init(address tokenAddress, bool isWETH) external;\\n\\n /**\\n * @notice it deposits an amount of the respective collateral token into the escrow\\n * @param loanID the ID of the loan\\n * @param amount the amount of collateral tokens to be deposited\\n */\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n /**\\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\\n * @dev only the TellerDiamond can make this call on behalf of the borrower\\n * @param loanID identifier of the loan\\n * @param amount number of collateral tokens to send\\n * @param receiver payable address to transfer money to\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n /**\\n * @notice it returns the supply of the respective loan\\n * @param loanID the respective loan ID\\n * @return supply_ the amount in collateral of the respective loan\\n */\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n /**\\n * @notice it returns the total supply of the collateral token held by the contract\\n * @return supply_ the total amount of collateral\\n */\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x900fed2311f919ba1451a6583ddbf9f3bc8afa8f5189500fff51f0c049258ed3\",\"license\":\"MIT\"},\"contracts/market/libraries/LibCollateral.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport { ICollateralEscrow } from \\\"../collateral/ICollateralEscrow.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\nimport { MarketStorageLib } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibCollateral {\\n /**\\n * @notice This event is emitted when collateral has been deposited for the loan\\n * @param loanID ID of the loan for which collateral was deposited\\n * @param depositor Account that deposited funds\\n * @param amount Amount of collateral deposited\\n */\\n event CollateralDeposited(\\n uint256 indexed loanID,\\n address indexed depositor,\\n uint256 amount\\n );\\n\\n /**\\n * @notice This event is emitted when collateral has been withdrawn\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param receiver Account that received funds\\n * @param amount Value of collateral withdrawn\\n */\\n event CollateralWithdrawn(\\n uint256 indexed loanID,\\n address indexed receiver,\\n uint256 amount\\n );\\n\\n /**\\n * @notice it gets MarketStorage's collateral escrow using the loanID\\n * @param loanID the loanID to be used\\n * @return c_ which is the collateral escrow\\n */\\n function e(uint256 loanID) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[\\n MarketStorageLib.store().loans[loanID].collateralToken\\n ];\\n }\\n\\n function e(address token) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[token];\\n }\\n\\n /**\\n * @notice it deposits an amount of collateral into a collateral escrow's address of a respective loan\\n * @param loanID the respective loan ID\\n * @param amount the amount of collateral to deposit\\n */\\n function deposit(uint256 loanID, uint256 amount) internal {\\n e(loanID).deposit{ value: amount }(loanID, amount);\\n\\n emit CollateralDeposited(loanID, msg.sender, amount);\\n }\\n\\n /**\\n * @notice it withdraws an amount from the collateral escrow\\n * @param loanID the respective loanID to withdraw from\\n * @param amount the number of collateral tokens to withdraw\\n * @param receiver the address who receives the withdrawal\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) internal {\\n e(loanID).withdraw(loanID, amount, receiver);\\n\\n emit CollateralWithdrawn(loanID, receiver, amount);\\n }\\n\\n /**\\n * @notice it withdraws the entire supply in collateral of a respective loan to an address\\n * @param loanID the respective loan's ID\\n * @param receiver the address of the receiver to withdraw tokens from\\n */\\n function withdrawAll(uint256 loanID, address payable receiver) internal {\\n withdraw(loanID, e(loanID).loanSupply(loanID), receiver);\\n }\\n\\n /**\\n * @notice it initializes a new escrow collateral to hold collateral tokens\\n * @param token address of the collateral token it holds\\n */\\n function createEscrow(address token) internal {\\n // Check if collateral escrow exists\\n if (address(e(token)) == address(0)) {\\n // Create escrow\\n address escrow =\\n AppStorageLib.store().collateralEscrowBeacon.cloneProxy(\\\"\\\");\\n ICollateralEscrow(escrow).init(\\n token,\\n // Check if collateral token is WETH\\n token == AppStorageLib.store().assetAddresses[\\\"WETH\\\"]\\n );\\n\\n // Set max allowance\\n IERC20(token).approve(escrow, type(uint256).max);\\n // Save escrow address for loan\\n MarketStorageLib.store().collateralEscrows[\\n token\\n ] = ICollateralEscrow(escrow);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x84dbab8283357a1cc4210e34642fc8247841a58973778f4f6570398cc3046947\",\"license\":\"MIT\"},\"contracts/market/libraries/LibLoans.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibEscrow } from \\\"../../escrow/libraries/LibEscrow.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus,\\n LoanDebt,\\n LoanTerms\\n} from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibLoans {\\n using NumbersLib for int256;\\n using NumbersLib for uint256;\\n\\n bytes32 internal constant ID = keccak256(\\\"LOANS\\\");\\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n * @notice it returns the loan\\n * @param loanID the ID of the respective loan\\n * @return l_ the loan \\n */\\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\\n l_ = s().loans[loanID];\\n }\\n\\n /**\\n * @notice it returns the loan debt from a respective loan\\n * @param loanID the ID of the respective loan\\n * @return d_ the loan debt from a respective loan\\n */\\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\\n d_ = s().loanDebt[loanID];\\n }\\n\\n // DEPRECATED\\n function terms(uint256 loanID)\\n internal\\n view\\n returns (LoanTerms storage t_)\\n {\\n t_ = s()._loanTerms[loanID];\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return owed_ uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID)\\n internal\\n view\\n returns (uint256 owed_)\\n {\\n if (loan(loanID).status == LoanStatus.Active) {\\n owed_ = debt(loanID).principalOwed + (debt(loanID).interestOwed);\\n }\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n internal\\n view\\n returns (uint256)\\n {\\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\\n }\\n \\n function getCollateralNeeded(uint256 loanID)\\n internal\\n view\\n returns (uint256 _needed)\\n {\\n (, _needed, ) = getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the total collateral needed in lending tokens, in collateral tokens and in escrowed loan values\\n * @param loanID the loanID to get the total collateral needed\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n internal\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\\n loanID\\n );\\n\\n // check if needed lending tokens is zero. if true, then needed collateral tokens is zero. else,\\n if (neededInLendingTokens == 0) {\\n neededInCollateralTokens = 0;\\n } else {\\n neededInCollateralTokens = PriceAggLib.valueFor(\\n loan(loanID).lendingToken,\\n loan(loanID).collateralToken,\\n neededInLendingTokens\\n );\\n }\\n }\\n\\n /**\\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\\n * @param loanID The loan ID to get needed collateral info for.\\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\\n */\\n function getCollateralNeededInTokens(uint256 loanID)\\n internal\\n view\\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\\n {\\n if (loan(loanID).collateralRatio == 0) {\\n return (0, 0);\\n }\\n\\n /*\\n The collateral to principal owed ratio is the sum of:\\n * collateral buffer percent\\n * loan interest rate\\n * liquidation reward percent\\n * X factor of additional collateral\\n */\\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n neededInLendingTokens = loan(loanID).borrowedAmount.percent(\\n loan(loanID).collateralRatio\\n );\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n uint16 requiredRatio =\\n loan(loanID).collateralRatio -\\n getInterestRatio(loanID) -\\n uint16(PlatformSettingsLib.getCollateralBufferValue());\\n\\n neededInLendingTokens =\\n debt(loanID).principalOwed +\\n debt(loanID).interestOwed;\\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\\n if (\\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\\n ) {\\n neededInLendingTokens -= escrowLoanValue;\\n }\\n neededInLendingTokens = neededInLendingTokens.percent(\\n requiredRatio\\n );\\n }\\n }\\n\\n /**\\n * @notice check if a loan can go to end of auction with a collateral ratio\\n * @return bool checking if collateralRatio is >= the over collateralized buffer value\\n */\\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\\n internal\\n view\\n returns (bool)\\n {\\n return\\n collateralRatio >=\\n PlatformSettingsLib.getOverCollateralizedBufferValue();\\n }\\n\\n /**\\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\\n * @notice There is a minimum threshold of 1%.\\n * @dev The interest rate is APY (annual percentage yield).\\n * @param loanID The loan ID to get the interest rate for.\\n */\\n function getInterestRatio(uint256 loanID)\\n internal\\n view\\n returns (uint16 ratio_)\\n {\\n ratio_ = uint16(\\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\\n SECONDS_PER_YEAR\\n );\\n\\n if (ratio_ == 0) {\\n ratio_ = 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0xe48b287a583b40e534654e4023422f59a9e6d7dd265d68ae4af43f8da58c09d9\",\"license\":\"MIT\"},\"contracts/nft/IStakeableNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IStakeableNFT {\\n function tokenBaseLoanSize(uint256 tokenId) external view returns (uint256);\\n\\n function tokenURIHash(uint256 tokenId)\\n external\\n view\\n returns (string memory);\\n\\n function tokenContributionAsset(uint256 tokenId)\\n external\\n view\\n returns (address);\\n\\n function tokenContributionSize(uint256 tokenId)\\n external\\n view\\n returns (uint256);\\n\\n function tokenContributionMultiplier(uint256 tokenId)\\n external\\n view\\n returns (uint8);\\n}\\n\",\"keccak256\":\"0xfbf44350ad91a54de26f39195d714580d7dade556ea4c7991a51eef5aa839105\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x417b75f5d92be67993efc54db7d453be5b5058a9a54d8916380e0281d3299526\",\"license\":\"MIT\"},\"contracts/nft/TellerNFTDictionary.sol\":{\"content\":\"/**\\n * @notice TellerNFTDictionary Version 1.02\\n *\\n * @notice This contract is used to gather data for TellerV1 NFTs more efficiently.\\n * @notice This contract has data which must be continuously synchronized with the TellerV1 NFT data\\n *\\n * @author develop@teller.finance\\n */\\n\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Interfaces\\nimport \\\"./IStakeableNFT.sol\\\";\\n\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFTDictionary is IStakeableNFT, AccessControlUpgradeable {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n mapping(uint256 => uint256) public baseLoanSizes;\\n mapping(uint256 => string[]) public hashes;\\n mapping(uint256 => address) public contributionAssets;\\n mapping(uint256 => uint256) public contributionSizes;\\n mapping(uint256 => uint8) public contributionMultipliers;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n\\n /* State Variables */\\n\\n mapping(uint256 => uint256) public _tokenTierMappingCompressed;\\n bool public _tokenTierMappingCompressedSet;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFTDictionary: not admin\\\");\\n _;\\n }\\n\\n function initialize(address initialAdmin) public {\\n _setupRole(ADMIN, initialAdmin);\\n _setRoleAdmin(ADMIN, ADMIN);\\n\\n __AccessControl_init();\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTierIndex(uint256 tokenId)\\n public\\n view\\n returns (uint8 index_)\\n {\\n //32 * 8 = 256 - each uint256 holds the data of 32 tokens . 8 bits each.\\n\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 compressedRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n //use 31 instead of 32 to account for the '0x' in the start.\\n //the '31 -' reverses our bytes order which is necessary\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint8 tierIndex = uint8((compressedRegister >> offset));\\n\\n return tierIndex;\\n }\\n\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory)\\n {\\n return hashes[tierIndex];\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTier(uint256 index, Tier memory newTier)\\n external\\n onlyAdmin\\n returns (bool)\\n {\\n baseLoanSizes[index] = newTier.baseLoanSize;\\n hashes[index] = newTier.hashes;\\n contributionAssets[index] = newTier.contributionAsset;\\n contributionSizes[index] = newTier.contributionSize;\\n contributionMultipliers[index] = newTier.contributionMultiplier;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param tiersMapping Information about the new tiers to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setAllTokenTierMappings(uint256[] memory tiersMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n require(\\n !_tokenTierMappingCompressedSet,\\n \\\"TellerNFTDictionary: token tier mapping already set\\\"\\n );\\n for (uint256 i = 0; i < tiersMapping.length; i++) {\\n _tokenTierMappingCompressed[i] = tiersMapping[i];\\n }\\n\\n _tokenTierMappingCompressedSet = true;\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param index the mapping row, each holds data for 32 tokens\\n * @param tierMapping Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierMapping(uint256 index, uint256 tierMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n _tokenTierMappingCompressed[index] = tierMapping;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenIds the NFT token Ids for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenIds(\\n uint256[] calldata tokenIds,\\n uint256 tokenTier\\n ) public onlyAdmin returns (bool) {\\n for (uint256 i; i < tokenIds.length; i++) {\\n setTokenTierForTokenId(tokenIds[i], tokenTier);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenId the NFT token Id for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenId(uint256 tokenId, uint256 tokenTier)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 existingRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint256 updateMaskShifted =\\n 0x00000000000000000000000000000000000000000000000000000000000000FF <<\\n offset;\\n\\n uint256 updateMaskShiftedNegated = ~updateMaskShifted;\\n\\n uint256 tokenTierShifted =\\n ((0x0000000000000000000000000000000000000000000000000000000000000000 |\\n tokenTier) << offset);\\n\\n uint256 existingRegisterClearedWithMask =\\n existingRegister & updateMaskShiftedNegated;\\n\\n uint256 updatedRegister =\\n existingRegisterClearedWithMask | tokenTierShifted;\\n\\n _tokenTierMappingCompressed[mappingIndex] = updatedRegister;\\n\\n return true;\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(IStakeableNFT).interfaceId ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n New methods for the dictionary\\n */\\n\\n /**\\n * @notice It returns Base Loan Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenBaseLoanSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return baseLoanSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Token URI Hash for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenURIHash(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n string[] memory tierImageHashes = hashes[tokenTier];\\n return tierImageHashes[tokenId % (tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice It returns Contribution Asset for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionAsset(uint256 tokenId)\\n public\\n view\\n override\\n returns (address)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionAssets[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Multiplier for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionMultiplier(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint8)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionMultipliers[tokenTier];\\n }\\n}\\n\",\"keccak256\":\"0xf33e3fa1f609fdd2abb3b5fb9c232269d13363a3e4fa5697ea96269e361e74fa\"},\"contracts/nft/libraries/NFTLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../TellerNFT.sol\\\";\\n\\n// Libraries\\nimport {\\n MerkleProof\\n} from \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\nimport { NFTStorageLib, NFTStorage } from \\\"../../storage/nft.sol\\\";\\n\\nlibrary NFTLib {\\n function s() internal pure returns (NFTStorage storage s_) {\\n s_ = NFTStorageLib.store();\\n }\\n\\n function nft() internal view returns (TellerNFT nft_) {\\n nft_ = AppStorageLib.store().nft;\\n }\\n\\n /**s\\n * @notice it transfers the NFT from the sender to the diamond to stake then adds the NFTID to the list of the owner's stakedNFTs\\n * @param nftID the ID of the NFT to stake\\n * @param owner the owner of the NFT who will stake the NFT\\n */\\n function stake(uint256 nftID, address owner) internal {\\n // Transfer to diamond\\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\\n // Add NFT ID to user set\\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\\n }\\n\\n /**\\n * @notice it unstakes the NFT by removing the NFT ID from the list of the user's staked NFTs\\n * @param nftID the ID of the NFT to remove from the list of the user's staked NFTs\\n * @return success_ the boolean value telling us if the user has unsuccessfully unstaked the NFT\\n */\\n function unstake(uint256 nftID) internal returns (bool success_) {\\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\\n }\\n\\n /**\\n * @notice it gets the list of staked NFTs from the owner\\n * @param nftOwner the owner of the staked NFTs to pull from\\n * @return staked_ the array of the staked NFTs owned by the user\\n */\\n function stakedNFTs(address nftOwner)\\n internal\\n view\\n returns (uint256[] memory staked_)\\n {\\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\\n staked_ = new uint256[](EnumerableSet.length(nfts));\\n for (uint256 i; i < staked_.length; i++) {\\n staked_[i] = EnumerableSet.at(nfts, i);\\n }\\n }\\n\\n /**\\n * @notice if the user fails to pay his loan, then we liquidate the all the NFTs associated with the loan\\n * @param loanID the identifier of the loan to liquidate the NFTs from\\n */\\n function liquidateNFT(uint256 loanID) internal {\\n // Check if NFTs are linked\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n NFTLib.nft().transferFrom(\\n address(this),\\n AppStorageLib.store().nftLiquidationController,\\n EnumerableSet.at(nfts, i)\\n );\\n }\\n }\\n\\n /**\\n * @notice it unstakes an NFT and verifies the proof in order to apply the proof to a loan\\n * @param loanID the identifier of the loan\\n * @param nftID the NFT ID to apply to the loan\\n */\\n function applyToLoan(uint256 loanID, uint256 nftID) internal {\\n // NFT must be currently staked\\n // Remove NFT from being staked - returns bool\\n require(unstake(nftID), \\\"Teller: borrower nft not staked\\\");\\n\\n // Apply NFT to loan\\n EnumerableSet.add(s().loanNFTs[loanID], nftID);\\n }\\n\\n /**\\n * @notice it finds the loan's NFTs and adds them back to the owner's list of staked NFTs\\n * @param loanID the identifier of the respective loan to add the NFTs back to the user's staked NFTs\\n * @param owner the owner to add the unstaked NFTs back to the staked pile\\n */\\n function restakeLinked(uint256 loanID, address owner) internal {\\n // Get linked NFT\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n // Restake the NFT\\n EnumerableSet.add(s().stakedNFTs[owner], EnumerableSet.at(nfts, i));\\n }\\n }\\n}\\n\",\"keccak256\":\"0xccbd35c6e8d0130b38f5025ee81c47d55e4fa48c8fcb8bec6f70c21061e0ce61\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n /**\\n * @notice it returns 10^{numberOfDecimals} for a token\\n * @param token the address to calculate the decimals for\\n * @return 10^number of decimals used to calculate the price and value of different token pairs\\n */\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @notice It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @notice it tries to calculate a price from Compound and Chainlink.\\n * @dev if no price is found on compound, then calculate it on chainlink\\n * @param src the token address to calculate the price for in dst\\n * @param dst the token address to retrieve the price of src\\n * @return price_ the price of src in dst\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n * @param src the address of the src token\\n * @param dst the address of the dst token\\n * @return the price of the src token in dst token\\n\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n * @param src the source token to calculate price for with chainlink\\n * @param dst the destination token to calculate price for with chainlink\\n * @param cRate the compound rate to multiply with the price of the dst token\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @notice Scales the {value} by the difference in decimal values.\\n * @param value the the value of the src in dst\\n * @param srcDecimals src token decimals\\n * @param dstDecimals dst token decimals\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @notice it tries to calculate the price of {src} in {dst}\\n * @param src address of source token\\n * @param dst address of destination token\\n * @return the price of src token in dst\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address WETH = AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n if (dst != WETH) {\\n int256 price1 = _priceFor(src, WETH);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, WETH);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice it checks if a token is a cToken. If it is, then get the underlying address\\n * @param token address of the token\\n * @return isCToken boolean whether it's a cToken\\n * @return underlying the address of the cToken\\n */\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2efb3d71a1c0fb49f8c455c4fa30d04c69a1617d619035fc400dabdeb2ab0c9e\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { PriceAggFacet } from \\\"./PriceAggFacet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\n/**\\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\\n */\\nlibrary PriceAggLib {\\n /**\\n * @notice It calculates the value of one token amount into another\\n * @param src the source token\\n * @param dst the destination token\\n * @param srcAmount the amount of source token\\n * @return value_ the returned value of src in dst\\n */\\n function valueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) internal view returns (uint256 value_) {\\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\\n }\\n\\n /**\\n * @notice It returns the price of the token pair as given from Compound.\\n * @dev if no compound price is calculated, then it checks Chainlink price Aggregator\\n * @param src the address of the source token\\n * @param dst the address of the desitnation token\\n * @return price_ gets the price of src in dst\\n */\\n function priceFor(address src, address dst)\\n internal\\n view\\n returns (int256 price_)\\n {\\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\\n }\\n}\\n\",\"keccak256\":\"0xff59eee567fa4a7f5cac432e31d918be92834f04614f49572d3984a5b030ac79\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\nabstract contract PausableMods {\\n /**\\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\\n * @param id id of the facet to check if is paused.\\n * @param state Boolean that the protocol AND facet should be in.\\n */\\n modifier paused(bytes32 id, bool state) {\\n require(\\n __isPaused(\\\"\\\") == state && __isPaused(id) == state,\\n __pausedMessage(state)\\n );\\n _;\\n }\\n\\n /**\\n * @dev Checks if the given id is paused.\\n * @param id Encoded id of the facet to check if is paused.\\n * @return the bool to tell us if the facet is paused (true) or not (false)\\n */\\n function __isPaused(bytes32 id) private view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n\\n /**\\n * @dev Gets the message that should be reverted with given a state it should be in.\\n * @param state Boolean that an id should be in.\\n * @return a message stating whether the facet is paused or not\\n */\\n function __pausedMessage(bool state) private pure returns (string memory) {\\n return state ? \\\"Pausable: not paused\\\" : \\\"Pausable: paused\\\";\\n }\\n}\\n\",\"keccak256\":\"0x2d3f848ee56ae5fa365539c2509c03c167affc89c89f98bb98cb9b83fbe8ae4c\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"NFTInterestRate\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getNFTInterestRate() internal view returns (uint16 value_) {\\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0x44294be1af9f913b2ed391a40cd4b646537a4b463b8d5ff1fac8ead3988966c1\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for loans taken out with an NFT.\\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\\n */\\nbytes32 constant NFT_INTEREST_RATE = keccak256(\\\"NFTInterestRate\\\");\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xd68a7df42b2bbba6f935d5890b7b37997c1432e25ae113827b8bde87f94fd86f\",\"license\":\"MIT\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n /**\\n * @notice Checks if the account should be allowed to mint tokens in the given market\\n * @param cToken The market to verify the mint against\\n * @param minter The account which would get the minted tokens\\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates mint and reverts on rejection. May emit logs.\\n * @param cToken Asset being minted\\n * @param minter The address minting the tokens\\n * @param mintAmount The amount of the underlying asset being minted\\n * @param mintTokens The number of tokens being minted\\n */\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to redeem tokens in the given market\\n * @param cToken The market to verify the redeem against\\n * @param redeemer The account which would redeem the tokens\\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates redeem and reverts on rejection. May emit logs.\\n * @param cToken Asset being redeemed\\n * @param redeemer The address redeeming the tokens\\n * @param redeemAmount The amount of the underlying asset being redeemed\\n * @param redeemTokens The number of tokens being redeemed\\n */\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\\n * @param cToken The market to verify the borrow against\\n * @param borrower The account which would borrow the asset\\n * @param borrowAmount The amount of underlying the account would borrow\\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates borrow and reverts on rejection. May emit logs.\\n * @param cToken Asset whose underlying is being borrowed\\n * @param borrower The address borrowing the underlying\\n * @param borrowAmount The amount of the underlying asset requested to borrow\\n */\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to repay a borrow in the given market\\n * @param cToken The market to verify the repay against\\n * @param payer The account which would repay the asset\\n * @param borrower The account which would borrowed the asset\\n * @param repayAmount The amount of the underlying asset the account would repay\\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\\n * @param cToken Asset being repaid\\n * @param payer The address repaying the borrow\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param borrowerIndex the index of the borrower\\n */\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n /**\\n * @notice Checks if the liquidation should be allowed to occur\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n */\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the seizing of assets should be allowed to occur\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates seize and reverts on rejection. May emit logs.\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to transfer tokens in the given market\\n * @param cToken The market to verify the transfer against\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates transfer and reverts on rejection. May emit logs.\\n * @param cToken Asset being transferred\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n */\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in all markets\\n * @param holder The address to claim COMP for\\n */\\n function claimComp(address holder) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in the specified markets\\n * @param holder The address to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n */\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n /**\\n * @notice Claim all comp accrued by the holders\\n * @param holders The addresses to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n * @param borrowers Whether or not to claim COMP earned by borrowing\\n * @param suppliers Whether or not to claim COMP earned by supplying\\n */\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n /**\\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\\n * @param cTokenBorrowed The address of the borrowed cToken\\n * @param cTokenCollateral The address of the collateral cToken\\n * @param repayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\\n */\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n /**\\n * @notice Return the address of the COMP token\\n * @return The address of COMP\\n */\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x38a824a4a21ce9370fa581a616d1bb9d311f27d8982a6b96ebeba90bd5fd0adb\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n \\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x37849041e4bee2dfa825677f69078521fcc94804aa5120f67dd12cc4133efcec\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @dev CETH is the only Compound token that does not support the {underlying} function.\\n * @param cToken address of the compound token\\n * @return address of the underlying cToken\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x99206384c27b0e68b1ec7b82260f6a47965f611875c018bc076ff8a688a6c6d7\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n /**\\n * @notice it returns the absolute number of a specified parameter\\n * @param self the number to be returned in it's absolute \\n * @return the absolute number\\n */\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0xa852b8866a3d6d928c6575bf2bcf2ae784eed73717c78c0cadbdedf8b0ba3274\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0c52fdd76b33f74e233c3a27dd3b73b134e9643aab347b3aa649c504809c6559\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\n// DEPRECATED\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\nstruct LoanRequest {\\n LoanUserRequest request;\\n LoanConsensusResponse[] responses;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanUserRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanConsensusResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) _loanTerms; // DEPRECATED: DO NOT REMOVE\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb7e05aeec806b5621512def93f4a389b4ef88c50ef9fe7115a33f57db2f2304b\",\"license\":\"MIT\"},\"contracts/storage/nft.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"../nft/TellerNFTDictionary.sol\\\";\\n\\n// Utils\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct NFTStorage {\\n // Maps NFT owner to set of token IDs owned\\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\\n // Maps loanID to NFT IDs indicating NFT being used for the loan\\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\\n // Merkle root used for verifying nft IDs to base loan size\\n TellerNFTDictionary nftDictionary;\\n}\\n\\nbytes32 constant NFT_STORAGE_POS = keccak256(\\\"teller.staking.storage\\\");\\n\\nlibrary NFTStorageLib {\\n function store() internal pure returns (NFTStorage storage s) {\\n bytes32 pos = NFT_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd44f213be3125ea2e2de120c241832f1861be18b3ff2fd4c3baa52ea20b94812\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", - "bytecode": "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", - "deployedBytecode": "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", + "solcInputHash": "151024dde4edc20ecc11a6b585cef1b4", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"liquidator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"reward\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokensIn\",\"type\":\"uint256\"}],\"name\":\"LoanLiquidated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountPaid\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"totalOwed\",\"type\":\"uint256\"}],\"name\":\"LoanRepaid\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"}],\"name\":\"TokensClaimed\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"claimTokens\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"escrowRepay\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLiquidationReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"inLending_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"inCollateral_\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"liquidateLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"repayLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"params\":{\"borrower\":\"Account address of the borrower\",\"liquidator\":\"Account address of the liquidator\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"reward\":\"Value in lending token paid out to liquidator\",\"tokensIn\":\"Percentage of the collateral price paid by the liquidator to the lending pool\"}},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"params\":{\"amountPaid\":\"Amount of the loan paid back\",\"borrower\":\"Account address of the borrower\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"payer\":\"Account address of the payer\",\"totalOwed\":\"Total amount of the loan to be repaid\"}}},\"kind\":\"dev\",\"methods\":{\"claimTokens(uint256)\":{\"params\":{\"loanID\":\"The id of the loan being used.\"}},\"escrowRepay(uint256,uint256)\":{\"details\":\"If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\",\"params\":{\"amount\":\"The amount being repaid.\",\"loanID\":\"The id of the loan being used.\"}},\"getLiquidationReward(uint256)\":{\"params\":{\"loanID\":\"The loan ID to get the info.\"},\"returns\":{\"inCollateral_\":\"The value the liquidator will receive denoted in collateral tokens.\",\"inLending_\":\"The value the liquidator will receive denoted in lending tokens.\"}},\"liquidateLoan(uint256)\":{\"params\":{\"loanID\":\"The ID of the loan to be liquidated\"}},\"repayLoan(uint256,uint256)\":{\"params\":{\"amount\":\"The amount of tokens to pay back to the loan\",\"loanID\":\"The ID of the loan the payment is for\"}}},\"version\":1},\"userdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully liquidated\"},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully repaid\"},\"TokensClaimed(address)\":{\"notice\":\"Notifies when the Escrow's tokens have been claimed.\"}},\"kind\":\"user\",\"methods\":{\"claimTokens(uint256)\":{\"notice\":\"Sends the tokens owned by this escrow to the owner.\"},\"escrowRepay(uint256,uint256)\":{\"notice\":\"Repay this Escrow's loan.\"},\"getLiquidationReward(uint256)\":{\"notice\":\"It gets the current liquidation reward for a given loan.\"},\"liquidateLoan(uint256)\":{\"notice\":\"Liquidate a loan if it is expired or under collateralized\"},\"repayLoan(uint256,uint256)\":{\"notice\":\"Make a payment to a loan\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/market/RepayFacet.sol\":\"RepayFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Trees proofs.\\n *\\n * The proofs can be generated using the JavaScript library\\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\\n *\\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n bytes32 computedHash = leaf;\\n\\n for (uint256 i = 0; i < proof.length; i++) {\\n bytes32 proofElement = proof[i];\\n\\n if (computedHash <= proofElement) {\\n // Hash(current computed hash + current element of the proof)\\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\\n } else {\\n // Hash(current element of the proof + current computed hash)\\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\\n }\\n }\\n\\n // Check if the computed hash (root) is equal to the provided root\\n return computedHash == root;\\n }\\n}\\n\",\"keccak256\":\"0xeee34bfb413657b6cd6c8e1e15c2080ba5ebaac479578515922804346fb63f7c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/reentry/ReentryMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nabstract contract ReentryMods {\\n modifier nonReentry(bytes32 id) {\\n AccessControlStorage storage s = AccessControlStorageLib.store();\\n require(!s.entered[id], \\\"AccessControl: reentered\\\");\\n s.entered[id] = true;\\n _;\\n s.entered[id] = false;\\n }\\n}\\n\",\"keccak256\":\"0x033c1164af25ef7d35a38a60973bf379b1cc603596914ffd85dcbcf0acdb6970\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/EscrowClaimTokens.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\n\\n// Interfaces\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, LoanStatus } from \\\"../storage/market.sol\\\";\\n\\n// Libraries\\nimport { LibLoans } from \\\"../market/libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"./libraries/LibEscrow.sol\\\";\\n\\n/**\\n * @notice Contains functionality to claim tokens that are in an escrow contract for a loan.\\n */\\ncontract EscrowClaimTokens is PausableMods {\\n /**\\n * @notice Notifies when the Escrow's tokens have been claimed.\\n * @param recipient address where the tokens where sent to.\\n */\\n event TokensClaimed(address recipient);\\n\\n /**\\n * @notice Sends the tokens owned by this escrow to the owner.\\n * @param loanID The id of the loan being used.\\n */\\n function claimTokens(uint256 loanID) external paused(\\\"\\\", false) {\\n require(\\n LibLoans.loan(loanID).borrower == msg.sender,\\n \\\"Teller: claim not borrower\\\"\\n );\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Closed,\\n \\\"Teller: loan not closed\\\"\\n );\\n\\n __claimEscrowTokens(loanID);\\n }\\n\\n function __claimEscrowTokens(uint256 loanID) internal {\\n __claimToken(loanID, LibLoans.loan(loanID).lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n __claimToken(loanID, EnumerableSet.at(tokens, i));\\n }\\n\\n emit TokensClaimed(msg.sender);\\n }\\n\\n function __claimToken(uint256 loanID, address token) private {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n if (balance > 0) {\\n LibEscrow.e(loanID).claimToken(\\n token,\\n LibLoans.loan(loanID).borrower,\\n balance\\n );\\n }\\n }\\n}\\n\",\"keccak256\":\"0xae189ea2a13c10f013f255f98ec50f34466c375bd7503275587d6abe5d25696c\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../interfaces/IAToken.sol\\\";\\nimport { IAaveLendingPool } from \\\"../interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x8030b206c87d0073fb7dbebfa2ee8a3e93c479d976d6cdaa0c939f2fedaa1525\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n /**\\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\\n * @param dappAddress address of the target contract address\\n * @param dappData encoded abi of the function in our contract we want to call\\n * @return the called data in bytes\\n */\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n /**\\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\\n * @param token address of the respective ERC20 token to approve for the spender\\n * @param spender address of the respective spender who is approved by the token contract\\n */\\n function setTokenAllowance(address token, address spender) external;\\n\\n /**\\n * @notice it allows user to claim their escrow tokens\\n * @dev only the owner (TellerDiamond) can make this call on behalf of the users\\n * @param token address of the respective token contract to claim tokens from\\n * @param to address where the tokens should be transferred to\\n * @param amount uint256 amount of tokens to be claimed\\n */\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xaf67fc4454ffaa4d2f7e46fe7101876e8ebdb1a5426c30f87b8e18cc573ac019\",\"license\":\"MIT\"},\"contracts/escrow/libraries/LibEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibDapps } from \\\"../dapps/libraries/LibDapps.sol\\\";\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibEscrow {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\\n e_ = s().loanEscrows[loanID];\\n }\\n\\n function exists(uint256 loanID) internal view returns (bool) {\\n return address(e(loanID)) != address(0);\\n }\\n\\n /**\\n * @notice It returns a list of tokens owned by a loan escrow\\n * @param loanID uint256 index used to return our token list\\n * @return t_ which is a list of tokens\\n */\\n function getEscrowTokens(uint256 loanID)\\n internal\\n view\\n returns (EnumerableSet.AddressSet storage t_)\\n {\\n t_ = s().escrowTokens[loanID];\\n }\\n\\n /**\\n * @notice It returns the balance of a respective token in a loan escrow\\n * @param loanID uint256 index used to point to our loan escrow\\n * @param token address of respective token to give us the balance of in our loan escrow\\n * @return uint256 balance of respective token returned in an escrow loan\\n */\\n function balanceOf(uint256 loanID, address token)\\n internal\\n view\\n returns (uint256)\\n {\\n return exists(loanID) ? IERC20(token).balanceOf(address(e(loanID))) : 0;\\n }\\n\\n /**\\n * @notice Adds or removes tokens held by the Escrow contract\\n * @param loanID The loan ID to update the token list for\\n * @param tokenAddress The token address to be added or removed\\n */\\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\\n // Skip if is lending token\\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\\n\\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\\n if (balanceOf(loanID, tokenAddress) > 0) {\\n if (!contains) {\\n EnumerableSet.add(tokens, tokenAddress);\\n }\\n } else if (contains) {\\n EnumerableSet.remove(tokens, tokenAddress);\\n }\\n }\\n\\n /**\\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\\n * @param loanID The loan ID to calculate value for\\n * @return value_ Escrow total value denoted in the lending token.\\n */\\n function calculateTotalValue(uint256 loanID)\\n internal\\n view\\n returns (uint256 value_)\\n {\\n if (!exists(loanID)) {\\n return 0;\\n }\\n\\n address lendingToken = LibLoans.loan(loanID).lendingToken;\\n value_ += balanceOf(loanID, lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\\n if (EnumerableSet.length(tokens) > 0) {\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n uint256 tokenBal =\\n balanceOf(loanID, EnumerableSet.at(tokens, i));\\n value_ += PriceAggLib.valueFor(\\n EnumerableSet.at(tokens, i),\\n lendingToken,\\n tokenBal\\n );\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x9ef96410fb3d580843e005cd632174cbcec9860dc04bc949fb56e4637cc95062\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when a user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when a user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n * @return ERC20 token\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n * @return balance_ the balance of the account\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice It calculates the total supply of the underlying asset.\\n * @return totalSupply_ the total supply denoted in the underlying asset.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given market.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n \\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfill the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n * @return mintAmount_ the amount minted of the specified token\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n * @return address of the strategy contract\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n * @param state boolean value that resembles the platform's state\\n */\\n function restrict(bool state) external virtual;\\n\\n /**\\n * @notice it initializes the Teller Token\\n * @param admin address of the admin to the respective Teller Token\\n * @param underlying address of the ERC20 token\\n */\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xf30ac4ef491851477ff9a3dd04974ebe74b529c37a3ef4e05798c3f734ceeb3d\",\"license\":\"MIT\"},\"contracts/market/LoanDataFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { Loan, LoanDebt, LoanTerms } from \\\"../storage/market.sol\\\";\\n\\ncontract LoanDataFacet {\\n /**\\n * @notice Returns the information about the given {loanID}.\\n * @param loanID The loan ID to get information for.\\n * @return loan_ The loan data.\\n */\\n function getLoan(uint256 loanID) external view returns (Loan memory loan_) {\\n loan_ = LibLoans.s().loans[loanID];\\n }\\n\\n /**\\n * @notice DEPRECATED\\n * @notice Returns the terms for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanTerms The terms that the loan weer created with.\\n */\\n function getLoanTerms(uint256 loanID)\\n external\\n view\\n returns (LoanTerms memory)\\n {\\n return LibLoans.terms(loanID);\\n }\\n\\n /**\\n * @notice Returns the loan IDs created by the {borrower} account.\\n * @param borrower The account to get loan IDs for.\\n * @return loanIDs The IDs for loans created by the {borrower}\\n */\\n function getBorrowerLoans(address borrower)\\n external\\n view\\n returns (uint128[] memory loanIDs)\\n {\\n return LibLoans.s().borrowerLoans[borrower];\\n }\\n\\n /**\\n * @notice Returns the debt owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanDebt The principal and interest owed amount.\\n */\\n function getDebtOwed(uint256 loanID)\\n external\\n view\\n returns (LoanDebt memory)\\n {\\n return LibLoans.debt(loanID);\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) external view returns (uint256) {\\n return LibLoans.getTotalOwed(loanID);\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n external\\n view\\n returns (uint256)\\n {\\n return LibLoans.getInterestOwedFor(loanID, amountBorrow);\\n }\\n\\n /**\\n * @notice it returns the collateral needed for a loan\\n * @param loanID the identifier of the loan ID to retrieve collateral from\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n external\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n return LibLoans.getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the typed address of a loan escrow\\n * @param loanID the identifier of the respective escrow's loan\\n * @return escrow_ the typed address of the returned ILoanEscrow\\n */\\n function getLoanEscrow(uint256 loanID)\\n external\\n view\\n returns (address escrow_)\\n {\\n escrow_ = address(LibLoans.s().loanEscrows[loanID]);\\n }\\n\\n /**\\n * @notice it returns the escrow's total value by calculating the value all the escrow tokens\\n * @param loanID the identifier of the respective escrow's loan\\n * @return the total value of the loan escrow\\n */\\n function getLoanEscrowValue(uint256 loanID)\\n external\\n view\\n returns (uint256)\\n {\\n return LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n /**\\n * @notice it returns the total escrow tokens held by an escrow\\n * @param loanID the identifier of the respective escrow's loan\\n * @return tokens_ the tokens held at the escrow loan \\n */\\n function getEscrowTokens(uint256 loanID)\\n external\\n view\\n returns (address[] memory tokens_)\\n {\\n EnumerableSet.AddressSet storage escrowTokens =\\n LibEscrow.getEscrowTokens(loanID);\\n tokens_ = new address[](EnumerableSet.length(escrowTokens));\\n for (uint256 i; i < tokens_.length; i++) {\\n tokens_[i] = EnumerableSet.at(escrowTokens, i);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x9a57f5de00ce073af4ffb2f74e7d8a15e56bc017826f2c5a393ef5b64554145f\",\"license\":\"MIT\"},\"contracts/market/RepayFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\nimport {\\n ReentryMods\\n} from \\\"../contexts2/access-control/reentry/ReentryMods.sol\\\";\\nimport { AUTHORIZED } from \\\"../shared/roles.sol\\\";\\nimport { LoanDataFacet } from \\\"./LoanDataFacet.sol\\\";\\nimport { EscrowClaimTokens } from \\\"../escrow/EscrowClaimTokens.sol\\\";\\n\\n// Libraries\\nimport {\\n IERC20,\\n SafeERC20\\n} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibCollateral } from \\\"./libraries/LibCollateral.sol\\\";\\nimport { LibDapps } from \\\"../escrow/dapps/libraries/LibDapps.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { NumbersLib } from \\\"../shared/libraries/NumbersLib.sol\\\";\\nimport { PriceAggLib } from \\\"../price-aggregator/PriceAggLib.sol\\\";\\nimport { NFTLib } from \\\"../nft/libraries/NFTLib.sol\\\";\\n\\n// Interfaces\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus\\n} from \\\"../storage/market.sol\\\";\\n\\ncontract RepayFacet is RolesMods, ReentryMods, PausableMods, EscrowClaimTokens {\\n /**\\n @notice This event is emitted when a loan has been successfully repaid\\n @param loanID ID of loan from which collateral was withdrawn\\n @param borrower Account address of the borrower\\n @param amountPaid Amount of the loan paid back\\n @param payer Account address of the payer\\n @param totalOwed Total amount of the loan to be repaid\\n */\\n event LoanRepaid(\\n uint256 indexed loanID,\\n address indexed borrower,\\n uint256 amountPaid,\\n address payer,\\n uint256 totalOwed\\n );\\n\\n /**\\n * @notice This event is emitted when a loan has been successfully liquidated\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param borrower Account address of the borrower\\n * @param liquidator Account address of the liquidator\\n * @param reward Value in lending token paid out to liquidator\\n * @param tokensIn Percentage of the collateral price paid by the liquidator to the lending pool\\n */\\n event LoanLiquidated(\\n uint256 indexed loanID,\\n address indexed borrower,\\n address liquidator,\\n uint256 reward,\\n uint256 tokensIn\\n );\\n\\n /**\\n * @notice Repay this Escrow's loan.\\n * @dev If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.\\n * @dev Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\\n * @param loanID The id of the loan being used.\\n * @param amount The amount being repaid.\\n */\\n function escrowRepay(uint256 loanID, uint256 amount)\\n external\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n nonReentry(\\\"\\\")\\n {\\n uint256 balance =\\n LibEscrow.balanceOf(loanID, LibLoans.loan(loanID).lendingToken);\\n uint256 totalOwed = LibLoans.getTotalOwed(loanID);\\n // if there isn't enough balance in the escrow, then transfer amount needed to the escrow\\n if (balance < totalOwed && amount > balance) {\\n uint256 amountNeeded =\\n amount > totalOwed ? totalOwed - (balance) : amount - (balance);\\n\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n msg.sender,\\n address(LibEscrow.e(loanID)),\\n amountNeeded\\n );\\n }\\n\\n __repayLoan(loanID, amount, address(LibEscrow.e(loanID)), false);\\n }\\n\\n /**\\n * @notice Make a payment to a loan\\n * @param loanID The ID of the loan the payment is for\\n * @param amount The amount of tokens to pay back to the loan\\n */\\n function repayLoan(uint256 loanID, uint256 amount)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n __repayLoan(loanID, amount, msg.sender, false);\\n }\\n\\n /**\\n * @notice it repays the loan, either from an escrow or from a regular address\\n * @param loanID the identifier of the loan to repay\\n * @param amount the amount to repay the loan\\n * @param sender the address of the sender that wants to pay, can also be a loan escrow\\n * @param isLiquidation is this loan being liquidated?\\n * @return leftToPay_ the amount left to pay for the loan\\n */\\n function __repayLoan(\\n uint256 loanID,\\n uint256 amount,\\n address sender,\\n bool isLiquidation\\n ) private returns (uint256 leftToPay_) {\\n require(amount > 0, \\\"Teller: zero repay\\\");\\n\\n // calculate the actual amount to repay\\n leftToPay_ =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n if (leftToPay_ < amount) {\\n amount = leftToPay_;\\n leftToPay_ = 0;\\n } else {\\n leftToPay_ -= amount;\\n }\\n\\n // Get the Teller token for the loan\\n ITToken tToken =\\n MarketStorageLib.store().tTokens[\\n LibLoans.loan(loanID).lendingToken\\n ];\\n // Transfer funds from an escrow if an escrow is calling it\\n // Otherwise, transfer funds from an account\\n if (address(LibEscrow.e(loanID)) == sender) {\\n LibEscrow.e(loanID).claimToken(\\n LibLoans.loan(loanID).lendingToken,\\n address(tToken),\\n amount\\n );\\n } else {\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n sender,\\n address(tToken),\\n amount\\n );\\n }\\n\\n // Deduct the interest and principal owed\\n uint256 principalPaid;\\n uint256 interestPaid;\\n if (amount < LibLoans.debt(loanID).interestOwed) {\\n interestPaid = amount;\\n LibLoans.debt(loanID).interestOwed -= amount;\\n } else {\\n if (LibLoans.debt(loanID).interestOwed > 0) {\\n interestPaid = LibLoans.debt(loanID).interestOwed;\\n amount -= interestPaid;\\n LibLoans.debt(loanID).interestOwed = 0;\\n }\\n\\n if (amount > 0) {\\n principalPaid = amount;\\n LibLoans.debt(loanID).principalOwed -= amount;\\n }\\n }\\n\\n // Tell the Teller Token value has been deposited back into the pool.\\n tToken.repayLoan(principalPaid, interestPaid);\\n\\n if (isLiquidation) {\\n // Make sure there is nothing left to repay on the loan\\n require(leftToPay_ == 0, \\\"Teller: liquidate partial repay\\\");\\n\\n // Set loan status\\n LibLoans.loan(loanID).status = LoanStatus.Liquidated;\\n\\n // Transfer NFT if linked\\n NFTLib.liquidateNFT(loanID);\\n } else {\\n // if the loan is now fully paid, close it and withdraw borrower collateral\\n if (leftToPay_ == 0) {\\n LibLoans.loan(loanID).status = LoanStatus.Closed;\\n\\n // Check if the loan has a collateral token\\n if (LibLoans.loan(loanID).collateralToken != address(0)) {\\n LibCollateral.withdrawAll(\\n loanID,\\n LibLoans.loan(loanID).borrower\\n );\\n }\\n\\n // Claim tokens in the escrow for the loan if any\\n __claimEscrowTokens(loanID);\\n\\n // Restake any NFTs linked to loan for borrower\\n NFTLib.restakeLinked(loanID, LibLoans.loan(loanID).borrower);\\n }\\n\\n emit LoanRepaid(\\n loanID,\\n LibLoans.loan(loanID).borrower,\\n amount,\\n msg.sender,\\n leftToPay_\\n );\\n }\\n }\\n\\n /**\\n * @notice Liquidate a loan if it is expired or under collateralized\\n * @param loanID The ID of the loan to be liquidated\\n */\\n function liquidateLoan(uint256 loanID)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n uint256 collateralAmount = LibCollateral.e(loanID).loanSupply(loanID);\\n require(\\n RepayLib.isLiquidable(loanID, collateralAmount),\\n \\\"Teller: does not need liquidation\\\"\\n );\\n\\n // Calculate the reward before repaying the loan\\n (uint256 rewardInLending, uint256 collateralInLending) =\\n RepayLib.getLiquidationReward(loanID, collateralAmount);\\n\\n // The liquidator pays the amount still owed on the loan\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n __repayLoan(loanID, amountToLiquidate, msg.sender, true);\\n\\n // Payout the liquidator reward owed\\n if (rewardInLending > 0) {\\n RepayLib.payOutLiquidator(\\n loanID,\\n rewardInLending,\\n collateralInLending,\\n collateralAmount,\\n payable(msg.sender)\\n );\\n }\\n\\n emit LoanLiquidated(\\n loanID,\\n loan.borrower,\\n msg.sender,\\n rewardInLending,\\n amountToLiquidate\\n );\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @return inLending_ The value the liquidator will receive denoted in lending tokens.\\n * @return inCollateral_ The value the liquidator will receive denoted in collateral tokens.\\n */\\n function getLiquidationReward(uint256 loanID)\\n external\\n view\\n returns (uint256 inLending_, uint256 inCollateral_)\\n {\\n (inLending_, ) = RepayLib.getLiquidationReward(\\n loanID,\\n LibCollateral.e(loanID).loanSupply(loanID)\\n );\\n inCollateral_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n inLending_\\n );\\n }\\n}\\n\\nlibrary RepayLib {\\n /**\\n * @notice It checks if a loan can be liquidated.\\n * @param loanID The loan ID to check.\\n * @return true if the loan is liquidable.\\n */\\n function isLiquidable(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (bool)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n // Check if loan can be liquidated\\n if (loan.status != LoanStatus.Active) {\\n return false;\\n }\\n\\n if (loan.collateralRatio > 0) {\\n // If loan has a collateral ratio, check how much is needed\\n (, uint256 neededInCollateral, ) =\\n LoanDataFacet(address(this)).getCollateralNeededInfo(loanID);\\n if (neededInCollateral > collateralAmount) {\\n return true;\\n }\\n }\\n\\n // Otherwise, check if the loan has expired\\n return block.timestamp >= loan.loanStartTime + loan.duration;\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @param collateralAmount The amount of collateral for the {loanID}. Passed in to save gas calling the collateral escrow multiple times.\\n * @return reward_ The value the liquidator will receive denoted in lending tokens.\\n */\\n function getLiquidationReward(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (uint256 reward_, uint256 collateralValue_)\\n {\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n // Max reward is amount repaid on loan plus extra percentage\\n uint256 maxReward =\\n amountToLiquidate +\\n NumbersLib.percent(\\n amountToLiquidate,\\n uint16(PlatformSettingsLib.getLiquidateRewardPercent())\\n );\\n\\n // Calculate available collateral for reward\\n if (collateralAmount > 0) {\\n collateralValue_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).collateralToken,\\n LibLoans.loan(loanID).lendingToken,\\n collateralAmount\\n );\\n reward_ += collateralValue_;\\n }\\n\\n // Calculate loan escrow value if collateral not enough to cover reward\\n if (reward_ < maxReward) {\\n reward_ += LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n // Cap the reward to max\\n if (reward_ > maxReward) {\\n reward_ = maxReward;\\n }\\n }\\n\\n /**\\n * @notice Checks if the loan has an Escrow and claims any tokens then pays out the loan collateral.\\n * @dev See Escrow.claimTokens for more info.\\n * @param loanID The loan ID which is being liquidated\\n * @param rewardInLending The total amount of reward based in the lending token to pay the liquidator\\n * @param collateralInLending The amount of collateral that is available for the loan denoted in lending tokens\\n * @param collateralAmount The amount of collateral that is available for the loan\\n * @param liquidator The address of the liquidator where the liquidation reward will be sent to\\n */\\n function payOutLiquidator(\\n uint256 loanID,\\n uint256 rewardInLending,\\n uint256 collateralInLending,\\n uint256 collateralAmount,\\n address payable liquidator\\n ) internal {\\n // check if loan is liquidated\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Liquidated,\\n \\\"Teller: loan not liquidated\\\"\\n );\\n\\n // if the lending reward is less than the collateral lending tokens, then aggregate\\n // the value for the lending token with the collateral token and send it to the liquidator\\n if (rewardInLending <= collateralInLending) {\\n uint256 rewardInCollateral =\\n PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n rewardInLending\\n );\\n\\n LibCollateral.withdraw(loanID, rewardInCollateral, liquidator);\\n } else {\\n // Payout whats available in the collateral token\\n LibCollateral.withdraw(loanID, collateralAmount, liquidator);\\n\\n // Claim remaining reward value from the loan escrow\\n claimEscrowTokensByValue(\\n loanID,\\n liquidator,\\n rewardInLending - collateralInLending\\n );\\n }\\n }\\n\\n /**\\n * @dev Send the equivalent of tokens owned by the loan escrow (in lending value) to the recipient,\\n * @param loanID The loan ID to clam tokens from\\n * @param recipient address to send the tokens to\\n * @param value The value of escrow held tokens to be claimed based in lending value\\n */\\n function claimEscrowTokensByValue(\\n uint256 loanID,\\n address recipient,\\n uint256 value\\n ) private {\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n uint256 valueLeftToTransfer = value;\\n\\n // Start with the lending token\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n LibLoans.loan(loanID).lendingToken,\\n recipient,\\n valueLeftToTransfer\\n );\\n\\n // Cycle through remaining tokens\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n if (valueLeftToTransfer == 0) {\\n return;\\n }\\n\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n EnumerableSet.at(tokens, i),\\n recipient,\\n valueLeftToTransfer\\n );\\n }\\n }\\n\\n /**\\n * @notice it claims the escrow tokens for the liquidator\\n * @notice it keeps claiming escrow tokens until there aren't anymore tokens or the valueLeftToTransfer is zero\\n * @param loanID the identifier of the escrow loan to claim tokens from\\n * @param token the address of the token asset to claim\\n * @param recipient the address of the recipient to transfer the tokens to\\n * @param valueLeftToTransfer the value left to transfer to the liquidator that is returned back\\n * @return the value left to transfer\\n */\\n function claimEscrowToken(\\n uint256 loanID,\\n address token,\\n address recipient,\\n uint256 valueLeftToTransfer\\n ) private returns (uint256) {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n // get value of token balance in lending value\\n if (balance > 0) {\\n // If token not the lending token, get value of token\\n uint256 balanceInLending;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n balanceInLending = balance;\\n } else {\\n balanceInLending = PriceAggLib.valueFor(\\n token,\\n LibLoans.loan(loanID).lendingToken,\\n balance\\n );\\n }\\n\\n if (balanceInLending <= valueLeftToTransfer) {\\n LibEscrow.e(loanID).claimToken(token, recipient, balance);\\n valueLeftToTransfer -= balanceInLending;\\n } else {\\n // Token balance is more than enough so calculate ratio of balance to transfer\\n uint256 valueToTransfer;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n valueToTransfer = valueLeftToTransfer;\\n } else {\\n valueToTransfer = NumbersLib.percent(\\n balance,\\n NumbersLib.ratioOf(\\n valueLeftToTransfer,\\n balanceInLending\\n )\\n );\\n }\\n\\n LibEscrow.e(loanID).claimToken(\\n token,\\n recipient,\\n valueToTransfer\\n );\\n valueLeftToTransfer = 0;\\n }\\n }\\n return valueLeftToTransfer;\\n }\\n}\\n\",\"keccak256\":\"0xc440b61519f74c4eba549f1f531726b1cd8b3da60ba7654cccd4eb9bd9fd7020\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n /**\\n * @notice it initializes an escrow\\n * @param tokenAddress the address of the collateral token to be stored\\n * @param isWETH check if it's wrapped Ethereum\\n */\\n function init(address tokenAddress, bool isWETH) external;\\n\\n /**\\n * @notice it deposits an amount of the respective collateral token into the escrow\\n * @param loanID the ID of the loan\\n * @param amount the amount of collateral tokens to be deposited\\n */\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n /**\\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\\n * @dev only the TellerDiamond can make this call on behalf of the borrower\\n * @param loanID identifier of the loan\\n * @param amount number of collateral tokens to send\\n * @param receiver payable address to transfer money to\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n /**\\n * @notice it returns the supply of the respective loan\\n * @param loanID the respective loan ID\\n * @return supply_ the amount in collateral of the respective loan\\n */\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n /**\\n * @notice it returns the total supply of the collateral token held by the contract\\n * @return supply_ the total amount of collateral\\n */\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x900fed2311f919ba1451a6583ddbf9f3bc8afa8f5189500fff51f0c049258ed3\",\"license\":\"MIT\"},\"contracts/market/libraries/LibCollateral.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport { ICollateralEscrow } from \\\"../collateral/ICollateralEscrow.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\nimport { MarketStorageLib } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibCollateral {\\n /**\\n * @notice This event is emitted when collateral has been deposited for the loan\\n * @param loanID ID of the loan for which collateral was deposited\\n * @param depositor Account that deposited funds\\n * @param amount Amount of collateral deposited\\n */\\n event CollateralDeposited(\\n uint256 indexed loanID,\\n address indexed depositor,\\n uint256 amount\\n );\\n\\n /**\\n * @notice This event is emitted when collateral has been withdrawn\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param receiver Account that received funds\\n * @param amount Value of collateral withdrawn\\n */\\n event CollateralWithdrawn(\\n uint256 indexed loanID,\\n address indexed receiver,\\n uint256 amount\\n );\\n\\n /**\\n * @notice it gets MarketStorage's collateral escrow using the loanID\\n * @param loanID the loanID to be used\\n * @return c_ which is the collateral escrow\\n */\\n function e(uint256 loanID) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[\\n MarketStorageLib.store().loans[loanID].collateralToken\\n ];\\n }\\n\\n function e(address token) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[token];\\n }\\n\\n /**\\n * @notice it deposits an amount of collateral into a collateral escrow's address of a respective loan\\n * @param loanID the respective loan ID\\n * @param amount the amount of collateral to deposit\\n */\\n function deposit(uint256 loanID, uint256 amount) internal {\\n e(loanID).deposit{ value: amount }(loanID, amount);\\n\\n emit CollateralDeposited(loanID, msg.sender, amount);\\n }\\n\\n /**\\n * @notice it withdraws an amount from the collateral escrow\\n * @param loanID the respective loanID to withdraw from\\n * @param amount the number of collateral tokens to withdraw\\n * @param receiver the address who receives the withdrawal\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) internal {\\n e(loanID).withdraw(loanID, amount, receiver);\\n\\n emit CollateralWithdrawn(loanID, receiver, amount);\\n }\\n\\n /**\\n * @notice it withdraws the entire supply in collateral of a respective loan to an address\\n * @param loanID the respective loan's ID\\n * @param receiver the address of the receiver to withdraw tokens from\\n */\\n function withdrawAll(uint256 loanID, address payable receiver) internal {\\n withdraw(loanID, e(loanID).loanSupply(loanID), receiver);\\n }\\n\\n /**\\n * @notice it initializes a new escrow collateral to hold collateral tokens\\n * @param token address of the collateral token it holds\\n */\\n function createEscrow(address token) internal {\\n // Check if collateral escrow exists\\n if (address(e(token)) == address(0)) {\\n // Create escrow\\n address escrow =\\n AppStorageLib.store().collateralEscrowBeacon.cloneProxy(\\\"\\\");\\n ICollateralEscrow(escrow).init(\\n token,\\n // Check if collateral token is WETH\\n token == AppStorageLib.store().assetAddresses[\\\"WETH\\\"]\\n );\\n\\n // Set max allowance\\n IERC20(token).approve(escrow, type(uint256).max);\\n // Save escrow address for loan\\n MarketStorageLib.store().collateralEscrows[\\n token\\n ] = ICollateralEscrow(escrow);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x84dbab8283357a1cc4210e34642fc8247841a58973778f4f6570398cc3046947\",\"license\":\"MIT\"},\"contracts/market/libraries/LibLoans.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibEscrow } from \\\"../../escrow/libraries/LibEscrow.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus,\\n LoanDebt,\\n LoanTerms\\n} from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibLoans {\\n using NumbersLib for int256;\\n using NumbersLib for uint256;\\n\\n bytes32 internal constant ID = keccak256(\\\"LOANS\\\");\\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n * @notice it returns the loan\\n * @param loanID the ID of the respective loan\\n * @return l_ the loan \\n */\\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\\n l_ = s().loans[loanID];\\n }\\n\\n /**\\n * @notice it returns the loan debt from a respective loan\\n * @param loanID the ID of the respective loan\\n * @return d_ the loan debt from a respective loan\\n */\\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\\n d_ = s().loanDebt[loanID];\\n }\\n\\n // DEPRECATED\\n function terms(uint256 loanID)\\n internal\\n view\\n returns (LoanTerms storage t_)\\n {\\n t_ = s()._loanTerms[loanID];\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return owed_ uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID)\\n internal\\n view\\n returns (uint256 owed_)\\n {\\n if (loan(loanID).status == LoanStatus.Active) {\\n owed_ = debt(loanID).principalOwed + (debt(loanID).interestOwed);\\n }\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n internal\\n view\\n returns (uint256)\\n {\\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\\n }\\n \\n function getCollateralNeeded(uint256 loanID)\\n internal\\n view\\n returns (uint256 _needed)\\n {\\n (, _needed, ) = getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the total collateral needed in lending tokens, in collateral tokens and in escrowed loan values\\n * @param loanID the loanID to get the total collateral needed\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n internal\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\\n loanID\\n );\\n\\n // check if needed lending tokens is zero. if true, then needed collateral tokens is zero. else,\\n if (neededInLendingTokens == 0) {\\n neededInCollateralTokens = 0;\\n } else {\\n neededInCollateralTokens = PriceAggLib.valueFor(\\n loan(loanID).lendingToken,\\n loan(loanID).collateralToken,\\n neededInLendingTokens\\n );\\n }\\n }\\n\\n /**\\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\\n * @param loanID The loan ID to get needed collateral info for.\\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\\n */\\n function getCollateralNeededInTokens(uint256 loanID)\\n internal\\n view\\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\\n {\\n if (loan(loanID).collateralRatio == 0) {\\n return (0, 0);\\n }\\n\\n /*\\n The collateral to principal owed ratio is the sum of:\\n * collateral buffer percent\\n * loan interest rate\\n * liquidation reward percent\\n * X factor of additional collateral\\n */\\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n neededInLendingTokens = loan(loanID).borrowedAmount.percent(\\n loan(loanID).collateralRatio\\n );\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n uint16 requiredRatio =\\n loan(loanID).collateralRatio -\\n getInterestRatio(loanID) -\\n uint16(PlatformSettingsLib.getCollateralBufferValue());\\n\\n neededInLendingTokens =\\n debt(loanID).principalOwed +\\n debt(loanID).interestOwed;\\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\\n if (\\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\\n ) {\\n neededInLendingTokens -= escrowLoanValue;\\n }\\n neededInLendingTokens = neededInLendingTokens.percent(\\n requiredRatio\\n );\\n }\\n }\\n\\n /**\\n * @notice check if a loan can go to end of auction with a collateral ratio\\n * @return bool checking if collateralRatio is >= the over collateralized buffer value\\n */\\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\\n internal\\n view\\n returns (bool)\\n {\\n return\\n collateralRatio >=\\n PlatformSettingsLib.getOverCollateralizedBufferValue();\\n }\\n\\n /**\\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\\n * @notice There is a minimum threshold of 1%.\\n * @dev The interest rate is APY (annual percentage yield).\\n * @param loanID The loan ID to get the interest rate for.\\n */\\n function getInterestRatio(uint256 loanID)\\n internal\\n view\\n returns (uint16 ratio_)\\n {\\n ratio_ = uint16(\\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\\n SECONDS_PER_YEAR\\n );\\n\\n if (ratio_ == 0) {\\n ratio_ = 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0xe48b287a583b40e534654e4023422f59a9e6d7dd265d68ae4af43f8da58c09d9\",\"license\":\"MIT\"},\"contracts/nft/IStakeableNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IStakeableNFT {\\n function tokenBaseLoanSize(uint256 tokenId) external view returns (uint256);\\n\\n function tokenURIHash(uint256 tokenId)\\n external\\n view\\n returns (string memory);\\n\\n function tokenContributionAsset(uint256 tokenId)\\n external\\n view\\n returns (address);\\n\\n function tokenContributionSize(uint256 tokenId)\\n external\\n view\\n returns (uint256);\\n\\n function tokenContributionMultiplier(uint256 tokenId)\\n external\\n view\\n returns (uint8);\\n}\\n\",\"keccak256\":\"0xfbf44350ad91a54de26f39195d714580d7dade556ea4c7991a51eef5aa839105\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x417b75f5d92be67993efc54db7d453be5b5058a9a54d8916380e0281d3299526\",\"license\":\"MIT\"},\"contracts/nft/TellerNFTDictionary.sol\":{\"content\":\"/**\\n * @notice TellerNFTDictionary Version 1.02\\n *\\n * @notice This contract is used to gather data for TellerV1 NFTs more efficiently.\\n * @notice This contract has data which must be continuously synchronized with the TellerV1 NFT data\\n *\\n * @author develop@teller.finance\\n */\\n\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Interfaces\\nimport \\\"./IStakeableNFT.sol\\\";\\n\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFTDictionary is IStakeableNFT, AccessControlUpgradeable {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n mapping(uint256 => uint256) public baseLoanSizes;\\n mapping(uint256 => string[]) public hashes;\\n mapping(uint256 => address) public contributionAssets;\\n mapping(uint256 => uint256) public contributionSizes;\\n mapping(uint256 => uint8) public contributionMultipliers;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n\\n /* State Variables */\\n\\n mapping(uint256 => uint256) public _tokenTierMappingCompressed;\\n bool public _tokenTierMappingCompressedSet;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFTDictionary: not admin\\\");\\n _;\\n }\\n\\n function initialize(address initialAdmin) public {\\n _setupRole(ADMIN, initialAdmin);\\n _setRoleAdmin(ADMIN, ADMIN);\\n\\n __AccessControl_init();\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTierIndex(uint256 tokenId)\\n public\\n view\\n returns (uint8 index_)\\n {\\n //32 * 8 = 256 - each uint256 holds the data of 32 tokens . 8 bits each.\\n\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 compressedRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n //use 31 instead of 32 to account for the '0x' in the start.\\n //the '31 -' reverses our bytes order which is necessary\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint8 tierIndex = uint8((compressedRegister >> offset));\\n\\n return tierIndex;\\n }\\n\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory)\\n {\\n return hashes[tierIndex];\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTier(uint256 index, Tier memory newTier)\\n external\\n onlyAdmin\\n returns (bool)\\n {\\n baseLoanSizes[index] = newTier.baseLoanSize;\\n hashes[index] = newTier.hashes;\\n contributionAssets[index] = newTier.contributionAsset;\\n contributionSizes[index] = newTier.contributionSize;\\n contributionMultipliers[index] = newTier.contributionMultiplier;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param tiersMapping Information about the new tiers to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setAllTokenTierMappings(uint256[] memory tiersMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n require(\\n !_tokenTierMappingCompressedSet,\\n \\\"TellerNFTDictionary: token tier mapping already set\\\"\\n );\\n for (uint256 i = 0; i < tiersMapping.length; i++) {\\n _tokenTierMappingCompressed[i] = tiersMapping[i];\\n }\\n\\n _tokenTierMappingCompressedSet = true;\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param index the mapping row, each holds data for 32 tokens\\n * @param tierMapping Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierMapping(uint256 index, uint256 tierMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n _tokenTierMappingCompressed[index] = tierMapping;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenIds the NFT token Ids for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenIds(\\n uint256[] calldata tokenIds,\\n uint256 tokenTier\\n ) public onlyAdmin returns (bool) {\\n for (uint256 i; i < tokenIds.length; i++) {\\n setTokenTierForTokenId(tokenIds[i], tokenTier);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenId the NFT token Id for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenId(uint256 tokenId, uint256 tokenTier)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 existingRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint256 updateMaskShifted =\\n 0x00000000000000000000000000000000000000000000000000000000000000FF <<\\n offset;\\n\\n uint256 updateMaskShiftedNegated = ~updateMaskShifted;\\n\\n uint256 tokenTierShifted =\\n ((0x0000000000000000000000000000000000000000000000000000000000000000 |\\n tokenTier) << offset);\\n\\n uint256 existingRegisterClearedWithMask =\\n existingRegister & updateMaskShiftedNegated;\\n\\n uint256 updatedRegister =\\n existingRegisterClearedWithMask | tokenTierShifted;\\n\\n _tokenTierMappingCompressed[mappingIndex] = updatedRegister;\\n\\n return true;\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(IStakeableNFT).interfaceId ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n New methods for the dictionary\\n */\\n\\n /**\\n * @notice It returns Base Loan Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenBaseLoanSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return baseLoanSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Token URI Hash for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenURIHash(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n string[] memory tierImageHashes = hashes[tokenTier];\\n return tierImageHashes[tokenId % (tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice It returns Contribution Asset for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionAsset(uint256 tokenId)\\n public\\n view\\n override\\n returns (address)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionAssets[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Multiplier for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionMultiplier(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint8)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionMultipliers[tokenTier];\\n }\\n}\\n\",\"keccak256\":\"0xf33e3fa1f609fdd2abb3b5fb9c232269d13363a3e4fa5697ea96269e361e74fa\"},\"contracts/nft/libraries/NFTLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../TellerNFT.sol\\\";\\n\\n// Libraries\\nimport {\\n MerkleProof\\n} from \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\nimport { NFTStorageLib, NFTStorage } from \\\"../../storage/nft.sol\\\";\\n\\nlibrary NFTLib {\\n function s() internal pure returns (NFTStorage storage s_) {\\n s_ = NFTStorageLib.store();\\n }\\n\\n function nft() internal view returns (TellerNFT nft_) {\\n nft_ = AppStorageLib.store().nft;\\n }\\n\\n /**s\\n * @notice it transfers the NFT from the sender to the diamond to stake then adds the NFTID to the list of the owner's stakedNFTs\\n * @param nftID the ID of the NFT to stake\\n * @param owner the owner of the NFT who will stake the NFT\\n */\\n function stake(uint256 nftID, address owner) internal {\\n // Transfer to diamond\\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\\n // Add NFT ID to user set\\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\\n }\\n\\n /**\\n * @notice it unstakes the NFT by removing the NFT ID from the list of the user's staked NFTs\\n * @param nftID the ID of the NFT to remove from the list of the user's staked NFTs\\n * @return success_ the boolean value telling us if the user has unsuccessfully unstaked the NFT\\n */\\n function unstake(uint256 nftID) internal returns (bool success_) {\\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\\n }\\n\\n /**\\n * @notice it gets the list of staked NFTs from the owner\\n * @param nftOwner the owner of the staked NFTs to pull from\\n * @return staked_ the array of the staked NFTs owned by the user\\n */\\n function stakedNFTs(address nftOwner)\\n internal\\n view\\n returns (uint256[] memory staked_)\\n {\\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\\n staked_ = new uint256[](EnumerableSet.length(nfts));\\n for (uint256 i; i < staked_.length; i++) {\\n staked_[i] = EnumerableSet.at(nfts, i);\\n }\\n }\\n\\n /**\\n * @notice if the user fails to pay his loan, then we liquidate the all the NFTs associated with the loan\\n * @param loanID the identifier of the loan to liquidate the NFTs from\\n */\\n function liquidateNFT(uint256 loanID) internal {\\n // Check if NFTs are linked\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n NFTLib.nft().transferFrom(\\n address(this),\\n AppStorageLib.store().nftLiquidationController,\\n EnumerableSet.at(nfts, i)\\n );\\n }\\n }\\n\\n /**\\n * @notice it unstakes an NFT and verifies the proof in order to apply the proof to a loan\\n * @param loanID the identifier of the loan\\n * @param nftID the NFT ID to apply to the loan\\n */\\n function applyToLoan(uint256 loanID, uint256 nftID) internal {\\n // NFT must be currently staked\\n // Remove NFT from being staked - returns bool\\n require(unstake(nftID), \\\"Teller: borrower nft not staked\\\");\\n\\n // Apply NFT to loan\\n EnumerableSet.add(s().loanNFTs[loanID], nftID);\\n }\\n\\n /**\\n * @notice it finds the loan's NFTs and adds them back to the owner's list of staked NFTs\\n * @param loanID the identifier of the respective loan to add the NFTs back to the user's staked NFTs\\n * @param owner the owner to add the unstaked NFTs back to the staked pile\\n */\\n function restakeLinked(uint256 loanID, address owner) internal {\\n // Get linked NFT\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n // Restake the NFT\\n EnumerableSet.add(s().stakedNFTs[owner], EnumerableSet.at(nfts, i));\\n }\\n }\\n}\\n\",\"keccak256\":\"0xccbd35c6e8d0130b38f5025ee81c47d55e4fa48c8fcb8bec6f70c21061e0ce61\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n /**\\n * @notice it returns 10^{numberOfDecimals} for a token\\n * @param token the address to calculate the decimals for\\n * @return 10^number of decimals used to calculate the price and value of different token pairs\\n */\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @notice It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @notice it tries to calculate a price from Compound and Chainlink.\\n * @dev if no price is found on compound, then calculate it on chainlink\\n * @param src the token address to calculate the price for in dst\\n * @param dst the token address to retrieve the price of src\\n * @return price_ the price of src in dst\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n * @param src the address of the src token\\n * @param dst the address of the dst token\\n * @return the price of the src token in dst token\\n\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n * @param src the source token to calculate price for with chainlink\\n * @param dst the destination token to calculate price for with chainlink\\n * @param cRate the compound rate to multiply with the price of the dst token\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @notice Scales the {value} by the difference in decimal values.\\n * @param value the the value of the src in dst\\n * @param srcDecimals src token decimals\\n * @param dstDecimals dst token decimals\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @notice it tries to calculate the price of {src} in {dst}\\n * @param src address of source token\\n * @param dst address of destination token\\n * @return the price of src token in dst\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address WETH = AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n if (dst != WETH) {\\n int256 price1 = _priceFor(src, WETH);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, WETH);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice it checks if a token is a cToken. If it is, then get the underlying address\\n * @param token address of the token\\n * @return isCToken boolean whether it's a cToken\\n * @return underlying the address of the cToken\\n */\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2efb3d71a1c0fb49f8c455c4fa30d04c69a1617d619035fc400dabdeb2ab0c9e\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { PriceAggFacet } from \\\"./PriceAggFacet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\n/**\\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\\n */\\nlibrary PriceAggLib {\\n /**\\n * @notice It calculates the value of one token amount into another\\n * @param src the source token\\n * @param dst the destination token\\n * @param srcAmount the amount of source token\\n * @return value_ the returned value of src in dst\\n */\\n function valueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) internal view returns (uint256 value_) {\\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\\n }\\n\\n /**\\n * @notice It returns the price of the token pair as given from Compound.\\n * @dev if no compound price is calculated, then it checks Chainlink price Aggregator\\n * @param src the address of the source token\\n * @param dst the address of the desitnation token\\n * @return price_ gets the price of src in dst\\n */\\n function priceFor(address src, address dst)\\n internal\\n view\\n returns (int256 price_)\\n {\\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\\n }\\n}\\n\",\"keccak256\":\"0xff59eee567fa4a7f5cac432e31d918be92834f04614f49572d3984a5b030ac79\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\nabstract contract PausableMods {\\n /**\\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\\n * @param id id of the facet to check if is paused.\\n * @param state Boolean that the protocol AND facet should be in.\\n */\\n modifier paused(bytes32 id, bool state) {\\n require(\\n __isPaused(\\\"\\\") == state && __isPaused(id) == state,\\n __pausedMessage(state)\\n );\\n _;\\n }\\n\\n /**\\n * @dev Checks if the given id is paused.\\n * @param id Encoded id of the facet to check if is paused.\\n * @return the bool to tell us if the facet is paused (true) or not (false)\\n */\\n function __isPaused(bytes32 id) private view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n\\n /**\\n * @dev Gets the message that should be reverted with given a state it should be in.\\n * @param state Boolean that an id should be in.\\n * @return a message stating whether the facet is paused or not\\n */\\n function __pausedMessage(bool state) private pure returns (string memory) {\\n return state ? \\\"Pausable: not paused\\\" : \\\"Pausable: paused\\\";\\n }\\n}\\n\",\"keccak256\":\"0x2d3f848ee56ae5fa365539c2509c03c167affc89c89f98bb98cb9b83fbe8ae4c\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"NFTInterestRate\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getNFTInterestRate() internal view returns (uint16 value_) {\\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0x44294be1af9f913b2ed391a40cd4b646537a4b463b8d5ff1fac8ead3988966c1\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for loans taken out with an NFT.\\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\\n */\\nbytes32 constant NFT_INTEREST_RATE = keccak256(\\\"NFTInterestRate\\\");\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xd68a7df42b2bbba6f935d5890b7b37997c1432e25ae113827b8bde87f94fd86f\",\"license\":\"MIT\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n /**\\n * @notice Checks if the account should be allowed to mint tokens in the given market\\n * @param cToken The market to verify the mint against\\n * @param minter The account which would get the minted tokens\\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates mint and reverts on rejection. May emit logs.\\n * @param cToken Asset being minted\\n * @param minter The address minting the tokens\\n * @param mintAmount The amount of the underlying asset being minted\\n * @param mintTokens The number of tokens being minted\\n */\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to redeem tokens in the given market\\n * @param cToken The market to verify the redeem against\\n * @param redeemer The account which would redeem the tokens\\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates redeem and reverts on rejection. May emit logs.\\n * @param cToken Asset being redeemed\\n * @param redeemer The address redeeming the tokens\\n * @param redeemAmount The amount of the underlying asset being redeemed\\n * @param redeemTokens The number of tokens being redeemed\\n */\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\\n * @param cToken The market to verify the borrow against\\n * @param borrower The account which would borrow the asset\\n * @param borrowAmount The amount of underlying the account would borrow\\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates borrow and reverts on rejection. May emit logs.\\n * @param cToken Asset whose underlying is being borrowed\\n * @param borrower The address borrowing the underlying\\n * @param borrowAmount The amount of the underlying asset requested to borrow\\n */\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to repay a borrow in the given market\\n * @param cToken The market to verify the repay against\\n * @param payer The account which would repay the asset\\n * @param borrower The account which would borrowed the asset\\n * @param repayAmount The amount of the underlying asset the account would repay\\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\\n * @param cToken Asset being repaid\\n * @param payer The address repaying the borrow\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param borrowerIndex the index of the borrower\\n */\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n /**\\n * @notice Checks if the liquidation should be allowed to occur\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n */\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the seizing of assets should be allowed to occur\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates seize and reverts on rejection. May emit logs.\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to transfer tokens in the given market\\n * @param cToken The market to verify the transfer against\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates transfer and reverts on rejection. May emit logs.\\n * @param cToken Asset being transferred\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n */\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in all markets\\n * @param holder The address to claim COMP for\\n */\\n function claimComp(address holder) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in the specified markets\\n * @param holder The address to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n */\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n /**\\n * @notice Claim all comp accrued by the holders\\n * @param holders The addresses to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n * @param borrowers Whether or not to claim COMP earned by borrowing\\n * @param suppliers Whether or not to claim COMP earned by supplying\\n */\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n /**\\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\\n * @param cTokenBorrowed The address of the borrowed cToken\\n * @param cTokenCollateral The address of the collateral cToken\\n * @param repayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\\n */\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n /**\\n * @notice Return the address of the COMP token\\n * @return The address of COMP\\n */\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x38a824a4a21ce9370fa581a616d1bb9d311f27d8982a6b96ebeba90bd5fd0adb\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n \\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x37849041e4bee2dfa825677f69078521fcc94804aa5120f67dd12cc4133efcec\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @dev CETH is the only Compound token that does not support the {underlying} function.\\n * @param cToken address of the compound token\\n * @return address of the underlying cToken\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x99206384c27b0e68b1ec7b82260f6a47965f611875c018bc076ff8a688a6c6d7\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n /**\\n * @notice it returns the absolute number of a specified parameter\\n * @param self the number to be returned in it's absolute \\n * @return the absolute number\\n */\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0xa852b8866a3d6d928c6575bf2bcf2ae784eed73717c78c0cadbdedf8b0ba3274\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0c52fdd76b33f74e233c3a27dd3b73b134e9643aab347b3aa649c504809c6559\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\n// DEPRECATED\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\nstruct LoanRequest {\\n LoanUserRequest request;\\n LoanConsensusResponse[] responses;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanUserRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanConsensusResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) _loanTerms; // DEPRECATED: DO NOT REMOVE\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb7e05aeec806b5621512def93f4a389b4ef88c50ef9fe7115a33f57db2f2304b\",\"license\":\"MIT\"},\"contracts/storage/nft.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"../nft/TellerNFTDictionary.sol\\\";\\n\\n// Utils\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct NFTStorage {\\n // Maps NFT owner to set of token IDs owned\\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\\n // Maps loanID to NFT IDs indicating NFT being used for the loan\\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\\n // Merkle root used for verifying nft IDs to base loan size\\n TellerNFTDictionary nftDictionary;\\n}\\n\\nbytes32 constant NFT_STORAGE_POS = keccak256(\\\"teller.staking.storage\\\");\\n\\nlibrary NFTStorageLib {\\n function store() internal pure returns (NFTStorage storage s) {\\n bytes32 pos = NFT_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd44f213be3125ea2e2de120c241832f1861be18b3ff2fd4c3baa52ea20b94812\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", "history": [ { "address": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", @@ -970,6 +970,1075 @@ "storage": [], "types": null } + }, + { + "address": "0x2057f8DD4bcC637edBF716fdaF7DCCC86E588082", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "RepayFacet", + "transactionHash": "0xbc046955004f24a9f4ea605bb77c6020b23c6b2b54e5ba826957510e2f0b5f21", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x2057f8DD4bcC637edBF716fdaF7DCCC86E588082", + "transactionIndex": 57, + "gasUsed": "1914533", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xe9e833314768cf1d9f7397bda5876b51054e45f3658bce460ceb4a797eb109cd", + "transactionHash": "0xbc046955004f24a9f4ea605bb77c6020b23c6b2b54e5ba826957510e2f0b5f21", + "logs": [], + "blockNumber": 12647879, + "cumulativeGasUsed": "6543028", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "1389136e56e3a43cff4f2990a46ef548", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"liquidator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"reward\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokensIn\",\"type\":\"uint256\"}],\"name\":\"LoanLiquidated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountPaid\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"totalOwed\",\"type\":\"uint256\"}],\"name\":\"LoanRepaid\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"}],\"name\":\"TokensClaimed\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"claimTokens\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"escrowRepay\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLiquidationReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"inLending_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"inCollateral_\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"liquidateLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"repayLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"params\":{\"borrower\":\"Account address of the borrower\",\"liquidator\":\"Account address of the liquidator\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"reward\":\"Value in lending token paid out to liquidator\",\"tokensIn\":\"Percentage of the collateral price paid by the liquidator to the lending pool\"}},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"params\":{\"amountPaid\":\"Amount of the loan paid back\",\"borrower\":\"Account address of the borrower\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"payer\":\"Account address of the payer\",\"totalOwed\":\"Total amount of the loan to be repaid\"}}},\"kind\":\"dev\",\"methods\":{\"claimTokens(uint256)\":{\"params\":{\"loanID\":\"The id of the loan being used.\"}},\"escrowRepay(uint256,uint256)\":{\"details\":\"If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\",\"params\":{\"amount\":\"The amount being repaid.\",\"loanID\":\"The id of the loan being used.\"}},\"getLiquidationReward(uint256)\":{\"params\":{\"loanID\":\"The loan ID to get the info.\"},\"returns\":{\"inCollateral_\":\"The value the liquidator will receive denoted in collateral tokens.\",\"inLending_\":\"The value the liquidator will receive denoted in lending tokens.\"}},\"liquidateLoan(uint256)\":{\"params\":{\"loanID\":\"The ID of the loan to be liquidated\"}},\"repayLoan(uint256,uint256)\":{\"params\":{\"amount\":\"The amount of tokens to pay back to the loan\",\"loanID\":\"The ID of the loan the payment is for\"}}},\"version\":1},\"userdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully liquidated\"},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully repaid\"},\"TokensClaimed(address)\":{\"notice\":\"Notifies when the Escrow's tokens have been claimed.\"}},\"kind\":\"user\",\"methods\":{\"claimTokens(uint256)\":{\"notice\":\"Sends the tokens owned by this escrow to the owner.\"},\"escrowRepay(uint256,uint256)\":{\"notice\":\"Repay this Escrow's loan.\"},\"getLiquidationReward(uint256)\":{\"notice\":\"It gets the current liquidation reward for a given loan.\"},\"liquidateLoan(uint256)\":{\"notice\":\"Liquidate a loan if it is expired or under collateralized\"},\"repayLoan(uint256,uint256)\":{\"notice\":\"Make a payment to a loan\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/market/RepayFacet.sol\":\"RepayFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Trees proofs.\\n *\\n * The proofs can be generated using the JavaScript library\\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\\n *\\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n bytes32 computedHash = leaf;\\n\\n for (uint256 i = 0; i < proof.length; i++) {\\n bytes32 proofElement = proof[i];\\n\\n if (computedHash <= proofElement) {\\n // Hash(current computed hash + current element of the proof)\\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\\n } else {\\n // Hash(current element of the proof + current computed hash)\\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\\n }\\n }\\n\\n // Check if the computed hash (root) is equal to the provided root\\n return computedHash == root;\\n }\\n}\\n\",\"keccak256\":\"0xeee34bfb413657b6cd6c8e1e15c2080ba5ebaac479578515922804346fb63f7c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/reentry/ReentryMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nabstract contract ReentryMods {\\n modifier nonReentry(bytes32 id) {\\n AccessControlStorage storage s = AccessControlStorageLib.store();\\n require(!s.entered[id], \\\"AccessControl: reentered\\\");\\n s.entered[id] = true;\\n _;\\n s.entered[id] = false;\\n }\\n}\\n\",\"keccak256\":\"0x033c1164af25ef7d35a38a60973bf379b1cc603596914ffd85dcbcf0acdb6970\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/EscrowClaimTokens.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\n\\n// Interfaces\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, LoanStatus } from \\\"../storage/market.sol\\\";\\n\\n// Libraries\\nimport { LibLoans } from \\\"../market/libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"./libraries/LibEscrow.sol\\\";\\n\\n/**\\n * @notice Contains functionality to claim tokens that are in an escrow contract for a loan.\\n */\\ncontract EscrowClaimTokens is PausableMods {\\n /**\\n * @notice Notifies when the Escrow's tokens have been claimed.\\n * @param recipient address where the tokens where sent to.\\n */\\n event TokensClaimed(address recipient);\\n\\n /**\\n * @notice Sends the tokens owned by this escrow to the owner.\\n * @param loanID The id of the loan being used.\\n */\\n function claimTokens(uint256 loanID) external paused(\\\"\\\", false) {\\n require(\\n LibLoans.loan(loanID).borrower == msg.sender,\\n \\\"Teller: claim not borrower\\\"\\n );\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Closed,\\n \\\"Teller: loan not closed\\\"\\n );\\n\\n __claimEscrowTokens(loanID);\\n }\\n\\n function __claimEscrowTokens(uint256 loanID) internal {\\n __claimToken(loanID, LibLoans.loan(loanID).lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n __claimToken(loanID, EnumerableSet.at(tokens, i));\\n }\\n\\n emit TokensClaimed(msg.sender);\\n }\\n\\n function __claimToken(uint256 loanID, address token) private {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n if (balance > 0) {\\n LibEscrow.e(loanID).claimToken(\\n token,\\n LibLoans.loan(loanID).borrower,\\n balance\\n );\\n }\\n }\\n}\\n\",\"keccak256\":\"0xae189ea2a13c10f013f255f98ec50f34466c375bd7503275587d6abe5d25696c\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../interfaces/IAToken.sol\\\";\\nimport { IAaveLendingPool } from \\\"../interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x8030b206c87d0073fb7dbebfa2ee8a3e93c479d976d6cdaa0c939f2fedaa1525\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n /**\\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\\n * @param dappAddress address of the target contract address\\n * @param dappData encoded abi of the function in our contract we want to call\\n * @return the called data in bytes\\n */\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n /**\\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\\n * @param token address of the respective ERC20 token to approve for the spender\\n * @param spender address of the respective spender who is approved by the token contract\\n */\\n function setTokenAllowance(address token, address spender) external;\\n\\n /**\\n * @notice it allows user to claim their escrow tokens\\n * @dev only the owner (TellerDiamond) can make this call on behalf of the users\\n * @param token address of the respective token contract to claim tokens from\\n * @param to address where the tokens should be transferred to\\n * @param amount uint256 amount of tokens to be claimed\\n */\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xaf67fc4454ffaa4d2f7e46fe7101876e8ebdb1a5426c30f87b8e18cc573ac019\",\"license\":\"MIT\"},\"contracts/escrow/libraries/LibEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibDapps } from \\\"../dapps/libraries/LibDapps.sol\\\";\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibEscrow {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\\n e_ = s().loanEscrows[loanID];\\n }\\n\\n /**\\n * @notice It returns a list of tokens owned by a loan escrow\\n * @param loanID uint256 index used to return our token list\\n * @return t_ which is a list of tokens \\n */\\n function getEscrowTokens(uint256 loanID)\\n internal\\n view\\n returns (EnumerableSet.AddressSet storage t_)\\n {\\n t_ = s().escrowTokens[loanID];\\n }\\n\\n /**\\n * @notice It returns the balance of a respective token in a loan escrow\\n * @param loanID uint256 index used to point to our loan escrow\\n * @param token address of respective token to give us the balance of in our loan escrow\\n * @return uint256 balance of respective token returned in an escrow loan\\n */\\n function balanceOf(uint256 loanID, address token)\\n internal\\n view\\n returns (uint256)\\n {\\n return IERC20(token).balanceOf(address(e(loanID)));\\n }\\n\\n /**\\n * @notice Adds or removes tokens held by the Escrow contract\\n * @param loanID The loan ID to update the token list for\\n * @param tokenAddress The token address to be added or removed\\n */\\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\\n // Skip if is lending token\\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\\n\\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\\n if (balanceOf(loanID, tokenAddress) > 0) {\\n if (!contains) {\\n EnumerableSet.add(tokens, tokenAddress);\\n }\\n } else if (contains) {\\n EnumerableSet.remove(tokens, tokenAddress);\\n }\\n }\\n\\n /**\\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\\n * @param loanID The loan ID to calculate value for\\n * @return value_ Escrow total value denoted in the lending token.\\n */\\n function calculateTotalValue(uint256 loanID)\\n internal\\n view\\n returns (uint256 value_)\\n {\\n address lendingToken = LibLoans.loan(loanID).lendingToken;\\n value_ += balanceOf(loanID, lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\\n if (EnumerableSet.length(tokens) > 0) {\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n uint256 tokenBal =\\n balanceOf(loanID, EnumerableSet.at(tokens, i));\\n value_ += PriceAggLib.valueFor(\\n EnumerableSet.at(tokens, i),\\n lendingToken,\\n tokenBal\\n );\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x17a7c6b11d6f280948e320525d1e131b89c23f80216918aa070df437a851d915\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when a user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when a user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n * @return ERC20 token\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n * @return balance_ the balance of the account\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice It calculates the total supply of the underlying asset.\\n * @return totalSupply_ the total supply denoted in the underlying asset.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given market.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n \\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfill the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n * @return mintAmount_ the amount minted of the specified token\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n * @return address of the strategy contract\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n * @param state boolean value that resembles the platform's state\\n */\\n function restrict(bool state) external virtual;\\n\\n /**\\n * @notice it initializes the Teller Token\\n * @param admin address of the admin to the respective Teller Token\\n * @param underlying address of the ERC20 token\\n */\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xf30ac4ef491851477ff9a3dd04974ebe74b529c37a3ef4e05798c3f734ceeb3d\",\"license\":\"MIT\"},\"contracts/market/LoanDataFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { Loan, LoanDebt, LoanTerms } from \\\"../storage/market.sol\\\";\\n\\ncontract LoanDataFacet {\\n /**\\n * @notice Returns the information about the given {loanID}.\\n * @param loanID The loan ID to get information for.\\n * @return loan_ The loan data.\\n */\\n function getLoan(uint256 loanID) external view returns (Loan memory loan_) {\\n loan_ = LibLoans.s().loans[loanID];\\n }\\n\\n /**\\n * @notice DEPRECATED\\n * @notice Returns the terms for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanTerms The terms that the loan weer created with.\\n */\\n function getLoanTerms(uint256 loanID)\\n external\\n view\\n returns (LoanTerms memory)\\n {\\n return LibLoans.terms(loanID);\\n }\\n\\n /**\\n * @notice Returns the loan IDs created by the {borrower} account.\\n * @param borrower The account to get loan IDs for.\\n * @return loanIDs The IDs for loans created by the {borrower}\\n */\\n function getBorrowerLoans(address borrower)\\n external\\n view\\n returns (uint128[] memory loanIDs)\\n {\\n return LibLoans.s().borrowerLoans[borrower];\\n }\\n\\n /**\\n * @notice Returns the debt owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanDebt The principal and interest owed amount.\\n */\\n function getDebtOwed(uint256 loanID)\\n external\\n view\\n returns (LoanDebt memory)\\n {\\n return LibLoans.debt(loanID);\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) external view returns (uint256) {\\n return LibLoans.getTotalOwed(loanID);\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n external\\n view\\n returns (uint256)\\n {\\n return LibLoans.getInterestOwedFor(loanID, amountBorrow);\\n }\\n\\n /**\\n * @notice it returns the collateral needed for a loan\\n * @param loanID the identifier of the loan ID to retrieve collateral from\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n external\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n return LibLoans.getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the typed address of a loan escrow\\n * @param loanID the identifier of the respective escrow's loan\\n * @return escrow_ the typed address of the returned ILoanEscrow\\n */\\n function getLoanEscrow(uint256 loanID)\\n external\\n view\\n returns (address escrow_)\\n {\\n escrow_ = address(LibLoans.s().loanEscrows[loanID]);\\n }\\n\\n /**\\n * @notice it returns the escrow's total value by calculating the value all the escrow tokens\\n * @param loanID the identifier of the respective escrow's loan\\n * @return the total value of the loan escrow\\n */\\n function getLoanEscrowValue(uint256 loanID)\\n external\\n view\\n returns (uint256)\\n {\\n return LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n /**\\n * @notice it returns the total escrow tokens held by an escrow\\n * @param loanID the identifier of the respective escrow's loan\\n * @return tokens_ the tokens held at the escrow loan \\n */\\n function getEscrowTokens(uint256 loanID)\\n external\\n view\\n returns (address[] memory tokens_)\\n {\\n EnumerableSet.AddressSet storage escrowTokens =\\n LibEscrow.getEscrowTokens(loanID);\\n tokens_ = new address[](EnumerableSet.length(escrowTokens));\\n for (uint256 i; i < tokens_.length; i++) {\\n tokens_[i] = EnumerableSet.at(escrowTokens, i);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x9a57f5de00ce073af4ffb2f74e7d8a15e56bc017826f2c5a393ef5b64554145f\",\"license\":\"MIT\"},\"contracts/market/RepayFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\nimport {\\n ReentryMods\\n} from \\\"../contexts2/access-control/reentry/ReentryMods.sol\\\";\\nimport { AUTHORIZED } from \\\"../shared/roles.sol\\\";\\nimport { LoanDataFacet } from \\\"./LoanDataFacet.sol\\\";\\nimport { EscrowClaimTokens } from \\\"../escrow/EscrowClaimTokens.sol\\\";\\n\\n// Libraries\\nimport {\\n IERC20,\\n SafeERC20\\n} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibCollateral } from \\\"./libraries/LibCollateral.sol\\\";\\nimport { LibDapps } from \\\"../escrow/dapps/libraries/LibDapps.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { NumbersLib } from \\\"../shared/libraries/NumbersLib.sol\\\";\\nimport { PriceAggLib } from \\\"../price-aggregator/PriceAggLib.sol\\\";\\nimport { NFTLib } from \\\"../nft/libraries/NFTLib.sol\\\";\\n\\n// Interfaces\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus\\n} from \\\"../storage/market.sol\\\";\\n\\ncontract RepayFacet is RolesMods, ReentryMods, PausableMods, EscrowClaimTokens {\\n /**\\n @notice This event is emitted when a loan has been successfully repaid\\n @param loanID ID of loan from which collateral was withdrawn\\n @param borrower Account address of the borrower\\n @param amountPaid Amount of the loan paid back\\n @param payer Account address of the payer\\n @param totalOwed Total amount of the loan to be repaid\\n */\\n event LoanRepaid(\\n uint256 indexed loanID,\\n address indexed borrower,\\n uint256 amountPaid,\\n address payer,\\n uint256 totalOwed\\n );\\n\\n /**\\n * @notice This event is emitted when a loan has been successfully liquidated\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param borrower Account address of the borrower\\n * @param liquidator Account address of the liquidator\\n * @param reward Value in lending token paid out to liquidator\\n * @param tokensIn Percentage of the collateral price paid by the liquidator to the lending pool\\n */\\n event LoanLiquidated(\\n uint256 indexed loanID,\\n address indexed borrower,\\n address liquidator,\\n uint256 reward,\\n uint256 tokensIn\\n );\\n\\n /**\\n * @notice Repay this Escrow's loan.\\n * @dev If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.\\n * @dev Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\\n * @param loanID The id of the loan being used.\\n * @param amount The amount being repaid.\\n */\\n function escrowRepay(uint256 loanID, uint256 amount)\\n external\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n nonReentry(\\\"\\\")\\n {\\n uint256 balance =\\n LibEscrow.balanceOf(loanID, LibLoans.loan(loanID).lendingToken);\\n uint256 totalOwed = LibLoans.getTotalOwed(loanID);\\n // if there isn't enough balance in the escrow, then transfer amount needed to the escrow\\n if (balance < totalOwed && amount > balance) {\\n uint256 amountNeeded =\\n amount > totalOwed ? totalOwed - (balance) : amount - (balance);\\n\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n msg.sender,\\n address(LibEscrow.e(loanID)),\\n amountNeeded\\n );\\n }\\n\\n __repayLoan(loanID, amount, address(LibEscrow.e(loanID)), false);\\n }\\n\\n /**\\n * @notice Make a payment to a loan\\n * @param loanID The ID of the loan the payment is for\\n * @param amount The amount of tokens to pay back to the loan\\n */\\n function repayLoan(uint256 loanID, uint256 amount)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n __repayLoan(loanID, amount, msg.sender, false);\\n }\\n\\n /**\\n * @notice it repays the loan, either from an escrow or from a regular address\\n * @param loanID the identifier of the loan to repay\\n * @param amount the amount to repay the loan\\n * @param sender the address of the sender that wants to pay, can also be a loan escrow\\n * @param isLiquidation is this loan being liquidated?\\n * @return leftToPay_ the amount left to pay for the loan\\n */\\n function __repayLoan(\\n uint256 loanID,\\n uint256 amount,\\n address sender,\\n bool isLiquidation\\n ) private returns (uint256 leftToPay_) {\\n require(amount > 0, \\\"Teller: zero repay\\\");\\n\\n // calculate the actual amount to repay\\n leftToPay_ =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n if (leftToPay_ < amount) {\\n amount = leftToPay_;\\n leftToPay_ = 0;\\n } else {\\n leftToPay_ -= amount;\\n }\\n\\n // Get the Teller token for the loan\\n ITToken tToken =\\n MarketStorageLib.store().tTokens[\\n LibLoans.loan(loanID).lendingToken\\n ];\\n // Transfer funds from an escrow if an escrow is calling it\\n // Otherwise, transfer funds from an account\\n if (address(LibEscrow.e(loanID)) == sender) {\\n LibEscrow.e(loanID).claimToken(\\n LibLoans.loan(loanID).lendingToken,\\n address(tToken),\\n amount\\n );\\n } else {\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n sender,\\n address(tToken),\\n amount\\n );\\n }\\n\\n // Deduct the interest and principal owed\\n uint256 principalPaid;\\n uint256 interestPaid;\\n if (amount < LibLoans.debt(loanID).interestOwed) {\\n interestPaid = amount;\\n LibLoans.debt(loanID).interestOwed -= amount;\\n } else {\\n if (LibLoans.debt(loanID).interestOwed > 0) {\\n interestPaid = LibLoans.debt(loanID).interestOwed;\\n amount -= interestPaid;\\n LibLoans.debt(loanID).interestOwed = 0;\\n }\\n\\n if (amount > 0) {\\n principalPaid = amount;\\n LibLoans.debt(loanID).principalOwed -= amount;\\n }\\n }\\n\\n // Tell the Teller Token value has been deposited back into the pool.\\n tToken.repayLoan(principalPaid, interestPaid);\\n\\n if (isLiquidation) {\\n // Make sure there is nothing left to repay on the loan\\n require(leftToPay_ == 0, \\\"Teller: liquidate partial repay\\\");\\n\\n // Set loan status\\n LibLoans.loan(loanID).status = LoanStatus.Liquidated;\\n\\n // Transfer NFT if linked\\n NFTLib.liquidateNFT(loanID);\\n } else {\\n // if the loan is now fully paid, close it and withdraw borrower collateral\\n if (leftToPay_ == 0) {\\n LibLoans.loan(loanID).status = LoanStatus.Closed;\\n\\n // Check if the loan has a collateral token\\n if (LibLoans.loan(loanID).collateralToken != address(0)) {\\n LibCollateral.withdrawAll(\\n loanID,\\n LibLoans.loan(loanID).borrower\\n );\\n }\\n\\n // Claim tokens in the escrow for the loan if any\\n __claimEscrowTokens(loanID);\\n\\n // Restake any NFTs linked to loan for borrower\\n NFTLib.restakeLinked(loanID, LibLoans.loan(loanID).borrower);\\n }\\n\\n emit LoanRepaid(\\n loanID,\\n LibLoans.loan(loanID).borrower,\\n amount,\\n msg.sender,\\n leftToPay_\\n );\\n }\\n }\\n\\n /**\\n * @notice Liquidate a loan if it is expired or under collateralized\\n * @param loanID The ID of the loan to be liquidated\\n */\\n function liquidateLoan(uint256 loanID)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n uint256 collateralAmount = LibCollateral.e(loanID).loanSupply(loanID);\\n require(\\n RepayLib.isLiquidable(loanID, collateralAmount),\\n \\\"Teller: does not need liquidation\\\"\\n );\\n\\n // Calculate the reward before repaying the loan\\n (uint256 rewardInLending, uint256 collateralInLending) =\\n RepayLib.getLiquidationReward(loanID, collateralAmount);\\n\\n // The liquidator pays the amount still owed on the loan\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n __repayLoan(loanID, amountToLiquidate, msg.sender, true);\\n\\n // Payout the liquidator reward owed\\n if (rewardInLending > 0) {\\n RepayLib.payOutLiquidator(\\n loanID,\\n rewardInLending,\\n collateralInLending,\\n collateralAmount,\\n payable(msg.sender)\\n );\\n }\\n\\n emit LoanLiquidated(\\n loanID,\\n loan.borrower,\\n msg.sender,\\n rewardInLending,\\n amountToLiquidate\\n );\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @return inLending_ The value the liquidator will receive denoted in lending tokens.\\n * @return inCollateral_ The value the liquidator will receive denoted in collateral tokens.\\n */\\n function getLiquidationReward(uint256 loanID)\\n external\\n view\\n returns (uint256 inLending_, uint256 inCollateral_)\\n {\\n (inLending_, ) = RepayLib.getLiquidationReward(\\n loanID,\\n LibCollateral.e(loanID).loanSupply(loanID)\\n );\\n inCollateral_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n inLending_\\n );\\n }\\n}\\n\\nlibrary RepayLib {\\n /**\\n * @notice It checks if a loan can be liquidated.\\n * @param loanID The loan ID to check.\\n * @return true if the loan is liquidable.\\n */\\n function isLiquidable(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (bool)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n // Check if loan can be liquidated\\n if (loan.status != LoanStatus.Active) {\\n return false;\\n }\\n\\n if (loan.collateralRatio > 0) {\\n // If loan has a collateral ratio, check how much is needed\\n (, uint256 neededInCollateral, ) =\\n LoanDataFacet(address(this)).getCollateralNeededInfo(loanID);\\n if (neededInCollateral > collateralAmount) {\\n return true;\\n }\\n }\\n\\n // Otherwise, check if the loan has expired\\n return block.timestamp >= loan.loanStartTime + loan.duration;\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @param collateralAmount The amount of collateral for the {loanID}. Passed in to save gas calling the collateral escrow multiple times.\\n * @return reward_ The value the liquidator will receive denoted in lending tokens.\\n */\\n function getLiquidationReward(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (uint256 reward_, uint256 collateralValue_)\\n {\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n // Max reward is amount repaid on loan plus extra percentage\\n uint256 maxReward =\\n amountToLiquidate +\\n NumbersLib.percent(\\n amountToLiquidate,\\n uint16(PlatformSettingsLib.getLiquidateRewardPercent())\\n );\\n\\n // Calculate available collateral for reward\\n if (collateralAmount > 0) {\\n collateralValue_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).collateralToken,\\n LibLoans.loan(loanID).lendingToken,\\n collateralAmount\\n );\\n reward_ += collateralValue_;\\n }\\n\\n // Calculate loan escrow value if collateral not enough to cover reward\\n if (reward_ < maxReward) {\\n reward_ += LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n // Cap the reward to max\\n if (reward_ > maxReward) {\\n reward_ = maxReward;\\n }\\n }\\n\\n /**\\n * @notice Checks if the loan has an Escrow and claims any tokens then pays out the loan collateral.\\n * @dev See Escrow.claimTokens for more info.\\n * @param loanID The loan ID which is being liquidated\\n * @param rewardInLending The total amount of reward based in the lending token to pay the liquidator\\n * @param collateralInLending The amount of collateral that is available for the loan denoted in lending tokens\\n * @param collateralAmount The amount of collateral that is available for the loan\\n * @param liquidator The address of the liquidator where the liquidation reward will be sent to\\n */\\n function payOutLiquidator(\\n uint256 loanID,\\n uint256 rewardInLending,\\n uint256 collateralInLending,\\n uint256 collateralAmount,\\n address payable liquidator\\n ) internal {\\n // check if loan is liquidated\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Liquidated,\\n \\\"Teller: loan not liquidated\\\"\\n );\\n\\n // if the lending reward is less than the collateral lending tokens, then aggregate\\n // the value for the lending token with the collateral token and send it to the liquidator\\n if (rewardInLending <= collateralInLending) {\\n uint256 rewardInCollateral =\\n PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n rewardInLending\\n );\\n\\n LibCollateral.withdraw(loanID, rewardInCollateral, liquidator);\\n } else {\\n // Payout whats available in the collateral token\\n LibCollateral.withdraw(loanID, collateralAmount, liquidator);\\n\\n // Claim remaining reward value from the loan escrow\\n claimEscrowTokensByValue(\\n loanID,\\n liquidator,\\n rewardInLending - collateralInLending\\n );\\n }\\n }\\n\\n /**\\n * @dev Send the equivalent of tokens owned by the loan escrow (in lending value) to the recipient,\\n * @param loanID The loan ID to clam tokens from\\n * @param recipient address to send the tokens to\\n * @param value The value of escrow held tokens to be claimed based in lending value\\n */\\n function claimEscrowTokensByValue(\\n uint256 loanID,\\n address recipient,\\n uint256 value\\n ) private {\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n uint256 valueLeftToTransfer = value;\\n\\n // Start with the lending token\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n LibLoans.loan(loanID).lendingToken,\\n recipient,\\n valueLeftToTransfer\\n );\\n\\n // Cycle through remaining tokens\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n if (valueLeftToTransfer == 0) {\\n return;\\n }\\n\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n EnumerableSet.at(tokens, i),\\n recipient,\\n valueLeftToTransfer\\n );\\n }\\n }\\n\\n /**\\n * @notice it claims the escrow tokens for the liquidator\\n * @notice it keeps claiming escrow tokens until there aren't anymore tokens or the valueLeftToTransfer is zero\\n * @param loanID the identifier of the escrow loan to claim tokens from\\n * @param token the address of the token asset to claim\\n * @param recipient the address of the recipient to transfer the tokens to\\n * @param valueLeftToTransfer the value left to transfer to the liquidator that is returned back\\n * @return the value left to transfer\\n */\\n function claimEscrowToken(\\n uint256 loanID,\\n address token,\\n address recipient,\\n uint256 valueLeftToTransfer\\n ) private returns (uint256) {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n // get value of token balance in lending value\\n if (balance > 0) {\\n // If token not the lending token, get value of token\\n uint256 balanceInLending;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n balanceInLending = balance;\\n } else {\\n balanceInLending = PriceAggLib.valueFor(\\n token,\\n LibLoans.loan(loanID).lendingToken,\\n balance\\n );\\n }\\n\\n if (balanceInLending <= valueLeftToTransfer) {\\n LibEscrow.e(loanID).claimToken(token, recipient, balance);\\n valueLeftToTransfer -= balanceInLending;\\n } else {\\n // Token balance is more than enough so calculate ratio of balance to transfer\\n uint256 valueToTransfer;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n valueToTransfer = valueLeftToTransfer;\\n } else {\\n valueToTransfer = NumbersLib.percent(\\n balance,\\n NumbersLib.ratioOf(\\n valueLeftToTransfer,\\n balanceInLending\\n )\\n );\\n }\\n\\n LibEscrow.e(loanID).claimToken(\\n token,\\n recipient,\\n valueToTransfer\\n );\\n valueLeftToTransfer = 0;\\n }\\n }\\n return valueLeftToTransfer;\\n }\\n}\\n\",\"keccak256\":\"0xc440b61519f74c4eba549f1f531726b1cd8b3da60ba7654cccd4eb9bd9fd7020\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n /**\\n * @notice it initializes an escrow\\n * @param tokenAddress the address of the collateral token to be stored\\n * @param isWETH check if it's wrapped Ethereum\\n */\\n function init(address tokenAddress, bool isWETH) external;\\n\\n /**\\n * @notice it deposits an amount of the respective collateral token into the escrow\\n * @param loanID the ID of the loan\\n * @param amount the amount of collateral tokens to be deposited\\n */\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n /**\\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\\n * @dev only the TellerDiamond can make this call on behalf of the borrower\\n * @param loanID identifier of the loan\\n * @param amount number of collateral tokens to send\\n * @param receiver payable address to transfer money to\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n /**\\n * @notice it returns the supply of the respective loan\\n * @param loanID the respective loan ID\\n * @return supply_ the amount in collateral of the respective loan\\n */\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n /**\\n * @notice it returns the total supply of the collateral token held by the contract\\n * @return supply_ the total amount of collateral\\n */\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x900fed2311f919ba1451a6583ddbf9f3bc8afa8f5189500fff51f0c049258ed3\",\"license\":\"MIT\"},\"contracts/market/libraries/LibCollateral.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport { ICollateralEscrow } from \\\"../collateral/ICollateralEscrow.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\nimport { MarketStorageLib } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibCollateral {\\n /**\\n * @notice This event is emitted when collateral has been deposited for the loan\\n * @param loanID ID of the loan for which collateral was deposited\\n * @param depositor Account that deposited funds\\n * @param amount Amount of collateral deposited\\n */\\n event CollateralDeposited(\\n uint256 indexed loanID,\\n address indexed depositor,\\n uint256 amount\\n );\\n\\n /**\\n * @notice This event is emitted when collateral has been withdrawn\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param receiver Account that received funds\\n * @param amount Value of collateral withdrawn\\n */\\n event CollateralWithdrawn(\\n uint256 indexed loanID,\\n address indexed receiver,\\n uint256 amount\\n );\\n\\n /**\\n * @notice it gets MarketStorage's collateral escrow using the loanID\\n * @param loanID the loanID to be used\\n * @return c_ which is the collateral escrow\\n */\\n function e(uint256 loanID) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[\\n MarketStorageLib.store().loans[loanID].collateralToken\\n ];\\n }\\n\\n function e(address token) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[token];\\n }\\n\\n /**\\n * @notice it deposits an amount of collateral into a collateral escrow's address of a respective loan\\n * @param loanID the respective loan ID\\n * @param amount the amount of collateral to deposit\\n */\\n function deposit(uint256 loanID, uint256 amount) internal {\\n e(loanID).deposit{ value: amount }(loanID, amount);\\n\\n emit CollateralDeposited(loanID, msg.sender, amount);\\n }\\n\\n /**\\n * @notice it withdraws an amount from the collateral escrow\\n * @param loanID the respective loanID to withdraw from\\n * @param amount the number of collateral tokens to withdraw\\n * @param receiver the address who receives the withdrawal\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) internal {\\n e(loanID).withdraw(loanID, amount, receiver);\\n\\n emit CollateralWithdrawn(loanID, receiver, amount);\\n }\\n\\n /**\\n * @notice it withdraws the entire supply in collateral of a respective loan to an address\\n * @param loanID the respective loan's ID\\n * @param receiver the address of the receiver to withdraw tokens from\\n */\\n function withdrawAll(uint256 loanID, address payable receiver) internal {\\n withdraw(loanID, e(loanID).loanSupply(loanID), receiver);\\n }\\n\\n /**\\n * @notice it initializes a new escrow collateral to hold collateral tokens\\n * @param token address of the collateral token it holds\\n */\\n function createEscrow(address token) internal {\\n // Check if collateral escrow exists\\n if (address(e(token)) == address(0)) {\\n // Create escrow\\n address escrow =\\n AppStorageLib.store().collateralEscrowBeacon.cloneProxy(\\\"\\\");\\n ICollateralEscrow(escrow).init(\\n token,\\n // Check if collateral token is WETH\\n token == AppStorageLib.store().assetAddresses[\\\"WETH\\\"]\\n );\\n\\n // Set max allowance\\n IERC20(token).approve(escrow, type(uint256).max);\\n // Save escrow address for loan\\n MarketStorageLib.store().collateralEscrows[\\n token\\n ] = ICollateralEscrow(escrow);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x84dbab8283357a1cc4210e34642fc8247841a58973778f4f6570398cc3046947\",\"license\":\"MIT\"},\"contracts/market/libraries/LibLoans.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibEscrow } from \\\"../../escrow/libraries/LibEscrow.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus,\\n LoanDebt,\\n LoanTerms\\n} from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibLoans {\\n using NumbersLib for int256;\\n using NumbersLib for uint256;\\n\\n bytes32 internal constant ID = keccak256(\\\"LOANS\\\");\\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n * @notice it returns the loan\\n * @param loanID the ID of the respective loan\\n * @return l_ the loan \\n */\\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\\n l_ = s().loans[loanID];\\n }\\n\\n /**\\n * @notice it returns the loan debt from a respective loan\\n * @param loanID the ID of the respective loan\\n * @return d_ the loan debt from a respective loan\\n */\\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\\n d_ = s().loanDebt[loanID];\\n }\\n\\n // DEPRECATED\\n function terms(uint256 loanID)\\n internal\\n view\\n returns (LoanTerms storage t_)\\n {\\n t_ = s()._loanTerms[loanID];\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return owed_ uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID)\\n internal\\n view\\n returns (uint256 owed_)\\n {\\n if (loan(loanID).status == LoanStatus.Active) {\\n owed_ = debt(loanID).principalOwed + (debt(loanID).interestOwed);\\n }\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n internal\\n view\\n returns (uint256)\\n {\\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\\n }\\n \\n function getCollateralNeeded(uint256 loanID)\\n internal\\n view\\n returns (uint256 _needed)\\n {\\n (, _needed, ) = getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the total collateral needed in lending tokens, in collateral tokens and in escrowed loan values\\n * @param loanID the loanID to get the total collateral needed\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n internal\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\\n loanID\\n );\\n\\n // check if needed lending tokens is zero. if true, then needed collateral tokens is zero. else,\\n if (neededInLendingTokens == 0) {\\n neededInCollateralTokens = 0;\\n } else {\\n neededInCollateralTokens = PriceAggLib.valueFor(\\n loan(loanID).lendingToken,\\n loan(loanID).collateralToken,\\n neededInLendingTokens\\n );\\n }\\n }\\n\\n /**\\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\\n * @param loanID The loan ID to get needed collateral info for.\\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\\n */\\n function getCollateralNeededInTokens(uint256 loanID)\\n internal\\n view\\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\\n {\\n if (loan(loanID).collateralRatio == 0) {\\n return (0, 0);\\n }\\n\\n /*\\n The collateral to principal owed ratio is the sum of:\\n * collateral buffer percent\\n * loan interest rate\\n * liquidation reward percent\\n * X factor of additional collateral\\n */\\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n neededInLendingTokens = loan(loanID).borrowedAmount.percent(\\n loan(loanID).collateralRatio\\n );\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n uint16 requiredRatio =\\n loan(loanID).collateralRatio -\\n getInterestRatio(loanID) -\\n uint16(PlatformSettingsLib.getCollateralBufferValue());\\n\\n neededInLendingTokens =\\n debt(loanID).principalOwed +\\n debt(loanID).interestOwed;\\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\\n if (\\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\\n ) {\\n neededInLendingTokens -= escrowLoanValue;\\n }\\n neededInLendingTokens = neededInLendingTokens.percent(\\n requiredRatio\\n );\\n }\\n }\\n\\n /**\\n * @notice check if a loan can go to end of auction with a collateral ratio\\n * @return bool checking if collateralRatio is >= the over collateralized buffer value\\n */\\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\\n internal\\n view\\n returns (bool)\\n {\\n return\\n collateralRatio >=\\n PlatformSettingsLib.getOverCollateralizedBufferValue();\\n }\\n\\n /**\\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\\n * @notice There is a minimum threshold of 1%.\\n * @dev The interest rate is APY (annual percentage yield).\\n * @param loanID The loan ID to get the interest rate for.\\n */\\n function getInterestRatio(uint256 loanID)\\n internal\\n view\\n returns (uint16 ratio_)\\n {\\n ratio_ = uint16(\\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\\n SECONDS_PER_YEAR\\n );\\n\\n if (ratio_ == 0) {\\n ratio_ = 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0xe48b287a583b40e534654e4023422f59a9e6d7dd265d68ae4af43f8da58c09d9\",\"license\":\"MIT\"},\"contracts/nft/IStakeableNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IStakeableNFT {\\n function tokenBaseLoanSize(uint256 tokenId) external view returns (uint256);\\n\\n function tokenURIHash(uint256 tokenId)\\n external\\n view\\n returns (string memory);\\n\\n function tokenContributionAsset(uint256 tokenId)\\n external\\n view\\n returns (address);\\n\\n function tokenContributionSize(uint256 tokenId)\\n external\\n view\\n returns (uint256);\\n\\n function tokenContributionMultiplier(uint256 tokenId)\\n external\\n view\\n returns (uint8);\\n}\\n\",\"keccak256\":\"0xfbf44350ad91a54de26f39195d714580d7dade556ea4c7991a51eef5aa839105\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x417b75f5d92be67993efc54db7d453be5b5058a9a54d8916380e0281d3299526\",\"license\":\"MIT\"},\"contracts/nft/TellerNFTDictionary.sol\":{\"content\":\"/**\\n * @notice TellerNFTDictionary Version 1.02\\n *\\n * @notice This contract is used to gather data for TellerV1 NFTs more efficiently.\\n * @notice This contract has data which must be continuously synchronized with the TellerV1 NFT data\\n *\\n * @author develop@teller.finance\\n */\\n\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Interfaces\\nimport \\\"./IStakeableNFT.sol\\\";\\n\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFTDictionary is IStakeableNFT, AccessControlUpgradeable {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n mapping(uint256 => uint256) public baseLoanSizes;\\n mapping(uint256 => string[]) public hashes;\\n mapping(uint256 => address) public contributionAssets;\\n mapping(uint256 => uint256) public contributionSizes;\\n mapping(uint256 => uint8) public contributionMultipliers;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n\\n /* State Variables */\\n\\n mapping(uint256 => uint256) public _tokenTierMappingCompressed;\\n bool public _tokenTierMappingCompressedSet;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFTDictionary: not admin\\\");\\n _;\\n }\\n\\n function initialize(address initialAdmin) public {\\n _setupRole(ADMIN, initialAdmin);\\n _setRoleAdmin(ADMIN, ADMIN);\\n\\n __AccessControl_init();\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTierIndex(uint256 tokenId)\\n public\\n view\\n returns (uint8 index_)\\n {\\n //32 * 8 = 256 - each uint256 holds the data of 32 tokens . 8 bits each.\\n\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 compressedRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n //use 31 instead of 32 to account for the '0x' in the start.\\n //the '31 -' reverses our bytes order which is necessary\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint8 tierIndex = uint8((compressedRegister >> offset));\\n\\n return tierIndex;\\n }\\n\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory)\\n {\\n return hashes[tierIndex];\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTier(uint256 index, Tier memory newTier)\\n external\\n onlyAdmin\\n returns (bool)\\n {\\n baseLoanSizes[index] = newTier.baseLoanSize;\\n hashes[index] = newTier.hashes;\\n contributionAssets[index] = newTier.contributionAsset;\\n contributionSizes[index] = newTier.contributionSize;\\n contributionMultipliers[index] = newTier.contributionMultiplier;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param tiersMapping Information about the new tiers to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setAllTokenTierMappings(uint256[] memory tiersMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n require(\\n !_tokenTierMappingCompressedSet,\\n \\\"TellerNFTDictionary: token tier mapping already set\\\"\\n );\\n for (uint256 i = 0; i < tiersMapping.length; i++) {\\n _tokenTierMappingCompressed[i] = tiersMapping[i];\\n }\\n\\n _tokenTierMappingCompressedSet = true;\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param index the mapping row, each holds data for 32 tokens\\n * @param tierMapping Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierMapping(uint256 index, uint256 tierMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n _tokenTierMappingCompressed[index] = tierMapping;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenIds the NFT token Ids for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenIds(\\n uint256[] calldata tokenIds,\\n uint256 tokenTier\\n ) public onlyAdmin returns (bool) {\\n for (uint256 i; i < tokenIds.length; i++) {\\n setTokenTierForTokenId(tokenIds[i], tokenTier);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenId the NFT token Id for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenId(uint256 tokenId, uint256 tokenTier)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 existingRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint256 updateMaskShifted =\\n 0x00000000000000000000000000000000000000000000000000000000000000FF <<\\n offset;\\n\\n uint256 updateMaskShiftedNegated = ~updateMaskShifted;\\n\\n uint256 tokenTierShifted =\\n ((0x0000000000000000000000000000000000000000000000000000000000000000 |\\n tokenTier) << offset);\\n\\n uint256 existingRegisterClearedWithMask =\\n existingRegister & updateMaskShiftedNegated;\\n\\n uint256 updatedRegister =\\n existingRegisterClearedWithMask | tokenTierShifted;\\n\\n _tokenTierMappingCompressed[mappingIndex] = updatedRegister;\\n\\n return true;\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(IStakeableNFT).interfaceId ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n New methods for the dictionary\\n */\\n\\n /**\\n * @notice It returns Base Loan Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenBaseLoanSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return baseLoanSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Token URI Hash for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenURIHash(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n string[] memory tierImageHashes = hashes[tokenTier];\\n return tierImageHashes[tokenId % (tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice It returns Contribution Asset for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionAsset(uint256 tokenId)\\n public\\n view\\n override\\n returns (address)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionAssets[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Multiplier for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionMultiplier(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint8)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionMultipliers[tokenTier];\\n }\\n}\\n\",\"keccak256\":\"0xf33e3fa1f609fdd2abb3b5fb9c232269d13363a3e4fa5697ea96269e361e74fa\"},\"contracts/nft/libraries/NFTLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../TellerNFT.sol\\\";\\n\\n// Libraries\\nimport {\\n MerkleProof\\n} from \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\nimport { NFTStorageLib, NFTStorage } from \\\"../../storage/nft.sol\\\";\\n\\nlibrary NFTLib {\\n function s() internal pure returns (NFTStorage storage s_) {\\n s_ = NFTStorageLib.store();\\n }\\n\\n function nft() internal view returns (TellerNFT nft_) {\\n nft_ = AppStorageLib.store().nft;\\n }\\n\\n /**s\\n * @notice it transfers the NFT from the sender to the diamond to stake then adds the NFTID to the list of the owner's stakedNFTs\\n * @param nftID the ID of the NFT to stake\\n * @param owner the owner of the NFT who will stake the NFT\\n */\\n function stake(uint256 nftID, address owner) internal {\\n // Transfer to diamond\\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\\n // Add NFT ID to user set\\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\\n }\\n\\n /**\\n * @notice it unstakes the NFT by removing the NFT ID from the list of the user's staked NFTs\\n * @param nftID the ID of the NFT to remove from the list of the user's staked NFTs\\n * @return success_ the boolean value telling us if the user has unsuccessfully unstaked the NFT\\n */\\n function unstake(uint256 nftID) internal returns (bool success_) {\\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\\n }\\n\\n /**\\n * @notice it gets the list of staked NFTs from the owner\\n * @param nftOwner the owner of the staked NFTs to pull from\\n * @return staked_ the array of the staked NFTs owned by the user\\n */\\n function stakedNFTs(address nftOwner)\\n internal\\n view\\n returns (uint256[] memory staked_)\\n {\\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\\n staked_ = new uint256[](EnumerableSet.length(nfts));\\n for (uint256 i; i < staked_.length; i++) {\\n staked_[i] = EnumerableSet.at(nfts, i);\\n }\\n }\\n\\n /**\\n * @notice if the user fails to pay his loan, then we liquidate the all the NFTs associated with the loan\\n * @param loanID the identifier of the loan to liquidate the NFTs from\\n */\\n function liquidateNFT(uint256 loanID) internal {\\n // Check if NFTs are linked\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n NFTLib.nft().transferFrom(\\n address(this),\\n AppStorageLib.store().nftLiquidationController,\\n EnumerableSet.at(nfts, i)\\n );\\n }\\n }\\n\\n /**\\n * @notice it unstakes an NFT and verifies the proof in order to apply the proof to a loan\\n * @param loanID the identifier of the loan\\n * @param nftID the NFT ID to apply to the loan\\n */\\n function applyToLoan(uint256 loanID, uint256 nftID) internal {\\n // NFT must be currently staked\\n // Remove NFT from being staked - returns bool\\n require(unstake(nftID), \\\"Teller: borrower nft not staked\\\");\\n\\n // Apply NFT to loan\\n EnumerableSet.add(s().loanNFTs[loanID], nftID);\\n }\\n\\n /**\\n * @notice it finds the loan's NFTs and adds them back to the owner's list of staked NFTs\\n * @param loanID the identifier of the respective loan to add the NFTs back to the user's staked NFTs\\n * @param owner the owner to add the unstaked NFTs back to the staked pile\\n */\\n function restakeLinked(uint256 loanID, address owner) internal {\\n // Get linked NFT\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n // Restake the NFT\\n EnumerableSet.add(s().stakedNFTs[owner], EnumerableSet.at(nfts, i));\\n }\\n }\\n}\\n\",\"keccak256\":\"0xccbd35c6e8d0130b38f5025ee81c47d55e4fa48c8fcb8bec6f70c21061e0ce61\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n /**\\n * @notice it returns 10^{numberOfDecimals} for a token\\n * @param token the address to calculate the decimals for\\n * @return 10^number of decimals used to calculate the price and value of different token pairs\\n */\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @notice It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @notice it tries to calculate a price from Compound and Chainlink.\\n * @dev if no price is found on compound, then calculate it on chainlink\\n * @param src the token address to calculate the price for in dst\\n * @param dst the token address to retrieve the price of src\\n * @return price_ the price of src in dst\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n * @param src the address of the src token\\n * @param dst the address of the dst token\\n * @return the price of the src token in dst token\\n\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n * @param src the source token to calculate price for with chainlink\\n * @param dst the destination token to calculate price for with chainlink\\n * @param cRate the compound rate to multiply with the price of the dst token\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @notice Scales the {value} by the difference in decimal values.\\n * @param value the the value of the src in dst\\n * @param srcDecimals src token decimals\\n * @param dstDecimals dst token decimals\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @notice it tries to calculate the price of {src} in {dst}\\n * @param src address of source token\\n * @param dst address of destination token\\n * @return the price of src token in dst\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address WETH = AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n if (dst != WETH) {\\n int256 price1 = _priceFor(src, WETH);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, WETH);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice it checks if a token is a cToken. If it is, then get the underlying address\\n * @param token address of the token\\n * @return isCToken boolean whether it's a cToken\\n * @return underlying the address of the cToken\\n */\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2efb3d71a1c0fb49f8c455c4fa30d04c69a1617d619035fc400dabdeb2ab0c9e\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { PriceAggFacet } from \\\"./PriceAggFacet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\n/**\\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\\n */\\nlibrary PriceAggLib {\\n /**\\n * @notice It calculates the value of one token amount into another\\n * @param src the source token\\n * @param dst the destination token\\n * @param srcAmount the amount of source token\\n * @return value_ the returned value of src in dst\\n */\\n function valueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) internal view returns (uint256 value_) {\\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\\n }\\n\\n /**\\n * @notice It returns the price of the token pair as given from Compound.\\n * @dev if no compound price is calculated, then it checks Chainlink price Aggregator\\n * @param src the address of the source token\\n * @param dst the address of the desitnation token\\n * @return price_ gets the price of src in dst\\n */\\n function priceFor(address src, address dst)\\n internal\\n view\\n returns (int256 price_)\\n {\\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\\n }\\n}\\n\",\"keccak256\":\"0xff59eee567fa4a7f5cac432e31d918be92834f04614f49572d3984a5b030ac79\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\nabstract contract PausableMods {\\n /**\\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\\n * @param id id of the facet to check if is paused.\\n * @param state Boolean that the protocol AND facet should be in.\\n */\\n modifier paused(bytes32 id, bool state) {\\n require(\\n __isPaused(\\\"\\\") == state && __isPaused(id) == state,\\n __pausedMessage(state)\\n );\\n _;\\n }\\n\\n /**\\n * @dev Checks if the given id is paused.\\n * @param id Encoded id of the facet to check if is paused.\\n * @return the bool to tell us if the facet is paused (true) or not (false)\\n */\\n function __isPaused(bytes32 id) private view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n\\n /**\\n * @dev Gets the message that should be reverted with given a state it should be in.\\n * @param state Boolean that an id should be in.\\n * @return a message stating whether the facet is paused or not\\n */\\n function __pausedMessage(bool state) private pure returns (string memory) {\\n return state ? \\\"Pausable: not paused\\\" : \\\"Pausable: paused\\\";\\n }\\n}\\n\",\"keccak256\":\"0x2d3f848ee56ae5fa365539c2509c03c167affc89c89f98bb98cb9b83fbe8ae4c\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"NFTInterestRate\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getNFTInterestRate() internal view returns (uint16 value_) {\\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0x44294be1af9f913b2ed391a40cd4b646537a4b463b8d5ff1fac8ead3988966c1\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for loans taken out with an NFT.\\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\\n */\\nbytes32 constant NFT_INTEREST_RATE = keccak256(\\\"NFTInterestRate\\\");\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xd68a7df42b2bbba6f935d5890b7b37997c1432e25ae113827b8bde87f94fd86f\",\"license\":\"MIT\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n /**\\n * @notice Checks if the account should be allowed to mint tokens in the given market\\n * @param cToken The market to verify the mint against\\n * @param minter The account which would get the minted tokens\\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates mint and reverts on rejection. May emit logs.\\n * @param cToken Asset being minted\\n * @param minter The address minting the tokens\\n * @param mintAmount The amount of the underlying asset being minted\\n * @param mintTokens The number of tokens being minted\\n */\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to redeem tokens in the given market\\n * @param cToken The market to verify the redeem against\\n * @param redeemer The account which would redeem the tokens\\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates redeem and reverts on rejection. May emit logs.\\n * @param cToken Asset being redeemed\\n * @param redeemer The address redeeming the tokens\\n * @param redeemAmount The amount of the underlying asset being redeemed\\n * @param redeemTokens The number of tokens being redeemed\\n */\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\\n * @param cToken The market to verify the borrow against\\n * @param borrower The account which would borrow the asset\\n * @param borrowAmount The amount of underlying the account would borrow\\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates borrow and reverts on rejection. May emit logs.\\n * @param cToken Asset whose underlying is being borrowed\\n * @param borrower The address borrowing the underlying\\n * @param borrowAmount The amount of the underlying asset requested to borrow\\n */\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to repay a borrow in the given market\\n * @param cToken The market to verify the repay against\\n * @param payer The account which would repay the asset\\n * @param borrower The account which would borrowed the asset\\n * @param repayAmount The amount of the underlying asset the account would repay\\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\\n * @param cToken Asset being repaid\\n * @param payer The address repaying the borrow\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param borrowerIndex the index of the borrower\\n */\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n /**\\n * @notice Checks if the liquidation should be allowed to occur\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n */\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the seizing of assets should be allowed to occur\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates seize and reverts on rejection. May emit logs.\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to transfer tokens in the given market\\n * @param cToken The market to verify the transfer against\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates transfer and reverts on rejection. May emit logs.\\n * @param cToken Asset being transferred\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n */\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in all markets\\n * @param holder The address to claim COMP for\\n */\\n function claimComp(address holder) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in the specified markets\\n * @param holder The address to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n */\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n /**\\n * @notice Claim all comp accrued by the holders\\n * @param holders The addresses to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n * @param borrowers Whether or not to claim COMP earned by borrowing\\n * @param suppliers Whether or not to claim COMP earned by supplying\\n */\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n /**\\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\\n * @param cTokenBorrowed The address of the borrowed cToken\\n * @param cTokenCollateral The address of the collateral cToken\\n * @param repayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\\n */\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n /**\\n * @notice Return the address of the COMP token\\n * @return The address of COMP\\n */\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x38a824a4a21ce9370fa581a616d1bb9d311f27d8982a6b96ebeba90bd5fd0adb\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n \\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x37849041e4bee2dfa825677f69078521fcc94804aa5120f67dd12cc4133efcec\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @dev CETH is the only Compound token that does not support the {underlying} function.\\n * @param cToken address of the compound token\\n * @return address of the underlying cToken\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x99206384c27b0e68b1ec7b82260f6a47965f611875c018bc076ff8a688a6c6d7\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n /**\\n * @notice it returns the absolute number of a specified parameter\\n * @param self the number to be returned in it's absolute \\n * @return the absolute number\\n */\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0xa852b8866a3d6d928c6575bf2bcf2ae784eed73717c78c0cadbdedf8b0ba3274\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0c52fdd76b33f74e233c3a27dd3b73b134e9643aab347b3aa649c504809c6559\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\n// DEPRECATED\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\nstruct LoanRequest {\\n LoanUserRequest request;\\n LoanConsensusResponse[] responses;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanUserRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanConsensusResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) _loanTerms; // DEPRECATED: DO NOT REMOVE\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb7e05aeec806b5621512def93f4a389b4ef88c50ef9fe7115a33f57db2f2304b\",\"license\":\"MIT\"},\"contracts/storage/nft.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"../nft/TellerNFTDictionary.sol\\\";\\n\\n// Utils\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct NFTStorage {\\n // Maps NFT owner to set of token IDs owned\\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\\n // Maps loanID to NFT IDs indicating NFT being used for the loan\\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\\n // Merkle root used for verifying nft IDs to base loan size\\n TellerNFTDictionary nftDictionary;\\n}\\n\\nbytes32 constant NFT_STORAGE_POS = keccak256(\\\"teller.staking.storage\\\");\\n\\nlibrary NFTStorageLib {\\n function store() internal pure returns (NFTStorage storage s) {\\n bytes32 pos = NFT_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd44f213be3125ea2e2de120c241832f1861be18b3ff2fd4c3baa52ea20b94812\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "history": [ + { + "address": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "RepayFacet", + "transactionHash": "0x4eea8acaef6be55cbc8d57c0b6b00c1cd78c7a4d37cba43eddf3f918f9617153", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "transactionIndex": 82, + "gasUsed": "1886617", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0x68c322ecfafd109f47e23505b015026e64b2edcec4bf5115acc411e5ae03cc6e", + "transactionHash": "0x4eea8acaef6be55cbc8d57c0b6b00c1cd78c7a4d37cba43eddf3f918f9617153", + "logs": [], + "blockNumber": 12438048, + "cumulativeGasUsed": "6642407", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "7aad2cc112697924bcec275c5d33dbff", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"liquidator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"reward\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokensIn\",\"type\":\"uint256\"}],\"name\":\"LoanLiquidated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountPaid\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"totalOwed\",\"type\":\"uint256\"}],\"name\":\"LoanRepaid\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"escrowRepay\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLiquidationReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"inLending_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"inCollateral_\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"liquidateLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"repayLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"params\":{\"borrower\":\"Account address of the borrower\",\"liquidator\":\"Account address of the liquidator\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"reward\":\"Value in lending token paid out to liquidator\",\"tokensIn\":\"Percentage of the collateral price paid by the liquidator to the lending pool\"}},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"params\":{\"amountPaid\":\"Amount of the loan paid back\",\"borrower\":\"Account address of the borrower\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"payer\":\"Account address of the payer\",\"totalOwed\":\"Total amount of the loan to be repaid\"}}},\"kind\":\"dev\",\"methods\":{\"escrowRepay(uint256,uint256)\":{\"details\":\"If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\",\"params\":{\"amount\":\"The amount being repaid.\",\"loanID\":\"The id of the loan being used.\"}},\"getLiquidationReward(uint256)\":{\"params\":{\"loanID\":\"The loan ID to get the info.\"},\"returns\":{\"inCollateral_\":\"The value the liquidator will receive denoted in collateral tokens.\",\"inLending_\":\"The value the liquidator will receive denoted in lending tokens.\"}},\"liquidateLoan(uint256)\":{\"params\":{\"loanID\":\"The ID of the loan to be liquidated\"}},\"repayLoan(uint256,uint256)\":{\"params\":{\"amount\":\"The amount of tokens to pay back to the loan\",\"loanID\":\"The ID of the loan the payment is for\"}}},\"version\":1},\"userdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully liquidated\"},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully repaid\"}},\"kind\":\"user\",\"methods\":{\"escrowRepay(uint256,uint256)\":{\"notice\":\"Repay this Escrow's loan.\"},\"getLiquidationReward(uint256)\":{\"notice\":\"It gets the current liquidation reward for a given loan.\"},\"liquidateLoan(uint256)\":{\"notice\":\"Liquidate a loan if it is expired or under collateralized\"},\"repayLoan(uint256,uint256)\":{\"notice\":\"Make a payment to a loan\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/market/RepayFacet.sol\":\"RepayFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Trees proofs.\\n *\\n * The proofs can be generated using the JavaScript library\\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\\n *\\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n bytes32 computedHash = leaf;\\n\\n for (uint256 i = 0; i < proof.length; i++) {\\n bytes32 proofElement = proof[i];\\n\\n if (computedHash <= proofElement) {\\n // Hash(current computed hash + current element of the proof)\\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\\n } else {\\n // Hash(current element of the proof + current computed hash)\\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\\n }\\n }\\n\\n // Check if the computed hash (root) is equal to the provided root\\n return computedHash == root;\\n }\\n}\\n\",\"keccak256\":\"0xeee34bfb413657b6cd6c8e1e15c2080ba5ebaac479578515922804346fb63f7c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/reentry/ReentryMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nabstract contract ReentryMods {\\n modifier nonReentry(bytes32 id) {\\n AccessControlStorage storage s = AccessControlStorageLib.store();\\n require(!s.entered[id], \\\"AccessControl: reentered\\\");\\n s.entered[id] = true;\\n _;\\n s.entered[id] = false;\\n }\\n}\\n\",\"keccak256\":\"0x033c1164af25ef7d35a38a60973bf379b1cc603596914ffd85dcbcf0acdb6970\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../interfaces/IAToken.sol\\\";\\nimport { IAaveLendingPool } from \\\"../interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x8030b206c87d0073fb7dbebfa2ee8a3e93c479d976d6cdaa0c939f2fedaa1525\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n function setTokenAllowance(address token, address spender) external;\\n\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xdaa338698014e6c00edf7a2aca49026a047e253cbe7fc392a73f5f63a063a7f9\",\"license\":\"MIT\"},\"contracts/escrow/libraries/LibEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibDapps } from \\\"../dapps/libraries/LibDapps.sol\\\";\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibEscrow {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\\n e_ = s().loanEscrows[loanID];\\n }\\n\\n function getEscrowTokens(uint256 loanID)\\n internal\\n view\\n returns (EnumerableSet.AddressSet storage t_)\\n {\\n t_ = s().escrowTokens[loanID];\\n }\\n\\n function balanceOf(uint256 loanID, address token)\\n internal\\n view\\n returns (uint256)\\n {\\n return IERC20(token).balanceOf(address(e(loanID)));\\n }\\n\\n /**\\n * @notice Adds or removes tokens held by the Escrow contract\\n * @param loanID The loan ID to update the token list for\\n * @param tokenAddress The token address to be added or removed\\n */\\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\\n // Skip if is lending token\\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\\n\\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\\n if (balanceOf(loanID, tokenAddress) > 0) {\\n if (!contains) {\\n EnumerableSet.add(tokens, tokenAddress);\\n }\\n } else if (contains) {\\n EnumerableSet.remove(tokens, tokenAddress);\\n }\\n }\\n\\n /**\\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\\n * @param loanID The loan ID to calculate value for\\n * @return value_ Escrow total value denoted in the lending token.\\n */\\n function calculateTotalValue(uint256 loanID)\\n internal\\n view\\n returns (uint256 value_)\\n {\\n address lendingToken = LibLoans.loan(loanID).lendingToken;\\n value_ += balanceOf(loanID, lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\\n if (EnumerableSet.length(tokens) > 0) {\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n uint256 tokenBal =\\n balanceOf(loanID, EnumerableSet.at(tokens, i));\\n value_ += PriceAggLib.valueFor(\\n EnumerableSet.at(tokens, i),\\n lendingToken,\\n tokenBal\\n );\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xcca97599fff1c1bd608e7f11c4674f325e43781794e91bf5322ac9e0ffd7b3df\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when an user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when an user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @return totalSupply_ The total value of the underlying token managed by the LP.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given markets.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider o the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfil the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n */\\n function restrict(bool state) external virtual;\\n\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xe6515c78e0277edbed82aa6926df727afd216379dd0bfbbb790222654c858499\",\"license\":\"MIT\"},\"contracts/market/LoanDataFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { Loan, LoanDebt, LoanTerms } from \\\"../storage/market.sol\\\";\\n\\ncontract LoanDataFacet {\\n /**\\n * @notice Returns the information about the given {loanID}.\\n * @param loanID The loan ID to get information for.\\n * @return loan_ The loan data.\\n */\\n function getLoan(uint256 loanID) external view returns (Loan memory loan_) {\\n loan_ = LibLoans.s().loans[loanID];\\n }\\n\\n /**\\n * @notice Returns the terms for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanTerms The terms that the loan weer created with.\\n */\\n function getLoanTerms(uint256 loanID)\\n external\\n view\\n returns (LoanTerms memory)\\n {\\n return LibLoans.terms(loanID);\\n }\\n\\n /**\\n * @notice Returns the loan IDs created by the {borrower} account.\\n * @param borrower The account to get loan IDs for.\\n * @return loanIDs The IDs for loans created by the {borrower}\\n */\\n function getBorrowerLoans(address borrower)\\n external\\n view\\n returns (uint128[] memory loanIDs)\\n {\\n return LibLoans.s().borrowerLoans[borrower];\\n }\\n\\n /**\\n * @notice Returns the debt owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanDebt The principal and interest owed amount.\\n */\\n function getDebtOwed(uint256 loanID)\\n external\\n view\\n returns (LoanDebt memory)\\n {\\n return LibLoans.debt(loanID);\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) external view returns (uint256) {\\n return LibLoans.getTotalOwed(loanID);\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n external\\n view\\n returns (uint256)\\n {\\n return LibLoans.getInterestOwedFor(loanID, amountBorrow);\\n }\\n\\n function getCollateralNeededInfo(uint256 loanID)\\n external\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n return LibLoans.getCollateralNeededInfo(loanID);\\n }\\n\\n function getLoanEscrow(uint256 loanID)\\n external\\n view\\n returns (address escrow_)\\n {\\n escrow_ = address(LibLoans.s().loanEscrows[loanID]);\\n }\\n\\n function getLoanEscrowValue(uint256 loanID)\\n external\\n view\\n returns (uint256)\\n {\\n return LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n function getEscrowTokens(uint256 loanID)\\n external\\n view\\n returns (address[] memory tokens_)\\n {\\n EnumerableSet.AddressSet storage escrowTokens =\\n LibEscrow.getEscrowTokens(loanID);\\n tokens_ = new address[](EnumerableSet.length(escrowTokens));\\n for (uint256 i; i < tokens_.length; i++) {\\n tokens_[i] = EnumerableSet.at(escrowTokens, i);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf589a2afff647e5288e15f3f6614135395562b4d12c743402a6504a3fb9b39d6\",\"license\":\"MIT\"},\"contracts/market/RepayFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\nimport {\\n ReentryMods\\n} from \\\"../contexts2/access-control/reentry/ReentryMods.sol\\\";\\nimport { AUTHORIZED } from \\\"../shared/roles.sol\\\";\\nimport { LoanDataFacet } from \\\"./LoanDataFacet.sol\\\";\\n\\n// Libraries\\nimport {\\n IERC20,\\n SafeERC20\\n} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibCollateral } from \\\"./libraries/LibCollateral.sol\\\";\\nimport { LibDapps } from \\\"../escrow/dapps/libraries/LibDapps.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { NumbersLib } from \\\"../shared/libraries/NumbersLib.sol\\\";\\nimport { PriceAggLib } from \\\"../price-aggregator/PriceAggLib.sol\\\";\\nimport { NFTLib } from \\\"../nft/libraries/NFTLib.sol\\\";\\n\\n// Interfaces\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus\\n} from \\\"../storage/market.sol\\\";\\n\\ncontract RepayFacet is RolesMods, ReentryMods, PausableMods {\\n /**\\n @notice This event is emitted when a loan has been successfully repaid\\n @param loanID ID of loan from which collateral was withdrawn\\n @param borrower Account address of the borrower\\n @param amountPaid Amount of the loan paid back\\n @param payer Account address of the payer\\n @param totalOwed Total amount of the loan to be repaid\\n */\\n event LoanRepaid(\\n uint256 indexed loanID,\\n address indexed borrower,\\n uint256 amountPaid,\\n address payer,\\n uint256 totalOwed\\n );\\n\\n /**\\n * @notice This event is emitted when a loan has been successfully liquidated\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param borrower Account address of the borrower\\n * @param liquidator Account address of the liquidator\\n * @param reward Value in lending token paid out to liquidator\\n * @param tokensIn Percentage of the collateral price paid by the liquidator to the lending pool\\n */\\n event LoanLiquidated(\\n uint256 indexed loanID,\\n address indexed borrower,\\n address liquidator,\\n uint256 reward,\\n uint256 tokensIn\\n );\\n\\n /**\\n * @notice Repay this Escrow's loan.\\n * @dev If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.\\n * @dev Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\\n * @param loanID The id of the loan being used.\\n * @param amount The amount being repaid.\\n */\\n function escrowRepay(uint256 loanID, uint256 amount)\\n external\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n nonReentry(\\\"\\\")\\n {\\n uint256 balance =\\n LibEscrow.balanceOf(loanID, LibLoans.loan(loanID).lendingToken);\\n uint256 totalOwed = LibLoans.getTotalOwed(loanID);\\n if (balance < totalOwed && amount > balance) {\\n uint256 amountNeeded =\\n amount > totalOwed ? totalOwed - (balance) : amount - (balance);\\n\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n msg.sender,\\n address(LibEscrow.e(loanID)),\\n amountNeeded\\n );\\n }\\n\\n uint256 leftToPay =\\n __repayLoan(loanID, amount, address(LibEscrow.e(loanID)));\\n // if the loan is now fully paid, close it and withdraw borrower collateral\\n if (leftToPay == 0) {\\n LibLoans.loan(loanID).status = LoanStatus.Closed;\\n LibCollateral.withdrawAll(loanID, LibLoans.loan(loanID).borrower);\\n }\\n\\n emit LoanRepaid(\\n loanID,\\n LibLoans.loan(loanID).borrower,\\n amount,\\n msg.sender,\\n leftToPay\\n );\\n }\\n\\n /**\\n * @notice Make a payment to a loan\\n * @param loanID The ID of the loan the payment is for\\n * @param amount The amount of tokens to pay back to the loan\\n */\\n function repayLoan(uint256 loanID, uint256 amount)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n uint256 leftToPay = __repayLoan(loanID, amount, msg.sender);\\n // if the loan is now fully paid, close it and withdraw borrower collateral\\n if (leftToPay == 0) {\\n LibLoans.loan(loanID).status = LoanStatus.Closed;\\n LibCollateral.withdrawAll(loanID, LibLoans.loan(loanID).borrower);\\n // Restake any NFTs linked to loan for borrower\\n NFTLib.restakeLinked(loanID, LibLoans.loan(loanID).borrower);\\n }\\n\\n emit LoanRepaid(\\n loanID,\\n LibLoans.loan(loanID).borrower,\\n amount,\\n msg.sender,\\n leftToPay\\n );\\n }\\n\\n function __repayLoan(\\n uint256 loanID,\\n uint256 amount,\\n address sender\\n ) private returns (uint256 leftToPay_) {\\n require(amount > 0, \\\"Teller: zero repay\\\");\\n\\n // calculate the actual amount to repay\\n leftToPay_ =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n if (leftToPay_ < amount) {\\n amount = leftToPay_;\\n leftToPay_ = 0;\\n } else {\\n leftToPay_ -= amount;\\n }\\n\\n // Get the Teller token for the loan\\n ITToken tToken =\\n MarketStorageLib.store().tTokens[\\n LibLoans.loan(loanID).lendingToken\\n ];\\n // Transfer funds from account\\n if (address(LibEscrow.e(loanID)) == sender) {\\n LibEscrow.e(loanID).claimToken(\\n LibLoans.loan(loanID).lendingToken,\\n address(tToken),\\n amount\\n );\\n } else {\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n sender,\\n address(tToken),\\n amount\\n );\\n }\\n\\n // Deduct the interest and principal owed\\n uint256 principalPaid;\\n uint256 interestPaid;\\n if (amount < LibLoans.debt(loanID).interestOwed) {\\n interestPaid = amount;\\n LibLoans.debt(loanID).interestOwed -= amount;\\n } else {\\n if (LibLoans.debt(loanID).interestOwed > 0) {\\n interestPaid = LibLoans.debt(loanID).interestOwed;\\n amount -= interestPaid;\\n LibLoans.debt(loanID).interestOwed = 0;\\n }\\n\\n if (amount > 0) {\\n principalPaid = amount;\\n LibLoans.debt(loanID).principalOwed -= amount;\\n }\\n }\\n\\n // Tell the Teller Token value has been deposited back into the pool.\\n tToken.repayLoan(principalPaid, interestPaid);\\n }\\n\\n /**\\n * @notice Liquidate a loan if it is expired or under collateralized\\n * @param loanID The ID of the loan to be liquidated\\n */\\n function liquidateLoan(uint256 loanID)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n uint256 collateralAmount = LibCollateral.e(loanID).loanSupply(loanID);\\n require(\\n RepayLib.isLiquidable(loanID, collateralAmount),\\n \\\"Teller: does not need liquidation\\\"\\n );\\n\\n // Calculate the reward before repaying the loan\\n (uint256 rewardInLending, uint256 collateralInLending) =\\n RepayLib.getLiquidationReward(loanID, collateralAmount);\\n\\n // The liquidator pays the amount still owed on the loan\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n // Make sure there is nothing left to repay on the loan\\n require(\\n __repayLoan(loanID, amountToLiquidate, msg.sender) == 0,\\n \\\"Teller: liquidate partial repay\\\"\\n );\\n\\n // Set loan status\\n loan.status = LoanStatus.Liquidated;\\n\\n // Payout the liquidator reward owed\\n if (rewardInLending > 0) {\\n RepayLib.payOutLiquidator(\\n loanID,\\n rewardInLending,\\n collateralInLending,\\n collateralAmount,\\n payable(msg.sender)\\n );\\n }\\n\\n // Transfer NFT if linked\\n NFTLib.liquidateNFT(loanID);\\n\\n emit LoanLiquidated(\\n loanID,\\n loan.borrower,\\n msg.sender,\\n rewardInLending,\\n amountToLiquidate\\n );\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @return inLending_ The value the liquidator will receive denoted in lending tokens.\\n * @return inCollateral_ The value the liquidator will receive denoted in collateral tokens.\\n */\\n function getLiquidationReward(uint256 loanID)\\n external\\n view\\n returns (uint256 inLending_, uint256 inCollateral_)\\n {\\n (inLending_, ) = RepayLib.getLiquidationReward(\\n loanID,\\n LibCollateral.e(loanID).loanSupply(loanID)\\n );\\n inCollateral_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n inLending_\\n );\\n }\\n}\\n\\nlibrary RepayLib {\\n /**\\n * @notice It checks if a loan can be liquidated.\\n * @param loanID The loan ID to check.\\n * @return true if the loan is liquidable.\\n */\\n function isLiquidable(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (bool)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n // Check if loan can be liquidated\\n if (loan.status != LoanStatus.Active) {\\n return false;\\n }\\n\\n if (loan.collateralRatio > 0) {\\n // If loan has a collateral ratio, check how much is needed\\n (, uint256 neededInCollateral, ) =\\n LoanDataFacet(address(this)).getCollateralNeededInfo(loanID);\\n if (neededInCollateral > collateralAmount) {\\n return true;\\n }\\n }\\n\\n // Otherwise, check if the loan has expired\\n return block.timestamp >= loan.loanStartTime + loan.duration;\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @param collateralAmount The amount of collateral for the {loanID}. Passed in to save gas calling the collateral escrow multiple times.\\n * @return reward_ The value the liquidator will receive denoted in lending tokens.\\n */\\n function getLiquidationReward(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (uint256 reward_, uint256 collateralValue_)\\n {\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n // Max reward is amount repaid on loan plus extra percentage\\n uint256 maxReward =\\n amountToLiquidate +\\n NumbersLib.percent(\\n amountToLiquidate,\\n uint16(PlatformSettingsLib.getLiquidateRewardPercent())\\n );\\n\\n // Calculate available collateral for reward\\n if (collateralAmount > 0) {\\n collateralValue_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).collateralToken,\\n LibLoans.loan(loanID).lendingToken,\\n collateralAmount\\n );\\n reward_ += collateralValue_;\\n }\\n\\n // Calculate loan escrow value if collateral not enough to cover reward\\n if (reward_ < maxReward) {\\n reward_ += LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n // Cap the reward to max\\n if (reward_ > maxReward) {\\n reward_ = maxReward;\\n }\\n }\\n\\n /**\\n * @notice Checks if the loan has an Escrow and claims any tokens then pays out the loan collateral.\\n * @dev See Escrow.claimTokens for more info.\\n * @param loanID The loan ID which is being liquidated\\n * @param rewardInLending The total amount of reward based in the lending token to pay the liquidator\\n * @param collateralInLending The amount of collateral that is available for the loan denoted in lending tokens\\n * @param collateralAmount The amount of collateral that is available for the loan\\n * @param liquidator The address of the liquidator where the liquidation reward will be sent to\\n */\\n function payOutLiquidator(\\n uint256 loanID,\\n uint256 rewardInLending,\\n uint256 collateralInLending,\\n uint256 collateralAmount,\\n address payable liquidator\\n ) internal {\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Liquidated,\\n \\\"Teller: loan not liquidated\\\"\\n );\\n\\n if (rewardInLending <= collateralInLending) {\\n uint256 rewardInCollateral =\\n PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n rewardInLending\\n );\\n\\n LibCollateral.withdraw(loanID, rewardInCollateral, liquidator);\\n } else {\\n // Payout whats available in the collateral token\\n LibCollateral.withdraw(loanID, collateralAmount, liquidator);\\n\\n // Claim remaining reward value from the loan escrow\\n claimEscrowTokensByValue(\\n loanID,\\n liquidator,\\n rewardInLending - collateralInLending\\n );\\n }\\n }\\n\\n /**\\n * @dev Send the equivalent of tokens owned by the loan escrow (in lending value) to the recipient,\\n * @param loanID The loan ID to clam tokens from\\n * @param recipient address to send the tokens to\\n * @param value The value of escrow held tokens to be claimed based in lending value\\n */\\n function claimEscrowTokensByValue(\\n uint256 loanID,\\n address recipient,\\n uint256 value\\n ) private {\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n uint256 valueLeftToTransfer = value;\\n\\n // Start with the lending token\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n LibLoans.loan(loanID).lendingToken,\\n recipient,\\n valueLeftToTransfer\\n );\\n\\n // Cycle through remaining tokens\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n if (valueLeftToTransfer == 0) {\\n return;\\n }\\n\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n EnumerableSet.at(tokens, i),\\n recipient,\\n valueLeftToTransfer\\n );\\n }\\n }\\n\\n function claimEscrowToken(\\n uint256 loanID,\\n address token,\\n address recipient,\\n uint256 valueLeftToTransfer\\n ) private returns (uint256) {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n // get value of token balance in lending value\\n if (balance > 0) {\\n // If token not the lending token, get value of token\\n uint256 balanceInLending;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n balanceInLending = balance;\\n } else {\\n balanceInLending = PriceAggLib.valueFor(\\n token,\\n LibLoans.loan(loanID).lendingToken,\\n balance\\n );\\n }\\n\\n if (balanceInLending <= valueLeftToTransfer) {\\n LibEscrow.e(loanID).claimToken(token, recipient, balance);\\n valueLeftToTransfer -= balanceInLending;\\n } else {\\n // Token balance is more than enough so calculate ratio of balance to transfer\\n uint256 valueToTransfer;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n valueToTransfer = valueLeftToTransfer;\\n } else {\\n valueToTransfer = NumbersLib.percent(\\n balanceInLending,\\n NumbersLib.ratioOf(\\n valueLeftToTransfer,\\n balanceInLending\\n )\\n );\\n }\\n\\n LibEscrow.e(loanID).claimToken(\\n token,\\n recipient,\\n valueToTransfer\\n );\\n valueLeftToTransfer = 0;\\n }\\n }\\n\\n return valueLeftToTransfer;\\n }\\n}\\n\",\"keccak256\":\"0xd48f89e3810bf8847385c6bb0f7d50244582997d808a52d888d77cbe50d55d8d\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n function init(address tokenAddress, bool isWETH) external;\\n\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x3c83593b5521e85c7f62076b41869cd5a762b34523ac39fc23b4ea1b9042aa59\",\"license\":\"MIT\"},\"contracts/market/libraries/LibCollateral.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport { ICollateralEscrow } from \\\"../collateral/ICollateralEscrow.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\nimport { MarketStorageLib } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibCollateral {\\n /**\\n * @notice This event is emitted when collateral has been deposited for the loan\\n * @param loanID ID of the loan for which collateral was deposited\\n * @param depositor Account that deposited funds\\n * @param amount Amount of collateral deposited\\n */\\n event CollateralDeposited(\\n uint256 indexed loanID,\\n address indexed depositor,\\n uint256 amount\\n );\\n\\n /**\\n * @notice This event is emitted when collateral has been withdrawn\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param receiver Account that received funds\\n * @param amount Value of collateral withdrawn\\n */\\n event CollateralWithdrawn(\\n uint256 indexed loanID,\\n address indexed receiver,\\n uint256 amount\\n );\\n\\n function e(uint256 loanID) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[\\n MarketStorageLib.store().loans[loanID].collateralToken\\n ];\\n }\\n\\n function e(address token) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[token];\\n }\\n\\n function deposit(uint256 loanID, uint256 amount) internal {\\n e(loanID).deposit{ value: amount }(loanID, amount);\\n\\n emit CollateralDeposited(loanID, msg.sender, amount);\\n }\\n\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) internal {\\n e(loanID).withdraw(loanID, amount, receiver);\\n\\n emit CollateralWithdrawn(loanID, receiver, amount);\\n }\\n\\n function withdrawAll(uint256 loanID, address payable receiver) internal {\\n withdraw(loanID, e(loanID).loanSupply(loanID), receiver);\\n }\\n\\n function createEscrow(address token) internal {\\n // Check if collateral escrow exists\\n if (address(e(token)) == address(0)) {\\n // Create escrow\\n address escrow =\\n AppStorageLib.store().collateralEscrowBeacon.cloneProxy(\\\"\\\");\\n ICollateralEscrow(escrow).init(\\n token,\\n // Check if collateral token is WETH\\n token == AppStorageLib.store().assetAddresses[\\\"WETH\\\"]\\n );\\n\\n // Set max allowance\\n IERC20(token).approve(escrow, type(uint256).max);\\n // Save escrow address for loan\\n MarketStorageLib.store().collateralEscrows[\\n token\\n ] = ICollateralEscrow(escrow);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd52b3e577480481b62d6a6c37f4ef596b7ec0120afbd6bc1a08b17923b926445\",\"license\":\"MIT\"},\"contracts/market/libraries/LibLoans.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibEscrow } from \\\"../../escrow/libraries/LibEscrow.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus,\\n LoanDebt,\\n LoanTerms\\n} from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibLoans {\\n using NumbersLib for int256;\\n using NumbersLib for uint256;\\n\\n bytes32 internal constant ID = keccak256(\\\"LOANS\\\");\\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\\n l_ = s().loans[loanID];\\n }\\n\\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\\n d_ = s().loanDebt[loanID];\\n }\\n\\n function terms(uint256 loanID)\\n internal\\n view\\n returns (LoanTerms storage t_)\\n {\\n t_ = s().loanTerms[loanID];\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) internal view returns (uint256) {\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n uint256 interestOwed =\\n getInterestOwedFor(loanID, terms(loanID).maxLoanAmount);\\n return terms(loanID).maxLoanAmount + (interestOwed);\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n return debt(loanID).principalOwed + (debt(loanID).interestOwed);\\n }\\n return 0;\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n internal\\n view\\n returns (uint256)\\n {\\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\\n }\\n\\n function getCollateralNeededInfo(uint256 loanID)\\n internal\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\\n loanID\\n );\\n\\n if (neededInLendingTokens == 0) {\\n neededInCollateralTokens = 0;\\n } else {\\n neededInCollateralTokens = PriceAggLib.valueFor(\\n loan(loanID).lendingToken,\\n loan(loanID).collateralToken,\\n neededInLendingTokens\\n );\\n }\\n }\\n\\n /**\\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\\n * @param loanID The loan ID to get needed collateral info for.\\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\\n */\\n function getCollateralNeededInTokens(uint256 loanID)\\n internal\\n view\\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\\n {\\n if (!_isActiveOrSet(loanID) || loan(loanID).collateralRatio == 0) {\\n return (0, 0);\\n }\\n\\n /*\\n The collateral to principal owed ratio is the sum of:\\n * collateral buffer percent\\n * loan interest rate\\n * liquidation reward percent\\n * X factor of additional collateral\\n */\\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n neededInLendingTokens = _getLoanAmount(loanID).percent(\\n loan(loanID).collateralRatio\\n );\\n } else {\\n uint16 requiredRatio =\\n loan(loanID).collateralRatio -\\n getInterestRatio(loanID) -\\n uint16(PlatformSettingsLib.getCollateralBufferValue());\\n\\n neededInLendingTokens =\\n debt(loanID).principalOwed +\\n debt(loanID).interestOwed;\\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\\n if (\\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\\n ) {\\n neededInLendingTokens -= escrowLoanValue;\\n }\\n neededInLendingTokens = neededInLendingTokens.percent(\\n requiredRatio\\n );\\n }\\n }\\n\\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\\n internal\\n view\\n returns (bool)\\n {\\n return\\n collateralRatio >=\\n PlatformSettingsLib.getOverCollateralizedBufferValue();\\n }\\n\\n /**\\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\\n * @notice There is a minimum threshold of 1%.\\n * @dev The interest rate on the loan terms is APY.\\n * @param loanID The loan ID to get the interest rate for.\\n */\\n function getInterestRatio(uint256 loanID)\\n internal\\n view\\n returns (uint16 ratio_)\\n {\\n ratio_ = uint16(\\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\\n SECONDS_PER_YEAR\\n );\\n\\n if (ratio_ == 0) {\\n ratio_ = 1;\\n }\\n }\\n\\n function _getLoanAmount(uint256 loanID) private view returns (uint256) {\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n return terms(loanID).maxLoanAmount;\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n return loan(loanID).borrowedAmount;\\n }\\n return 0;\\n }\\n\\n function _isActiveOrSet(uint256 loanID) private view returns (bool) {\\n LoanStatus status = loan(loanID).status;\\n return status == LoanStatus.Active || status == LoanStatus.TermsSet;\\n }\\n}\\n\",\"keccak256\":\"0x9bf9fae5b01110da7c5a5d2517fdea6aa880d5c1647ba6125c68cafad278499b\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x7c788b94c175b70eec6b10bfe0655616fc0beb2ce3ef70a6fa750f291d35106c\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}.\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x39fd6d70fd1aa5ae45465d7eeb38f74e2bf90535c2510782fb0bb5f720250ac5\",\"license\":\"MIT\"},\"contracts/nft/libraries/NFTLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../TellerNFT.sol\\\";\\n\\n// Libraries\\nimport {\\n MerkleProof\\n} from \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\nimport { NFTStorageLib, NFTStorage } from \\\"../../storage/nft.sol\\\";\\n\\nstruct NftLoanSizeProof {\\n uint256 id;\\n uint256 baseLoanSize;\\n bytes32[] proof;\\n}\\n\\nlibrary NFTLib {\\n function s() internal pure returns (NFTStorage storage s_) {\\n s_ = NFTStorageLib.store();\\n }\\n\\n function nft() internal view returns (TellerNFT nft_) {\\n nft_ = AppStorageLib.store().nft;\\n }\\n\\n function stake(uint256 nftID, address owner) internal {\\n // Transfer to diamond\\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\\n // Add NFT ID to user set\\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\\n }\\n\\n function unstake(uint256 nftID) internal returns (bool success_) {\\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\\n }\\n\\n function stakedNFTs(address nftOwner)\\n internal\\n view\\n returns (uint256[] memory staked_)\\n {\\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\\n staked_ = new uint256[](EnumerableSet.length(nfts));\\n for (uint256 i; i < staked_.length; i++) {\\n staked_[i] = EnumerableSet.at(nfts, i);\\n }\\n }\\n\\n function liquidateNFT(uint256 loanID) internal {\\n // Check if NFTs are linked\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n NFTLib.nft().transferFrom(\\n address(this),\\n AppStorageLib.store().nftLiquidationController,\\n EnumerableSet.at(nfts, i)\\n );\\n }\\n }\\n\\n function applyToLoan(uint256 loanID, NftLoanSizeProof calldata proof)\\n internal\\n {\\n // NFT must be currently staked\\n // Remove NFT from being staked - returns bool\\n require(unstake(proof.id), \\\"Teller: borrower nft not staked\\\");\\n\\n require(verifyLoanSize(proof), \\\"Teller invalid nft proof\\\");\\n\\n // Apply NFT to loan\\n EnumerableSet.add(s().loanNFTs[loanID], proof.id);\\n }\\n\\n function restakeLinked(uint256 loanID, address owner) internal {\\n // Get linked NFT\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n // Restake the NFT\\n stake(EnumerableSet.at(nfts, i), owner);\\n }\\n }\\n\\n function verifyLoanSize(NftLoanSizeProof calldata proof)\\n internal\\n view\\n returns (bool verified_)\\n {\\n verified_ = MerkleProof.verify(\\n proof.proof,\\n s().nftMerkleRoot,\\n keccak256(abi.encodePacked(proof.id, proof.baseLoanSize))\\n );\\n }\\n}\\n\",\"keccak256\":\"0xb063eb66af8d3844af1125125ac2629ee0225b20209e3464d560ebe1b3d3d407\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @dev It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @dev Tries to calculate a price from Compound and Chainlink.\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @dev Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @dev Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @dev Scales the {value} by the difference in decimal values.\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @dev Tries to calculate the price of {src} in {dst}\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address WETH = AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n if (dst != WETH) {\\n int256 price1 = _priceFor(src, WETH);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, WETH);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf84fd8d9a179ca7a70e75677870bdd7a5be7da097cf5f1bccf1c9f93253bda90\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { PriceAggFacet } from \\\"./PriceAggFacet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\n/**\\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\\n */\\nlibrary PriceAggLib {\\n /**\\n * @notice See {PriceAggFacet.getValueFor}\\n */\\n function valueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) internal view returns (uint256 value_) {\\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\\n }\\n\\n /**\\n * @notice See {PriceAggFacet.getPriceFor}\\n */\\n function priceFor(address src, address dst)\\n internal\\n view\\n returns (int256 price_)\\n {\\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\\n }\\n}\\n\",\"keccak256\":\"0x510633e39e7a30533d703eb7ec314c037772721fdb7cea96046cd6837bcb76c3\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\nabstract contract PausableMods {\\n /**\\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\\n * @param id id of the facet to check if is paused.\\n * @param state Boolean that the protocol AND facet should be in.\\n */\\n modifier paused(bytes32 id, bool state) {\\n require(\\n __isPaused(\\\"\\\") == state && __isPaused(id) == state,\\n __pausedMessage(state)\\n );\\n _;\\n }\\n\\n /**\\n * @dev Checks if the given id is paused.\\n * @param id Encoded id of the facet to check if is paused.\\n */\\n function __isPaused(bytes32 id) private view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n\\n /**\\n * @dev Gets the message that should be reverted with given a state it should be in.\\n * @param state Boolean that an id should be in.\\n */\\n function __pausedMessage(bool state) private pure returns (string memory) {\\n return state ? \\\"Pausable: not paused\\\" : \\\"Pausable: paused\\\";\\n }\\n}\\n\",\"keccak256\":\"0x772d8b9b63e9b8e78f243a70988f1a1e1100272cf317259ea173829f7b9bdf0e\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0xbeef1937dc1ed1f6f78b80f0737f018565ab264184cf05ef54c3c28ecd55a09b\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xacf6bcb8c4afd2f337a0161e8be64b016c1b350d336cd862245dd922fcd10f33\",\"license\":\"MIT\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n function claimComp(address holder) external;\\n\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x495d8bb746a524fea6ddc4286c955d7a0160718bf662456330a9d6d14b8a5da9\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n\\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x208769886b3db8f03ef1fa26f1caee189038dfc744b9a499402fc4e4c0090c38\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4d9045666e86d675f7bd48202f9a77d0675fa20b2184131ad369710ac5eb3203\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @notice CETH is the only Compound token that does not support the {underlying} function.\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x14e96659912e9d03ae30732faca8e3d617f3e756a215d948cabedab6642c1465\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0x998aefaf4edbe7b0cb41032750b65b3822b4bec0fec3ee5b396f8fb73b5e9e03\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0x8919fcdfb49018474c872c462c11b21a50faa7ab80f0162abd6b657cbbc5d04c\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x0888cf40ea019be9f0ee94cb8af1e030454c28f8c6512db9d89ed027fe21f18f\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n bool initialized;\\n bool platformRestricted;\\n mapping(bytes32 => bool) paused;\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0xade1dda8163fc39658e5f6929b662187584b29cce47e9cb0915fc0d1832fb4f7\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) loanTerms;\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5f3fdba19ae8040e2007affe422527b7dca58ba424df33ba4dd9cb08d83d00de\",\"license\":\"MIT\"},\"contracts/storage/nft.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Utils\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct NFTStorage {\\n // Maps NFT owner to set of token IDs owned\\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\\n // Maps loanID to NFT IDs indicating NFT being used for the loan\\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\\n // Merkle root used for verifying nft IDs to base loan size\\n bytes32 nftMerkleRoot;\\n}\\n\\nbytes32 constant NFT_STORAGE_POS = keccak256(\\\"teller.staking.storage\\\");\\n\\nlibrary NFTStorageLib {\\n function store() internal pure returns (NFTStorage storage s) {\\n bytes32 pos = NFT_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x8d58bb6ba00310d8c3d89b95c62e5c997430a1124d73224897f7d9b2a43ab50a\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "params": { + "borrower": "Account address of the borrower", + "liquidator": "Account address of the liquidator", + "loanID": "ID of loan from which collateral was withdrawn", + "reward": "Value in lending token paid out to liquidator", + "tokensIn": "Percentage of the collateral price paid by the liquidator to the lending pool" + } + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "params": { + "amountPaid": "Amount of the loan paid back", + "borrower": "Account address of the borrower", + "loanID": "ID of loan from which collateral was withdrawn", + "payer": "Account address of the payer", + "totalOwed": "Total amount of the loan to be repaid" + } + } + }, + "kind": "dev", + "methods": { + "escrowRepay(uint256,uint256)": { + "details": "If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.", + "params": { + "amount": "The amount being repaid.", + "loanID": "The id of the loan being used." + } + }, + "getLiquidationReward(uint256)": { + "params": { + "loanID": "The loan ID to get the info." + }, + "returns": { + "inCollateral_": "The value the liquidator will receive denoted in collateral tokens.", + "inLending_": "The value the liquidator will receive denoted in lending tokens." + } + }, + "liquidateLoan(uint256)": { + "params": { + "loanID": "The ID of the loan to be liquidated" + } + }, + "repayLoan(uint256,uint256)": { + "params": { + "amount": "The amount of tokens to pay back to the loan", + "loanID": "The ID of the loan the payment is for" + } + } + }, + "version": 1 + }, + "userdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "notice": "This event is emitted when a loan has been successfully liquidated" + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "notice": "This event is emitted when a loan has been successfully repaid" + } + }, + "kind": "user", + "methods": { + "escrowRepay(uint256,uint256)": { + "notice": "Repay this Escrow's loan." + }, + "getLiquidationReward(uint256)": { + "notice": "It gets the current liquidation reward for a given loan." + }, + "liquidateLoan(uint256)": { + "notice": "Liquidate a loan if it is expired or under collateralized" + }, + "repayLoan(uint256,uint256)": { + "notice": "Make a payment to a loan" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0x1843F635aE17eae7763b14C02E0288DAC806A680", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "RepayFacet", + "transactionHash": "0x6e39fece8c7daa41cb1d0aebe98e337ee928cc825c47062ed4be64c95c5b6f2a", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x1843F635aE17eae7763b14C02E0288DAC806A680", + "transactionIndex": 138, + "gasUsed": "1838004", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xc09715a46d9abff24cf1b272a8b49e01801c095bf806999527124405ef2b06cb", + "transactionHash": "0x6e39fece8c7daa41cb1d0aebe98e337ee928cc825c47062ed4be64c95c5b6f2a", + "logs": [], + "blockNumber": 12451269, + "cumulativeGasUsed": "5998051", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "eafd179d066c5157135a6ef7437993d7", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"liquidator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"reward\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokensIn\",\"type\":\"uint256\"}],\"name\":\"LoanLiquidated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountPaid\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"totalOwed\",\"type\":\"uint256\"}],\"name\":\"LoanRepaid\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"escrowRepay\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLiquidationReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"inLending_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"inCollateral_\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"liquidateLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"repayLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"params\":{\"borrower\":\"Account address of the borrower\",\"liquidator\":\"Account address of the liquidator\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"reward\":\"Value in lending token paid out to liquidator\",\"tokensIn\":\"Percentage of the collateral price paid by the liquidator to the lending pool\"}},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"params\":{\"amountPaid\":\"Amount of the loan paid back\",\"borrower\":\"Account address of the borrower\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"payer\":\"Account address of the payer\",\"totalOwed\":\"Total amount of the loan to be repaid\"}}},\"kind\":\"dev\",\"methods\":{\"escrowRepay(uint256,uint256)\":{\"details\":\"If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\",\"params\":{\"amount\":\"The amount being repaid.\",\"loanID\":\"The id of the loan being used.\"}},\"getLiquidationReward(uint256)\":{\"params\":{\"loanID\":\"The loan ID to get the info.\"},\"returns\":{\"inCollateral_\":\"The value the liquidator will receive denoted in collateral tokens.\",\"inLending_\":\"The value the liquidator will receive denoted in lending tokens.\"}},\"liquidateLoan(uint256)\":{\"params\":{\"loanID\":\"The ID of the loan to be liquidated\"}},\"repayLoan(uint256,uint256)\":{\"params\":{\"amount\":\"The amount of tokens to pay back to the loan\",\"loanID\":\"The ID of the loan the payment is for\"}}},\"version\":1},\"userdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully liquidated\"},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully repaid\"}},\"kind\":\"user\",\"methods\":{\"escrowRepay(uint256,uint256)\":{\"notice\":\"Repay this Escrow's loan.\"},\"getLiquidationReward(uint256)\":{\"notice\":\"It gets the current liquidation reward for a given loan.\"},\"liquidateLoan(uint256)\":{\"notice\":\"Liquidate a loan if it is expired or under collateralized\"},\"repayLoan(uint256,uint256)\":{\"notice\":\"Make a payment to a loan\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/market/RepayFacet.sol\":\"RepayFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Trees proofs.\\n *\\n * The proofs can be generated using the JavaScript library\\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\\n *\\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n bytes32 computedHash = leaf;\\n\\n for (uint256 i = 0; i < proof.length; i++) {\\n bytes32 proofElement = proof[i];\\n\\n if (computedHash <= proofElement) {\\n // Hash(current computed hash + current element of the proof)\\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\\n } else {\\n // Hash(current element of the proof + current computed hash)\\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\\n }\\n }\\n\\n // Check if the computed hash (root) is equal to the provided root\\n return computedHash == root;\\n }\\n}\\n\",\"keccak256\":\"0xeee34bfb413657b6cd6c8e1e15c2080ba5ebaac479578515922804346fb63f7c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/reentry/ReentryMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nabstract contract ReentryMods {\\n modifier nonReentry(bytes32 id) {\\n AccessControlStorage storage s = AccessControlStorageLib.store();\\n require(!s.entered[id], \\\"AccessControl: reentered\\\");\\n s.entered[id] = true;\\n _;\\n s.entered[id] = false;\\n }\\n}\\n\",\"keccak256\":\"0x033c1164af25ef7d35a38a60973bf379b1cc603596914ffd85dcbcf0acdb6970\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../interfaces/IAToken.sol\\\";\\nimport { IAaveLendingPool } from \\\"../interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x8030b206c87d0073fb7dbebfa2ee8a3e93c479d976d6cdaa0c939f2fedaa1525\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n function setTokenAllowance(address token, address spender) external;\\n\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xdaa338698014e6c00edf7a2aca49026a047e253cbe7fc392a73f5f63a063a7f9\",\"license\":\"MIT\"},\"contracts/escrow/libraries/LibEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibDapps } from \\\"../dapps/libraries/LibDapps.sol\\\";\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibEscrow {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\\n e_ = s().loanEscrows[loanID];\\n }\\n\\n function getEscrowTokens(uint256 loanID)\\n internal\\n view\\n returns (EnumerableSet.AddressSet storage t_)\\n {\\n t_ = s().escrowTokens[loanID];\\n }\\n\\n function balanceOf(uint256 loanID, address token)\\n internal\\n view\\n returns (uint256)\\n {\\n return IERC20(token).balanceOf(address(e(loanID)));\\n }\\n\\n /**\\n * @notice Adds or removes tokens held by the Escrow contract\\n * @param loanID The loan ID to update the token list for\\n * @param tokenAddress The token address to be added or removed\\n */\\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\\n // Skip if is lending token\\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\\n\\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\\n if (balanceOf(loanID, tokenAddress) > 0) {\\n if (!contains) {\\n EnumerableSet.add(tokens, tokenAddress);\\n }\\n } else if (contains) {\\n EnumerableSet.remove(tokens, tokenAddress);\\n }\\n }\\n\\n /**\\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\\n * @param loanID The loan ID to calculate value for\\n * @return value_ Escrow total value denoted in the lending token.\\n */\\n function calculateTotalValue(uint256 loanID)\\n internal\\n view\\n returns (uint256 value_)\\n {\\n address lendingToken = LibLoans.loan(loanID).lendingToken;\\n value_ += balanceOf(loanID, lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\\n if (EnumerableSet.length(tokens) > 0) {\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n uint256 tokenBal =\\n balanceOf(loanID, EnumerableSet.at(tokens, i));\\n value_ += PriceAggLib.valueFor(\\n EnumerableSet.at(tokens, i),\\n lendingToken,\\n tokenBal\\n );\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xcca97599fff1c1bd608e7f11c4674f325e43781794e91bf5322ac9e0ffd7b3df\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when an user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when an user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @return totalSupply_ The total value of the underlying token managed by the LP.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given markets.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider o the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfil the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n */\\n function restrict(bool state) external virtual;\\n\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xe6515c78e0277edbed82aa6926df727afd216379dd0bfbbb790222654c858499\",\"license\":\"MIT\"},\"contracts/market/LoanDataFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { Loan, LoanDebt, LoanTerms } from \\\"../storage/market.sol\\\";\\n\\ncontract LoanDataFacet {\\n /**\\n * @notice Returns the information about the given {loanID}.\\n * @param loanID The loan ID to get information for.\\n * @return loan_ The loan data.\\n */\\n function getLoan(uint256 loanID) external view returns (Loan memory loan_) {\\n loan_ = LibLoans.s().loans[loanID];\\n }\\n\\n /**\\n * @notice Returns the terms for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanTerms The terms that the loan weer created with.\\n */\\n function getLoanTerms(uint256 loanID)\\n external\\n view\\n returns (LoanTerms memory)\\n {\\n return LibLoans.terms(loanID);\\n }\\n\\n /**\\n * @notice Returns the loan IDs created by the {borrower} account.\\n * @param borrower The account to get loan IDs for.\\n * @return loanIDs The IDs for loans created by the {borrower}\\n */\\n function getBorrowerLoans(address borrower)\\n external\\n view\\n returns (uint128[] memory loanIDs)\\n {\\n return LibLoans.s().borrowerLoans[borrower];\\n }\\n\\n /**\\n * @notice Returns the debt owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanDebt The principal and interest owed amount.\\n */\\n function getDebtOwed(uint256 loanID)\\n external\\n view\\n returns (LoanDebt memory)\\n {\\n return LibLoans.debt(loanID);\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) external view returns (uint256) {\\n return LibLoans.getTotalOwed(loanID);\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n external\\n view\\n returns (uint256)\\n {\\n return LibLoans.getInterestOwedFor(loanID, amountBorrow);\\n }\\n\\n function getCollateralNeededInfo(uint256 loanID)\\n external\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n return LibLoans.getCollateralNeededInfo(loanID);\\n }\\n\\n function getLoanEscrow(uint256 loanID)\\n external\\n view\\n returns (address escrow_)\\n {\\n escrow_ = address(LibLoans.s().loanEscrows[loanID]);\\n }\\n\\n function getLoanEscrowValue(uint256 loanID)\\n external\\n view\\n returns (uint256)\\n {\\n return LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n function getEscrowTokens(uint256 loanID)\\n external\\n view\\n returns (address[] memory tokens_)\\n {\\n EnumerableSet.AddressSet storage escrowTokens =\\n LibEscrow.getEscrowTokens(loanID);\\n tokens_ = new address[](EnumerableSet.length(escrowTokens));\\n for (uint256 i; i < tokens_.length; i++) {\\n tokens_[i] = EnumerableSet.at(escrowTokens, i);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf589a2afff647e5288e15f3f6614135395562b4d12c743402a6504a3fb9b39d6\",\"license\":\"MIT\"},\"contracts/market/RepayFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\nimport {\\n ReentryMods\\n} from \\\"../contexts2/access-control/reentry/ReentryMods.sol\\\";\\nimport { AUTHORIZED } from \\\"../shared/roles.sol\\\";\\nimport { LoanDataFacet } from \\\"./LoanDataFacet.sol\\\";\\n\\n// Libraries\\nimport {\\n IERC20,\\n SafeERC20\\n} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibCollateral } from \\\"./libraries/LibCollateral.sol\\\";\\nimport { LibDapps } from \\\"../escrow/dapps/libraries/LibDapps.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { NumbersLib } from \\\"../shared/libraries/NumbersLib.sol\\\";\\nimport { PriceAggLib } from \\\"../price-aggregator/PriceAggLib.sol\\\";\\nimport { NFTLib } from \\\"../nft/libraries/NFTLib.sol\\\";\\n\\n// Interfaces\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus\\n} from \\\"../storage/market.sol\\\";\\n\\ncontract RepayFacet is RolesMods, ReentryMods, PausableMods {\\n /**\\n @notice This event is emitted when a loan has been successfully repaid\\n @param loanID ID of loan from which collateral was withdrawn\\n @param borrower Account address of the borrower\\n @param amountPaid Amount of the loan paid back\\n @param payer Account address of the payer\\n @param totalOwed Total amount of the loan to be repaid\\n */\\n event LoanRepaid(\\n uint256 indexed loanID,\\n address indexed borrower,\\n uint256 amountPaid,\\n address payer,\\n uint256 totalOwed\\n );\\n\\n /**\\n * @notice This event is emitted when a loan has been successfully liquidated\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param borrower Account address of the borrower\\n * @param liquidator Account address of the liquidator\\n * @param reward Value in lending token paid out to liquidator\\n * @param tokensIn Percentage of the collateral price paid by the liquidator to the lending pool\\n */\\n event LoanLiquidated(\\n uint256 indexed loanID,\\n address indexed borrower,\\n address liquidator,\\n uint256 reward,\\n uint256 tokensIn\\n );\\n\\n /**\\n * @notice Repay this Escrow's loan.\\n * @dev If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.\\n * @dev Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\\n * @param loanID The id of the loan being used.\\n * @param amount The amount being repaid.\\n */\\n function escrowRepay(uint256 loanID, uint256 amount)\\n external\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n nonReentry(\\\"\\\")\\n {\\n uint256 balance =\\n LibEscrow.balanceOf(loanID, LibLoans.loan(loanID).lendingToken);\\n uint256 totalOwed = LibLoans.getTotalOwed(loanID);\\n if (balance < totalOwed && amount > balance) {\\n uint256 amountNeeded =\\n amount > totalOwed ? totalOwed - (balance) : amount - (balance);\\n\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n msg.sender,\\n address(LibEscrow.e(loanID)),\\n amountNeeded\\n );\\n }\\n\\n __repayLoan(loanID, amount, address(LibEscrow.e(loanID)), false);\\n }\\n\\n /**\\n * @notice Make a payment to a loan\\n * @param loanID The ID of the loan the payment is for\\n * @param amount The amount of tokens to pay back to the loan\\n */\\n function repayLoan(uint256 loanID, uint256 amount)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n __repayLoan(loanID, amount, msg.sender, false);\\n }\\n\\n function __repayLoan(\\n uint256 loanID,\\n uint256 amount,\\n address sender,\\n bool isLiquidation\\n ) private returns (uint256 leftToPay_) {\\n require(amount > 0, \\\"Teller: zero repay\\\");\\n\\n // calculate the actual amount to repay\\n leftToPay_ =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n if (leftToPay_ < amount) {\\n amount = leftToPay_;\\n leftToPay_ = 0;\\n } else {\\n leftToPay_ -= amount;\\n }\\n\\n // Get the Teller token for the loan\\n ITToken tToken =\\n MarketStorageLib.store().tTokens[\\n LibLoans.loan(loanID).lendingToken\\n ];\\n // Transfer funds from account\\n if (address(LibEscrow.e(loanID)) == sender) {\\n LibEscrow.e(loanID).claimToken(\\n LibLoans.loan(loanID).lendingToken,\\n address(tToken),\\n amount\\n );\\n } else {\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n sender,\\n address(tToken),\\n amount\\n );\\n }\\n\\n // Deduct the interest and principal owed\\n uint256 principalPaid;\\n uint256 interestPaid;\\n if (amount < LibLoans.debt(loanID).interestOwed) {\\n interestPaid = amount;\\n LibLoans.debt(loanID).interestOwed -= amount;\\n } else {\\n if (LibLoans.debt(loanID).interestOwed > 0) {\\n interestPaid = LibLoans.debt(loanID).interestOwed;\\n amount -= interestPaid;\\n LibLoans.debt(loanID).interestOwed = 0;\\n }\\n\\n if (amount > 0) {\\n principalPaid = amount;\\n LibLoans.debt(loanID).principalOwed -= amount;\\n }\\n }\\n\\n // Tell the Teller Token value has been deposited back into the pool.\\n tToken.repayLoan(principalPaid, interestPaid);\\n\\n if (isLiquidation) {\\n // Make sure there is nothing left to repay on the loan\\n require(leftToPay_ == 0, \\\"Teller: liquidate partial repay\\\");\\n\\n // Set loan status\\n LibLoans.loan(loanID).status = LoanStatus.Liquidated;\\n\\n // Transfer NFT if linked\\n NFTLib.liquidateNFT(loanID);\\n } else {\\n // if the loan is now fully paid, close it and withdraw borrower collateral\\n if (leftToPay_ == 0) {\\n LibLoans.loan(loanID).status = LoanStatus.Closed;\\n LibCollateral.withdrawAll(loanID, LibLoans.loan(loanID).borrower);\\n // Restake any NFTs linked to loan for borrower\\n NFTLib.restakeLinked(loanID, LibLoans.loan(loanID).borrower);\\n }\\n\\n emit LoanRepaid(\\n loanID,\\n LibLoans.loan(loanID).borrower,\\n amount,\\n msg.sender,\\n leftToPay_\\n );\\n }\\n }\\n\\n /**\\n * @notice Liquidate a loan if it is expired or under collateralized\\n * @param loanID The ID of the loan to be liquidated\\n */\\n function liquidateLoan(uint256 loanID)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n uint256 collateralAmount = LibCollateral.e(loanID).loanSupply(loanID);\\n require(\\n RepayLib.isLiquidable(loanID, collateralAmount),\\n \\\"Teller: does not need liquidation\\\"\\n );\\n\\n // Calculate the reward before repaying the loan\\n (uint256 rewardInLending, uint256 collateralInLending) =\\n RepayLib.getLiquidationReward(loanID, collateralAmount);\\n\\n // The liquidator pays the amount still owed on the loan\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n __repayLoan(loanID, amountToLiquidate, msg.sender, true);\\n\\n // Payout the liquidator reward owed\\n if (rewardInLending > 0) {\\n RepayLib.payOutLiquidator(\\n loanID,\\n rewardInLending,\\n collateralInLending,\\n collateralAmount,\\n payable(msg.sender)\\n );\\n }\\n\\n emit LoanLiquidated(\\n loanID,\\n loan.borrower,\\n msg.sender,\\n rewardInLending,\\n amountToLiquidate\\n );\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @return inLending_ The value the liquidator will receive denoted in lending tokens.\\n * @return inCollateral_ The value the liquidator will receive denoted in collateral tokens.\\n */\\n function getLiquidationReward(uint256 loanID)\\n external\\n view\\n returns (uint256 inLending_, uint256 inCollateral_)\\n {\\n (inLending_, ) = RepayLib.getLiquidationReward(\\n loanID,\\n LibCollateral.e(loanID).loanSupply(loanID)\\n );\\n inCollateral_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n inLending_\\n );\\n }\\n}\\n\\nlibrary RepayLib {\\n /**\\n * @notice It checks if a loan can be liquidated.\\n * @param loanID The loan ID to check.\\n * @return true if the loan is liquidable.\\n */\\n function isLiquidable(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (bool)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n // Check if loan can be liquidated\\n if (loan.status != LoanStatus.Active) {\\n return false;\\n }\\n\\n if (loan.collateralRatio > 0) {\\n // If loan has a collateral ratio, check how much is needed\\n (, uint256 neededInCollateral, ) =\\n LoanDataFacet(address(this)).getCollateralNeededInfo(loanID);\\n if (neededInCollateral > collateralAmount) {\\n return true;\\n }\\n }\\n\\n // Otherwise, check if the loan has expired\\n return block.timestamp >= loan.loanStartTime + loan.duration;\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @param collateralAmount The amount of collateral for the {loanID}. Passed in to save gas calling the collateral escrow multiple times.\\n * @return reward_ The value the liquidator will receive denoted in lending tokens.\\n */\\n function getLiquidationReward(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (uint256 reward_, uint256 collateralValue_)\\n {\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n // Max reward is amount repaid on loan plus extra percentage\\n uint256 maxReward =\\n amountToLiquidate +\\n NumbersLib.percent(\\n amountToLiquidate,\\n uint16(PlatformSettingsLib.getLiquidateRewardPercent())\\n );\\n\\n // Calculate available collateral for reward\\n if (collateralAmount > 0) {\\n collateralValue_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).collateralToken,\\n LibLoans.loan(loanID).lendingToken,\\n collateralAmount\\n );\\n reward_ += collateralValue_;\\n }\\n\\n // Calculate loan escrow value if collateral not enough to cover reward\\n if (reward_ < maxReward) {\\n reward_ += LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n // Cap the reward to max\\n if (reward_ > maxReward) {\\n reward_ = maxReward;\\n }\\n }\\n\\n /**\\n * @notice Checks if the loan has an Escrow and claims any tokens then pays out the loan collateral.\\n * @dev See Escrow.claimTokens for more info.\\n * @param loanID The loan ID which is being liquidated\\n * @param rewardInLending The total amount of reward based in the lending token to pay the liquidator\\n * @param collateralInLending The amount of collateral that is available for the loan denoted in lending tokens\\n * @param collateralAmount The amount of collateral that is available for the loan\\n * @param liquidator The address of the liquidator where the liquidation reward will be sent to\\n */\\n function payOutLiquidator(\\n uint256 loanID,\\n uint256 rewardInLending,\\n uint256 collateralInLending,\\n uint256 collateralAmount,\\n address payable liquidator\\n ) internal {\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Liquidated,\\n \\\"Teller: loan not liquidated\\\"\\n );\\n\\n if (rewardInLending <= collateralInLending) {\\n uint256 rewardInCollateral =\\n PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n rewardInLending\\n );\\n\\n LibCollateral.withdraw(loanID, rewardInCollateral, liquidator);\\n } else {\\n // Payout whats available in the collateral token\\n LibCollateral.withdraw(loanID, collateralAmount, liquidator);\\n\\n // Claim remaining reward value from the loan escrow\\n claimEscrowTokensByValue(\\n loanID,\\n liquidator,\\n rewardInLending - collateralInLending\\n );\\n }\\n }\\n\\n /**\\n * @dev Send the equivalent of tokens owned by the loan escrow (in lending value) to the recipient,\\n * @param loanID The loan ID to clam tokens from\\n * @param recipient address to send the tokens to\\n * @param value The value of escrow held tokens to be claimed based in lending value\\n */\\n function claimEscrowTokensByValue(\\n uint256 loanID,\\n address recipient,\\n uint256 value\\n ) private {\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n uint256 valueLeftToTransfer = value;\\n\\n // Start with the lending token\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n LibLoans.loan(loanID).lendingToken,\\n recipient,\\n valueLeftToTransfer\\n );\\n\\n // Cycle through remaining tokens\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n if (valueLeftToTransfer == 0) {\\n return;\\n }\\n\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n EnumerableSet.at(tokens, i),\\n recipient,\\n valueLeftToTransfer\\n );\\n }\\n }\\n\\n function claimEscrowToken(\\n uint256 loanID,\\n address token,\\n address recipient,\\n uint256 valueLeftToTransfer\\n ) private returns (uint256) {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n // get value of token balance in lending value\\n if (balance > 0) {\\n // If token not the lending token, get value of token\\n uint256 balanceInLending;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n balanceInLending = balance;\\n } else {\\n balanceInLending = PriceAggLib.valueFor(\\n token,\\n LibLoans.loan(loanID).lendingToken,\\n balance\\n );\\n }\\n\\n if (balanceInLending <= valueLeftToTransfer) {\\n LibEscrow.e(loanID).claimToken(token, recipient, balance);\\n valueLeftToTransfer -= balanceInLending;\\n } else {\\n // Token balance is more than enough so calculate ratio of balance to transfer\\n uint256 valueToTransfer;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n valueToTransfer = valueLeftToTransfer;\\n } else {\\n valueToTransfer = NumbersLib.percent(\\n balance,\\n NumbersLib.ratioOf(\\n valueLeftToTransfer,\\n balanceInLending\\n )\\n );\\n }\\n\\n LibEscrow.e(loanID).claimToken(\\n token,\\n recipient,\\n valueToTransfer\\n );\\n valueLeftToTransfer = 0;\\n }\\n }\\n\\n return valueLeftToTransfer;\\n }\\n}\\n\",\"keccak256\":\"0x049ab45abd77562d277c3290acb7c420dd6590aba988deb924805d64c2e2fa16\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n function init(address tokenAddress, bool isWETH) external;\\n\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x3c83593b5521e85c7f62076b41869cd5a762b34523ac39fc23b4ea1b9042aa59\",\"license\":\"MIT\"},\"contracts/market/libraries/LibCollateral.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport { ICollateralEscrow } from \\\"../collateral/ICollateralEscrow.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\nimport { MarketStorageLib } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibCollateral {\\n /**\\n * @notice This event is emitted when collateral has been deposited for the loan\\n * @param loanID ID of the loan for which collateral was deposited\\n * @param depositor Account that deposited funds\\n * @param amount Amount of collateral deposited\\n */\\n event CollateralDeposited(\\n uint256 indexed loanID,\\n address indexed depositor,\\n uint256 amount\\n );\\n\\n /**\\n * @notice This event is emitted when collateral has been withdrawn\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param receiver Account that received funds\\n * @param amount Value of collateral withdrawn\\n */\\n event CollateralWithdrawn(\\n uint256 indexed loanID,\\n address indexed receiver,\\n uint256 amount\\n );\\n\\n function e(uint256 loanID) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[\\n MarketStorageLib.store().loans[loanID].collateralToken\\n ];\\n }\\n\\n function e(address token) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[token];\\n }\\n\\n function deposit(uint256 loanID, uint256 amount) internal {\\n e(loanID).deposit{ value: amount }(loanID, amount);\\n\\n emit CollateralDeposited(loanID, msg.sender, amount);\\n }\\n\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) internal {\\n e(loanID).withdraw(loanID, amount, receiver);\\n\\n emit CollateralWithdrawn(loanID, receiver, amount);\\n }\\n\\n function withdrawAll(uint256 loanID, address payable receiver) internal {\\n withdraw(loanID, e(loanID).loanSupply(loanID), receiver);\\n }\\n\\n function createEscrow(address token) internal {\\n // Check if collateral escrow exists\\n if (address(e(token)) == address(0)) {\\n // Create escrow\\n address escrow =\\n AppStorageLib.store().collateralEscrowBeacon.cloneProxy(\\\"\\\");\\n ICollateralEscrow(escrow).init(\\n token,\\n // Check if collateral token is WETH\\n token == AppStorageLib.store().assetAddresses[\\\"WETH\\\"]\\n );\\n\\n // Set max allowance\\n IERC20(token).approve(escrow, type(uint256).max);\\n // Save escrow address for loan\\n MarketStorageLib.store().collateralEscrows[\\n token\\n ] = ICollateralEscrow(escrow);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd52b3e577480481b62d6a6c37f4ef596b7ec0120afbd6bc1a08b17923b926445\",\"license\":\"MIT\"},\"contracts/market/libraries/LibLoans.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibEscrow } from \\\"../../escrow/libraries/LibEscrow.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus,\\n LoanDebt,\\n LoanTerms\\n} from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibLoans {\\n using NumbersLib for int256;\\n using NumbersLib for uint256;\\n\\n bytes32 internal constant ID = keccak256(\\\"LOANS\\\");\\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\\n l_ = s().loans[loanID];\\n }\\n\\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\\n d_ = s().loanDebt[loanID];\\n }\\n\\n function terms(uint256 loanID)\\n internal\\n view\\n returns (LoanTerms storage t_)\\n {\\n t_ = s().loanTerms[loanID];\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) internal view returns (uint256) {\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n uint256 interestOwed =\\n getInterestOwedFor(loanID, terms(loanID).maxLoanAmount);\\n return terms(loanID).maxLoanAmount + (interestOwed);\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n return debt(loanID).principalOwed + (debt(loanID).interestOwed);\\n }\\n return 0;\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n internal\\n view\\n returns (uint256)\\n {\\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\\n }\\n\\n function getCollateralNeededInfo(uint256 loanID)\\n internal\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\\n loanID\\n );\\n\\n if (neededInLendingTokens == 0) {\\n neededInCollateralTokens = 0;\\n } else {\\n neededInCollateralTokens = PriceAggLib.valueFor(\\n loan(loanID).lendingToken,\\n loan(loanID).collateralToken,\\n neededInLendingTokens\\n );\\n }\\n }\\n\\n /**\\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\\n * @param loanID The loan ID to get needed collateral info for.\\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\\n */\\n function getCollateralNeededInTokens(uint256 loanID)\\n internal\\n view\\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\\n {\\n if (!_isActiveOrSet(loanID) || loan(loanID).collateralRatio == 0) {\\n return (0, 0);\\n }\\n\\n /*\\n The collateral to principal owed ratio is the sum of:\\n * collateral buffer percent\\n * loan interest rate\\n * liquidation reward percent\\n * X factor of additional collateral\\n */\\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n neededInLendingTokens = _getLoanAmount(loanID).percent(\\n loan(loanID).collateralRatio\\n );\\n } else {\\n uint16 requiredRatio =\\n loan(loanID).collateralRatio -\\n getInterestRatio(loanID) -\\n uint16(PlatformSettingsLib.getCollateralBufferValue());\\n\\n neededInLendingTokens =\\n debt(loanID).principalOwed +\\n debt(loanID).interestOwed;\\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\\n if (\\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\\n ) {\\n neededInLendingTokens -= escrowLoanValue;\\n }\\n neededInLendingTokens = neededInLendingTokens.percent(\\n requiredRatio\\n );\\n }\\n }\\n\\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\\n internal\\n view\\n returns (bool)\\n {\\n return\\n collateralRatio >=\\n PlatformSettingsLib.getOverCollateralizedBufferValue();\\n }\\n\\n /**\\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\\n * @notice There is a minimum threshold of 1%.\\n * @dev The interest rate on the loan terms is APY.\\n * @param loanID The loan ID to get the interest rate for.\\n */\\n function getInterestRatio(uint256 loanID)\\n internal\\n view\\n returns (uint16 ratio_)\\n {\\n ratio_ = uint16(\\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\\n SECONDS_PER_YEAR\\n );\\n\\n if (ratio_ == 0) {\\n ratio_ = 1;\\n }\\n }\\n\\n function _getLoanAmount(uint256 loanID) private view returns (uint256) {\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n return terms(loanID).maxLoanAmount;\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n return loan(loanID).borrowedAmount;\\n }\\n return 0;\\n }\\n\\n function _isActiveOrSet(uint256 loanID) private view returns (bool) {\\n LoanStatus status = loan(loanID).status;\\n return status == LoanStatus.Active || status == LoanStatus.TermsSet;\\n }\\n}\\n\",\"keccak256\":\"0x9bf9fae5b01110da7c5a5d2517fdea6aa880d5c1647ba6125c68cafad278499b\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x7c788b94c175b70eec6b10bfe0655616fc0beb2ce3ef70a6fa750f291d35106c\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}.\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x39fd6d70fd1aa5ae45465d7eeb38f74e2bf90535c2510782fb0bb5f720250ac5\",\"license\":\"MIT\"},\"contracts/nft/libraries/NFTLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../TellerNFT.sol\\\";\\n\\n// Libraries\\nimport {\\n MerkleProof\\n} from \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\nimport { NFTStorageLib, NFTStorage } from \\\"../../storage/nft.sol\\\";\\n\\nstruct NftLoanSizeProof {\\n uint256 id;\\n uint256 baseLoanSize;\\n bytes32[] proof;\\n}\\n\\nlibrary NFTLib {\\n function s() internal pure returns (NFTStorage storage s_) {\\n s_ = NFTStorageLib.store();\\n }\\n\\n function nft() internal view returns (TellerNFT nft_) {\\n nft_ = AppStorageLib.store().nft;\\n }\\n\\n function stake(uint256 nftID, address owner) internal {\\n // Transfer to diamond\\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\\n // Add NFT ID to user set\\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\\n }\\n\\n function unstake(uint256 nftID) internal returns (bool success_) {\\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\\n }\\n\\n function stakedNFTs(address nftOwner)\\n internal\\n view\\n returns (uint256[] memory staked_)\\n {\\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\\n staked_ = new uint256[](EnumerableSet.length(nfts));\\n for (uint256 i; i < staked_.length; i++) {\\n staked_[i] = EnumerableSet.at(nfts, i);\\n }\\n }\\n\\n function liquidateNFT(uint256 loanID) internal {\\n // Check if NFTs are linked\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n NFTLib.nft().transferFrom(\\n address(this),\\n AppStorageLib.store().nftLiquidationController,\\n EnumerableSet.at(nfts, i)\\n );\\n }\\n }\\n\\n function applyToLoan(uint256 loanID, NftLoanSizeProof calldata proof)\\n internal\\n {\\n // NFT must be currently staked\\n // Remove NFT from being staked - returns bool\\n require(unstake(proof.id), \\\"Teller: borrower nft not staked\\\");\\n\\n require(verifyLoanSize(proof), \\\"Teller invalid nft proof\\\");\\n\\n // Apply NFT to loan\\n EnumerableSet.add(s().loanNFTs[loanID], proof.id);\\n }\\n\\n function restakeLinked(uint256 loanID, address owner) internal {\\n // Get linked NFT\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n // Restake the NFT\\n EnumerableSet.add(s().stakedNFTs[owner], EnumerableSet.at(nfts, i));\\n }\\n }\\n\\n function verifyLoanSize(NftLoanSizeProof calldata proof)\\n internal\\n view\\n returns (bool verified_)\\n {\\n verified_ = MerkleProof.verify(\\n proof.proof,\\n s().nftMerkleRoot,\\n keccak256(abi.encodePacked(proof.id, proof.baseLoanSize))\\n );\\n }\\n}\\n\",\"keccak256\":\"0x99ba27095901d86a4d1e1b9ec3a603fbbf7c67ada2ccd11cd5ed0435e5c3c66d\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @dev It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @dev Tries to calculate a price from Compound and Chainlink.\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @dev Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @dev Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @dev Scales the {value} by the difference in decimal values.\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @dev Tries to calculate the price of {src} in {dst}\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address WETH = AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n if (dst != WETH) {\\n int256 price1 = _priceFor(src, WETH);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, WETH);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf84fd8d9a179ca7a70e75677870bdd7a5be7da097cf5f1bccf1c9f93253bda90\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { PriceAggFacet } from \\\"./PriceAggFacet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\n/**\\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\\n */\\nlibrary PriceAggLib {\\n /**\\n * @notice See {PriceAggFacet.getValueFor}\\n */\\n function valueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) internal view returns (uint256 value_) {\\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\\n }\\n\\n /**\\n * @notice See {PriceAggFacet.getPriceFor}\\n */\\n function priceFor(address src, address dst)\\n internal\\n view\\n returns (int256 price_)\\n {\\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\\n }\\n}\\n\",\"keccak256\":\"0x510633e39e7a30533d703eb7ec314c037772721fdb7cea96046cd6837bcb76c3\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\nabstract contract PausableMods {\\n /**\\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\\n * @param id id of the facet to check if is paused.\\n * @param state Boolean that the protocol AND facet should be in.\\n */\\n modifier paused(bytes32 id, bool state) {\\n require(\\n __isPaused(\\\"\\\") == state && __isPaused(id) == state,\\n __pausedMessage(state)\\n );\\n _;\\n }\\n\\n /**\\n * @dev Checks if the given id is paused.\\n * @param id Encoded id of the facet to check if is paused.\\n */\\n function __isPaused(bytes32 id) private view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n\\n /**\\n * @dev Gets the message that should be reverted with given a state it should be in.\\n * @param state Boolean that an id should be in.\\n */\\n function __pausedMessage(bool state) private pure returns (string memory) {\\n return state ? \\\"Pausable: not paused\\\" : \\\"Pausable: paused\\\";\\n }\\n}\\n\",\"keccak256\":\"0x772d8b9b63e9b8e78f243a70988f1a1e1100272cf317259ea173829f7b9bdf0e\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0xbeef1937dc1ed1f6f78b80f0737f018565ab264184cf05ef54c3c28ecd55a09b\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xacf6bcb8c4afd2f337a0161e8be64b016c1b350d336cd862245dd922fcd10f33\",\"license\":\"MIT\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n function claimComp(address holder) external;\\n\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x495d8bb746a524fea6ddc4286c955d7a0160718bf662456330a9d6d14b8a5da9\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n\\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x208769886b3db8f03ef1fa26f1caee189038dfc744b9a499402fc4e4c0090c38\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4d9045666e86d675f7bd48202f9a77d0675fa20b2184131ad369710ac5eb3203\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @notice CETH is the only Compound token that does not support the {underlying} function.\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x14e96659912e9d03ae30732faca8e3d617f3e756a215d948cabedab6642c1465\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0x998aefaf4edbe7b0cb41032750b65b3822b4bec0fec3ee5b396f8fb73b5e9e03\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0x8919fcdfb49018474c872c462c11b21a50faa7ab80f0162abd6b657cbbc5d04c\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x0888cf40ea019be9f0ee94cb8af1e030454c28f8c6512db9d89ed027fe21f18f\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n bool initialized;\\n bool platformRestricted;\\n mapping(bytes32 => bool) paused;\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0xade1dda8163fc39658e5f6929b662187584b29cce47e9cb0915fc0d1832fb4f7\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) loanTerms;\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5f3fdba19ae8040e2007affe422527b7dca58ba424df33ba4dd9cb08d83d00de\",\"license\":\"MIT\"},\"contracts/storage/nft.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Utils\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct NFTStorage {\\n // Maps NFT owner to set of token IDs owned\\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\\n // Maps loanID to NFT IDs indicating NFT being used for the loan\\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\\n // Merkle root used for verifying nft IDs to base loan size\\n bytes32 nftMerkleRoot;\\n}\\n\\nbytes32 constant NFT_STORAGE_POS = keccak256(\\\"teller.staking.storage\\\");\\n\\nlibrary NFTStorageLib {\\n function store() internal pure returns (NFTStorage storage s) {\\n bytes32 pos = NFT_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x8d58bb6ba00310d8c3d89b95c62e5c997430a1124d73224897f7d9b2a43ab50a\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "history": [ + { + "address": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "RepayFacet", + "transactionHash": "0x4eea8acaef6be55cbc8d57c0b6b00c1cd78c7a4d37cba43eddf3f918f9617153", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "transactionIndex": 82, + "gasUsed": "1886617", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0x68c322ecfafd109f47e23505b015026e64b2edcec4bf5115acc411e5ae03cc6e", + "transactionHash": "0x4eea8acaef6be55cbc8d57c0b6b00c1cd78c7a4d37cba43eddf3f918f9617153", + "logs": [], + "blockNumber": 12438048, + "cumulativeGasUsed": "6642407", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "7aad2cc112697924bcec275c5d33dbff", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"liquidator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"reward\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokensIn\",\"type\":\"uint256\"}],\"name\":\"LoanLiquidated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountPaid\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"totalOwed\",\"type\":\"uint256\"}],\"name\":\"LoanRepaid\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"escrowRepay\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLiquidationReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"inLending_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"inCollateral_\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"liquidateLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"repayLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"params\":{\"borrower\":\"Account address of the borrower\",\"liquidator\":\"Account address of the liquidator\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"reward\":\"Value in lending token paid out to liquidator\",\"tokensIn\":\"Percentage of the collateral price paid by the liquidator to the lending pool\"}},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"params\":{\"amountPaid\":\"Amount of the loan paid back\",\"borrower\":\"Account address of the borrower\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"payer\":\"Account address of the payer\",\"totalOwed\":\"Total amount of the loan to be repaid\"}}},\"kind\":\"dev\",\"methods\":{\"escrowRepay(uint256,uint256)\":{\"details\":\"If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\",\"params\":{\"amount\":\"The amount being repaid.\",\"loanID\":\"The id of the loan being used.\"}},\"getLiquidationReward(uint256)\":{\"params\":{\"loanID\":\"The loan ID to get the info.\"},\"returns\":{\"inCollateral_\":\"The value the liquidator will receive denoted in collateral tokens.\",\"inLending_\":\"The value the liquidator will receive denoted in lending tokens.\"}},\"liquidateLoan(uint256)\":{\"params\":{\"loanID\":\"The ID of the loan to be liquidated\"}},\"repayLoan(uint256,uint256)\":{\"params\":{\"amount\":\"The amount of tokens to pay back to the loan\",\"loanID\":\"The ID of the loan the payment is for\"}}},\"version\":1},\"userdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully liquidated\"},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully repaid\"}},\"kind\":\"user\",\"methods\":{\"escrowRepay(uint256,uint256)\":{\"notice\":\"Repay this Escrow's loan.\"},\"getLiquidationReward(uint256)\":{\"notice\":\"It gets the current liquidation reward for a given loan.\"},\"liquidateLoan(uint256)\":{\"notice\":\"Liquidate a loan if it is expired or under collateralized\"},\"repayLoan(uint256,uint256)\":{\"notice\":\"Make a payment to a loan\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/market/RepayFacet.sol\":\"RepayFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Trees proofs.\\n *\\n * The proofs can be generated using the JavaScript library\\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\\n *\\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n bytes32 computedHash = leaf;\\n\\n for (uint256 i = 0; i < proof.length; i++) {\\n bytes32 proofElement = proof[i];\\n\\n if (computedHash <= proofElement) {\\n // Hash(current computed hash + current element of the proof)\\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\\n } else {\\n // Hash(current element of the proof + current computed hash)\\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\\n }\\n }\\n\\n // Check if the computed hash (root) is equal to the provided root\\n return computedHash == root;\\n }\\n}\\n\",\"keccak256\":\"0xeee34bfb413657b6cd6c8e1e15c2080ba5ebaac479578515922804346fb63f7c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/reentry/ReentryMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nabstract contract ReentryMods {\\n modifier nonReentry(bytes32 id) {\\n AccessControlStorage storage s = AccessControlStorageLib.store();\\n require(!s.entered[id], \\\"AccessControl: reentered\\\");\\n s.entered[id] = true;\\n _;\\n s.entered[id] = false;\\n }\\n}\\n\",\"keccak256\":\"0x033c1164af25ef7d35a38a60973bf379b1cc603596914ffd85dcbcf0acdb6970\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../interfaces/IAToken.sol\\\";\\nimport { IAaveLendingPool } from \\\"../interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x8030b206c87d0073fb7dbebfa2ee8a3e93c479d976d6cdaa0c939f2fedaa1525\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n function setTokenAllowance(address token, address spender) external;\\n\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xdaa338698014e6c00edf7a2aca49026a047e253cbe7fc392a73f5f63a063a7f9\",\"license\":\"MIT\"},\"contracts/escrow/libraries/LibEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibDapps } from \\\"../dapps/libraries/LibDapps.sol\\\";\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibEscrow {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\\n e_ = s().loanEscrows[loanID];\\n }\\n\\n function getEscrowTokens(uint256 loanID)\\n internal\\n view\\n returns (EnumerableSet.AddressSet storage t_)\\n {\\n t_ = s().escrowTokens[loanID];\\n }\\n\\n function balanceOf(uint256 loanID, address token)\\n internal\\n view\\n returns (uint256)\\n {\\n return IERC20(token).balanceOf(address(e(loanID)));\\n }\\n\\n /**\\n * @notice Adds or removes tokens held by the Escrow contract\\n * @param loanID The loan ID to update the token list for\\n * @param tokenAddress The token address to be added or removed\\n */\\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\\n // Skip if is lending token\\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\\n\\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\\n if (balanceOf(loanID, tokenAddress) > 0) {\\n if (!contains) {\\n EnumerableSet.add(tokens, tokenAddress);\\n }\\n } else if (contains) {\\n EnumerableSet.remove(tokens, tokenAddress);\\n }\\n }\\n\\n /**\\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\\n * @param loanID The loan ID to calculate value for\\n * @return value_ Escrow total value denoted in the lending token.\\n */\\n function calculateTotalValue(uint256 loanID)\\n internal\\n view\\n returns (uint256 value_)\\n {\\n address lendingToken = LibLoans.loan(loanID).lendingToken;\\n value_ += balanceOf(loanID, lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\\n if (EnumerableSet.length(tokens) > 0) {\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n uint256 tokenBal =\\n balanceOf(loanID, EnumerableSet.at(tokens, i));\\n value_ += PriceAggLib.valueFor(\\n EnumerableSet.at(tokens, i),\\n lendingToken,\\n tokenBal\\n );\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xcca97599fff1c1bd608e7f11c4674f325e43781794e91bf5322ac9e0ffd7b3df\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when an user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when an user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @return totalSupply_ The total value of the underlying token managed by the LP.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given markets.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider o the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfil the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n */\\n function restrict(bool state) external virtual;\\n\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xe6515c78e0277edbed82aa6926df727afd216379dd0bfbbb790222654c858499\",\"license\":\"MIT\"},\"contracts/market/LoanDataFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { Loan, LoanDebt, LoanTerms } from \\\"../storage/market.sol\\\";\\n\\ncontract LoanDataFacet {\\n /**\\n * @notice Returns the information about the given {loanID}.\\n * @param loanID The loan ID to get information for.\\n * @return loan_ The loan data.\\n */\\n function getLoan(uint256 loanID) external view returns (Loan memory loan_) {\\n loan_ = LibLoans.s().loans[loanID];\\n }\\n\\n /**\\n * @notice Returns the terms for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanTerms The terms that the loan weer created with.\\n */\\n function getLoanTerms(uint256 loanID)\\n external\\n view\\n returns (LoanTerms memory)\\n {\\n return LibLoans.terms(loanID);\\n }\\n\\n /**\\n * @notice Returns the loan IDs created by the {borrower} account.\\n * @param borrower The account to get loan IDs for.\\n * @return loanIDs The IDs for loans created by the {borrower}\\n */\\n function getBorrowerLoans(address borrower)\\n external\\n view\\n returns (uint128[] memory loanIDs)\\n {\\n return LibLoans.s().borrowerLoans[borrower];\\n }\\n\\n /**\\n * @notice Returns the debt owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanDebt The principal and interest owed amount.\\n */\\n function getDebtOwed(uint256 loanID)\\n external\\n view\\n returns (LoanDebt memory)\\n {\\n return LibLoans.debt(loanID);\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) external view returns (uint256) {\\n return LibLoans.getTotalOwed(loanID);\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n external\\n view\\n returns (uint256)\\n {\\n return LibLoans.getInterestOwedFor(loanID, amountBorrow);\\n }\\n\\n function getCollateralNeededInfo(uint256 loanID)\\n external\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n return LibLoans.getCollateralNeededInfo(loanID);\\n }\\n\\n function getLoanEscrow(uint256 loanID)\\n external\\n view\\n returns (address escrow_)\\n {\\n escrow_ = address(LibLoans.s().loanEscrows[loanID]);\\n }\\n\\n function getLoanEscrowValue(uint256 loanID)\\n external\\n view\\n returns (uint256)\\n {\\n return LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n function getEscrowTokens(uint256 loanID)\\n external\\n view\\n returns (address[] memory tokens_)\\n {\\n EnumerableSet.AddressSet storage escrowTokens =\\n LibEscrow.getEscrowTokens(loanID);\\n tokens_ = new address[](EnumerableSet.length(escrowTokens));\\n for (uint256 i; i < tokens_.length; i++) {\\n tokens_[i] = EnumerableSet.at(escrowTokens, i);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf589a2afff647e5288e15f3f6614135395562b4d12c743402a6504a3fb9b39d6\",\"license\":\"MIT\"},\"contracts/market/RepayFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\nimport {\\n ReentryMods\\n} from \\\"../contexts2/access-control/reentry/ReentryMods.sol\\\";\\nimport { AUTHORIZED } from \\\"../shared/roles.sol\\\";\\nimport { LoanDataFacet } from \\\"./LoanDataFacet.sol\\\";\\n\\n// Libraries\\nimport {\\n IERC20,\\n SafeERC20\\n} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibCollateral } from \\\"./libraries/LibCollateral.sol\\\";\\nimport { LibDapps } from \\\"../escrow/dapps/libraries/LibDapps.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { NumbersLib } from \\\"../shared/libraries/NumbersLib.sol\\\";\\nimport { PriceAggLib } from \\\"../price-aggregator/PriceAggLib.sol\\\";\\nimport { NFTLib } from \\\"../nft/libraries/NFTLib.sol\\\";\\n\\n// Interfaces\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus\\n} from \\\"../storage/market.sol\\\";\\n\\ncontract RepayFacet is RolesMods, ReentryMods, PausableMods {\\n /**\\n @notice This event is emitted when a loan has been successfully repaid\\n @param loanID ID of loan from which collateral was withdrawn\\n @param borrower Account address of the borrower\\n @param amountPaid Amount of the loan paid back\\n @param payer Account address of the payer\\n @param totalOwed Total amount of the loan to be repaid\\n */\\n event LoanRepaid(\\n uint256 indexed loanID,\\n address indexed borrower,\\n uint256 amountPaid,\\n address payer,\\n uint256 totalOwed\\n );\\n\\n /**\\n * @notice This event is emitted when a loan has been successfully liquidated\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param borrower Account address of the borrower\\n * @param liquidator Account address of the liquidator\\n * @param reward Value in lending token paid out to liquidator\\n * @param tokensIn Percentage of the collateral price paid by the liquidator to the lending pool\\n */\\n event LoanLiquidated(\\n uint256 indexed loanID,\\n address indexed borrower,\\n address liquidator,\\n uint256 reward,\\n uint256 tokensIn\\n );\\n\\n /**\\n * @notice Repay this Escrow's loan.\\n * @dev If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.\\n * @dev Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\\n * @param loanID The id of the loan being used.\\n * @param amount The amount being repaid.\\n */\\n function escrowRepay(uint256 loanID, uint256 amount)\\n external\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n nonReentry(\\\"\\\")\\n {\\n uint256 balance =\\n LibEscrow.balanceOf(loanID, LibLoans.loan(loanID).lendingToken);\\n uint256 totalOwed = LibLoans.getTotalOwed(loanID);\\n if (balance < totalOwed && amount > balance) {\\n uint256 amountNeeded =\\n amount > totalOwed ? totalOwed - (balance) : amount - (balance);\\n\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n msg.sender,\\n address(LibEscrow.e(loanID)),\\n amountNeeded\\n );\\n }\\n\\n uint256 leftToPay =\\n __repayLoan(loanID, amount, address(LibEscrow.e(loanID)));\\n // if the loan is now fully paid, close it and withdraw borrower collateral\\n if (leftToPay == 0) {\\n LibLoans.loan(loanID).status = LoanStatus.Closed;\\n LibCollateral.withdrawAll(loanID, LibLoans.loan(loanID).borrower);\\n }\\n\\n emit LoanRepaid(\\n loanID,\\n LibLoans.loan(loanID).borrower,\\n amount,\\n msg.sender,\\n leftToPay\\n );\\n }\\n\\n /**\\n * @notice Make a payment to a loan\\n * @param loanID The ID of the loan the payment is for\\n * @param amount The amount of tokens to pay back to the loan\\n */\\n function repayLoan(uint256 loanID, uint256 amount)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n uint256 leftToPay = __repayLoan(loanID, amount, msg.sender);\\n // if the loan is now fully paid, close it and withdraw borrower collateral\\n if (leftToPay == 0) {\\n LibLoans.loan(loanID).status = LoanStatus.Closed;\\n LibCollateral.withdrawAll(loanID, LibLoans.loan(loanID).borrower);\\n // Restake any NFTs linked to loan for borrower\\n NFTLib.restakeLinked(loanID, LibLoans.loan(loanID).borrower);\\n }\\n\\n emit LoanRepaid(\\n loanID,\\n LibLoans.loan(loanID).borrower,\\n amount,\\n msg.sender,\\n leftToPay\\n );\\n }\\n\\n function __repayLoan(\\n uint256 loanID,\\n uint256 amount,\\n address sender\\n ) private returns (uint256 leftToPay_) {\\n require(amount > 0, \\\"Teller: zero repay\\\");\\n\\n // calculate the actual amount to repay\\n leftToPay_ =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n if (leftToPay_ < amount) {\\n amount = leftToPay_;\\n leftToPay_ = 0;\\n } else {\\n leftToPay_ -= amount;\\n }\\n\\n // Get the Teller token for the loan\\n ITToken tToken =\\n MarketStorageLib.store().tTokens[\\n LibLoans.loan(loanID).lendingToken\\n ];\\n // Transfer funds from account\\n if (address(LibEscrow.e(loanID)) == sender) {\\n LibEscrow.e(loanID).claimToken(\\n LibLoans.loan(loanID).lendingToken,\\n address(tToken),\\n amount\\n );\\n } else {\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n sender,\\n address(tToken),\\n amount\\n );\\n }\\n\\n // Deduct the interest and principal owed\\n uint256 principalPaid;\\n uint256 interestPaid;\\n if (amount < LibLoans.debt(loanID).interestOwed) {\\n interestPaid = amount;\\n LibLoans.debt(loanID).interestOwed -= amount;\\n } else {\\n if (LibLoans.debt(loanID).interestOwed > 0) {\\n interestPaid = LibLoans.debt(loanID).interestOwed;\\n amount -= interestPaid;\\n LibLoans.debt(loanID).interestOwed = 0;\\n }\\n\\n if (amount > 0) {\\n principalPaid = amount;\\n LibLoans.debt(loanID).principalOwed -= amount;\\n }\\n }\\n\\n // Tell the Teller Token value has been deposited back into the pool.\\n tToken.repayLoan(principalPaid, interestPaid);\\n }\\n\\n /**\\n * @notice Liquidate a loan if it is expired or under collateralized\\n * @param loanID The ID of the loan to be liquidated\\n */\\n function liquidateLoan(uint256 loanID)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n uint256 collateralAmount = LibCollateral.e(loanID).loanSupply(loanID);\\n require(\\n RepayLib.isLiquidable(loanID, collateralAmount),\\n \\\"Teller: does not need liquidation\\\"\\n );\\n\\n // Calculate the reward before repaying the loan\\n (uint256 rewardInLending, uint256 collateralInLending) =\\n RepayLib.getLiquidationReward(loanID, collateralAmount);\\n\\n // The liquidator pays the amount still owed on the loan\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n // Make sure there is nothing left to repay on the loan\\n require(\\n __repayLoan(loanID, amountToLiquidate, msg.sender) == 0,\\n \\\"Teller: liquidate partial repay\\\"\\n );\\n\\n // Set loan status\\n loan.status = LoanStatus.Liquidated;\\n\\n // Payout the liquidator reward owed\\n if (rewardInLending > 0) {\\n RepayLib.payOutLiquidator(\\n loanID,\\n rewardInLending,\\n collateralInLending,\\n collateralAmount,\\n payable(msg.sender)\\n );\\n }\\n\\n // Transfer NFT if linked\\n NFTLib.liquidateNFT(loanID);\\n\\n emit LoanLiquidated(\\n loanID,\\n loan.borrower,\\n msg.sender,\\n rewardInLending,\\n amountToLiquidate\\n );\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @return inLending_ The value the liquidator will receive denoted in lending tokens.\\n * @return inCollateral_ The value the liquidator will receive denoted in collateral tokens.\\n */\\n function getLiquidationReward(uint256 loanID)\\n external\\n view\\n returns (uint256 inLending_, uint256 inCollateral_)\\n {\\n (inLending_, ) = RepayLib.getLiquidationReward(\\n loanID,\\n LibCollateral.e(loanID).loanSupply(loanID)\\n );\\n inCollateral_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n inLending_\\n );\\n }\\n}\\n\\nlibrary RepayLib {\\n /**\\n * @notice It checks if a loan can be liquidated.\\n * @param loanID The loan ID to check.\\n * @return true if the loan is liquidable.\\n */\\n function isLiquidable(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (bool)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n // Check if loan can be liquidated\\n if (loan.status != LoanStatus.Active) {\\n return false;\\n }\\n\\n if (loan.collateralRatio > 0) {\\n // If loan has a collateral ratio, check how much is needed\\n (, uint256 neededInCollateral, ) =\\n LoanDataFacet(address(this)).getCollateralNeededInfo(loanID);\\n if (neededInCollateral > collateralAmount) {\\n return true;\\n }\\n }\\n\\n // Otherwise, check if the loan has expired\\n return block.timestamp >= loan.loanStartTime + loan.duration;\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @param collateralAmount The amount of collateral for the {loanID}. Passed in to save gas calling the collateral escrow multiple times.\\n * @return reward_ The value the liquidator will receive denoted in lending tokens.\\n */\\n function getLiquidationReward(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (uint256 reward_, uint256 collateralValue_)\\n {\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n // Max reward is amount repaid on loan plus extra percentage\\n uint256 maxReward =\\n amountToLiquidate +\\n NumbersLib.percent(\\n amountToLiquidate,\\n uint16(PlatformSettingsLib.getLiquidateRewardPercent())\\n );\\n\\n // Calculate available collateral for reward\\n if (collateralAmount > 0) {\\n collateralValue_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).collateralToken,\\n LibLoans.loan(loanID).lendingToken,\\n collateralAmount\\n );\\n reward_ += collateralValue_;\\n }\\n\\n // Calculate loan escrow value if collateral not enough to cover reward\\n if (reward_ < maxReward) {\\n reward_ += LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n // Cap the reward to max\\n if (reward_ > maxReward) {\\n reward_ = maxReward;\\n }\\n }\\n\\n /**\\n * @notice Checks if the loan has an Escrow and claims any tokens then pays out the loan collateral.\\n * @dev See Escrow.claimTokens for more info.\\n * @param loanID The loan ID which is being liquidated\\n * @param rewardInLending The total amount of reward based in the lending token to pay the liquidator\\n * @param collateralInLending The amount of collateral that is available for the loan denoted in lending tokens\\n * @param collateralAmount The amount of collateral that is available for the loan\\n * @param liquidator The address of the liquidator where the liquidation reward will be sent to\\n */\\n function payOutLiquidator(\\n uint256 loanID,\\n uint256 rewardInLending,\\n uint256 collateralInLending,\\n uint256 collateralAmount,\\n address payable liquidator\\n ) internal {\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Liquidated,\\n \\\"Teller: loan not liquidated\\\"\\n );\\n\\n if (rewardInLending <= collateralInLending) {\\n uint256 rewardInCollateral =\\n PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n rewardInLending\\n );\\n\\n LibCollateral.withdraw(loanID, rewardInCollateral, liquidator);\\n } else {\\n // Payout whats available in the collateral token\\n LibCollateral.withdraw(loanID, collateralAmount, liquidator);\\n\\n // Claim remaining reward value from the loan escrow\\n claimEscrowTokensByValue(\\n loanID,\\n liquidator,\\n rewardInLending - collateralInLending\\n );\\n }\\n }\\n\\n /**\\n * @dev Send the equivalent of tokens owned by the loan escrow (in lending value) to the recipient,\\n * @param loanID The loan ID to clam tokens from\\n * @param recipient address to send the tokens to\\n * @param value The value of escrow held tokens to be claimed based in lending value\\n */\\n function claimEscrowTokensByValue(\\n uint256 loanID,\\n address recipient,\\n uint256 value\\n ) private {\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n uint256 valueLeftToTransfer = value;\\n\\n // Start with the lending token\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n LibLoans.loan(loanID).lendingToken,\\n recipient,\\n valueLeftToTransfer\\n );\\n\\n // Cycle through remaining tokens\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n if (valueLeftToTransfer == 0) {\\n return;\\n }\\n\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n EnumerableSet.at(tokens, i),\\n recipient,\\n valueLeftToTransfer\\n );\\n }\\n }\\n\\n function claimEscrowToken(\\n uint256 loanID,\\n address token,\\n address recipient,\\n uint256 valueLeftToTransfer\\n ) private returns (uint256) {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n // get value of token balance in lending value\\n if (balance > 0) {\\n // If token not the lending token, get value of token\\n uint256 balanceInLending;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n balanceInLending = balance;\\n } else {\\n balanceInLending = PriceAggLib.valueFor(\\n token,\\n LibLoans.loan(loanID).lendingToken,\\n balance\\n );\\n }\\n\\n if (balanceInLending <= valueLeftToTransfer) {\\n LibEscrow.e(loanID).claimToken(token, recipient, balance);\\n valueLeftToTransfer -= balanceInLending;\\n } else {\\n // Token balance is more than enough so calculate ratio of balance to transfer\\n uint256 valueToTransfer;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n valueToTransfer = valueLeftToTransfer;\\n } else {\\n valueToTransfer = NumbersLib.percent(\\n balanceInLending,\\n NumbersLib.ratioOf(\\n valueLeftToTransfer,\\n balanceInLending\\n )\\n );\\n }\\n\\n LibEscrow.e(loanID).claimToken(\\n token,\\n recipient,\\n valueToTransfer\\n );\\n valueLeftToTransfer = 0;\\n }\\n }\\n\\n return valueLeftToTransfer;\\n }\\n}\\n\",\"keccak256\":\"0xd48f89e3810bf8847385c6bb0f7d50244582997d808a52d888d77cbe50d55d8d\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n function init(address tokenAddress, bool isWETH) external;\\n\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x3c83593b5521e85c7f62076b41869cd5a762b34523ac39fc23b4ea1b9042aa59\",\"license\":\"MIT\"},\"contracts/market/libraries/LibCollateral.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport { ICollateralEscrow } from \\\"../collateral/ICollateralEscrow.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\nimport { MarketStorageLib } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibCollateral {\\n /**\\n * @notice This event is emitted when collateral has been deposited for the loan\\n * @param loanID ID of the loan for which collateral was deposited\\n * @param depositor Account that deposited funds\\n * @param amount Amount of collateral deposited\\n */\\n event CollateralDeposited(\\n uint256 indexed loanID,\\n address indexed depositor,\\n uint256 amount\\n );\\n\\n /**\\n * @notice This event is emitted when collateral has been withdrawn\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param receiver Account that received funds\\n * @param amount Value of collateral withdrawn\\n */\\n event CollateralWithdrawn(\\n uint256 indexed loanID,\\n address indexed receiver,\\n uint256 amount\\n );\\n\\n function e(uint256 loanID) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[\\n MarketStorageLib.store().loans[loanID].collateralToken\\n ];\\n }\\n\\n function e(address token) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[token];\\n }\\n\\n function deposit(uint256 loanID, uint256 amount) internal {\\n e(loanID).deposit{ value: amount }(loanID, amount);\\n\\n emit CollateralDeposited(loanID, msg.sender, amount);\\n }\\n\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) internal {\\n e(loanID).withdraw(loanID, amount, receiver);\\n\\n emit CollateralWithdrawn(loanID, receiver, amount);\\n }\\n\\n function withdrawAll(uint256 loanID, address payable receiver) internal {\\n withdraw(loanID, e(loanID).loanSupply(loanID), receiver);\\n }\\n\\n function createEscrow(address token) internal {\\n // Check if collateral escrow exists\\n if (address(e(token)) == address(0)) {\\n // Create escrow\\n address escrow =\\n AppStorageLib.store().collateralEscrowBeacon.cloneProxy(\\\"\\\");\\n ICollateralEscrow(escrow).init(\\n token,\\n // Check if collateral token is WETH\\n token == AppStorageLib.store().assetAddresses[\\\"WETH\\\"]\\n );\\n\\n // Set max allowance\\n IERC20(token).approve(escrow, type(uint256).max);\\n // Save escrow address for loan\\n MarketStorageLib.store().collateralEscrows[\\n token\\n ] = ICollateralEscrow(escrow);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd52b3e577480481b62d6a6c37f4ef596b7ec0120afbd6bc1a08b17923b926445\",\"license\":\"MIT\"},\"contracts/market/libraries/LibLoans.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibEscrow } from \\\"../../escrow/libraries/LibEscrow.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus,\\n LoanDebt,\\n LoanTerms\\n} from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibLoans {\\n using NumbersLib for int256;\\n using NumbersLib for uint256;\\n\\n bytes32 internal constant ID = keccak256(\\\"LOANS\\\");\\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\\n l_ = s().loans[loanID];\\n }\\n\\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\\n d_ = s().loanDebt[loanID];\\n }\\n\\n function terms(uint256 loanID)\\n internal\\n view\\n returns (LoanTerms storage t_)\\n {\\n t_ = s().loanTerms[loanID];\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) internal view returns (uint256) {\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n uint256 interestOwed =\\n getInterestOwedFor(loanID, terms(loanID).maxLoanAmount);\\n return terms(loanID).maxLoanAmount + (interestOwed);\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n return debt(loanID).principalOwed + (debt(loanID).interestOwed);\\n }\\n return 0;\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n internal\\n view\\n returns (uint256)\\n {\\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\\n }\\n\\n function getCollateralNeededInfo(uint256 loanID)\\n internal\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\\n loanID\\n );\\n\\n if (neededInLendingTokens == 0) {\\n neededInCollateralTokens = 0;\\n } else {\\n neededInCollateralTokens = PriceAggLib.valueFor(\\n loan(loanID).lendingToken,\\n loan(loanID).collateralToken,\\n neededInLendingTokens\\n );\\n }\\n }\\n\\n /**\\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\\n * @param loanID The loan ID to get needed collateral info for.\\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\\n */\\n function getCollateralNeededInTokens(uint256 loanID)\\n internal\\n view\\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\\n {\\n if (!_isActiveOrSet(loanID) || loan(loanID).collateralRatio == 0) {\\n return (0, 0);\\n }\\n\\n /*\\n The collateral to principal owed ratio is the sum of:\\n * collateral buffer percent\\n * loan interest rate\\n * liquidation reward percent\\n * X factor of additional collateral\\n */\\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n neededInLendingTokens = _getLoanAmount(loanID).percent(\\n loan(loanID).collateralRatio\\n );\\n } else {\\n uint16 requiredRatio =\\n loan(loanID).collateralRatio -\\n getInterestRatio(loanID) -\\n uint16(PlatformSettingsLib.getCollateralBufferValue());\\n\\n neededInLendingTokens =\\n debt(loanID).principalOwed +\\n debt(loanID).interestOwed;\\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\\n if (\\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\\n ) {\\n neededInLendingTokens -= escrowLoanValue;\\n }\\n neededInLendingTokens = neededInLendingTokens.percent(\\n requiredRatio\\n );\\n }\\n }\\n\\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\\n internal\\n view\\n returns (bool)\\n {\\n return\\n collateralRatio >=\\n PlatformSettingsLib.getOverCollateralizedBufferValue();\\n }\\n\\n /**\\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\\n * @notice There is a minimum threshold of 1%.\\n * @dev The interest rate on the loan terms is APY.\\n * @param loanID The loan ID to get the interest rate for.\\n */\\n function getInterestRatio(uint256 loanID)\\n internal\\n view\\n returns (uint16 ratio_)\\n {\\n ratio_ = uint16(\\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\\n SECONDS_PER_YEAR\\n );\\n\\n if (ratio_ == 0) {\\n ratio_ = 1;\\n }\\n }\\n\\n function _getLoanAmount(uint256 loanID) private view returns (uint256) {\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n return terms(loanID).maxLoanAmount;\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n return loan(loanID).borrowedAmount;\\n }\\n return 0;\\n }\\n\\n function _isActiveOrSet(uint256 loanID) private view returns (bool) {\\n LoanStatus status = loan(loanID).status;\\n return status == LoanStatus.Active || status == LoanStatus.TermsSet;\\n }\\n}\\n\",\"keccak256\":\"0x9bf9fae5b01110da7c5a5d2517fdea6aa880d5c1647ba6125c68cafad278499b\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x7c788b94c175b70eec6b10bfe0655616fc0beb2ce3ef70a6fa750f291d35106c\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}.\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x39fd6d70fd1aa5ae45465d7eeb38f74e2bf90535c2510782fb0bb5f720250ac5\",\"license\":\"MIT\"},\"contracts/nft/libraries/NFTLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../TellerNFT.sol\\\";\\n\\n// Libraries\\nimport {\\n MerkleProof\\n} from \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\nimport { NFTStorageLib, NFTStorage } from \\\"../../storage/nft.sol\\\";\\n\\nstruct NftLoanSizeProof {\\n uint256 id;\\n uint256 baseLoanSize;\\n bytes32[] proof;\\n}\\n\\nlibrary NFTLib {\\n function s() internal pure returns (NFTStorage storage s_) {\\n s_ = NFTStorageLib.store();\\n }\\n\\n function nft() internal view returns (TellerNFT nft_) {\\n nft_ = AppStorageLib.store().nft;\\n }\\n\\n function stake(uint256 nftID, address owner) internal {\\n // Transfer to diamond\\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\\n // Add NFT ID to user set\\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\\n }\\n\\n function unstake(uint256 nftID) internal returns (bool success_) {\\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\\n }\\n\\n function stakedNFTs(address nftOwner)\\n internal\\n view\\n returns (uint256[] memory staked_)\\n {\\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\\n staked_ = new uint256[](EnumerableSet.length(nfts));\\n for (uint256 i; i < staked_.length; i++) {\\n staked_[i] = EnumerableSet.at(nfts, i);\\n }\\n }\\n\\n function liquidateNFT(uint256 loanID) internal {\\n // Check if NFTs are linked\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n NFTLib.nft().transferFrom(\\n address(this),\\n AppStorageLib.store().nftLiquidationController,\\n EnumerableSet.at(nfts, i)\\n );\\n }\\n }\\n\\n function applyToLoan(uint256 loanID, NftLoanSizeProof calldata proof)\\n internal\\n {\\n // NFT must be currently staked\\n // Remove NFT from being staked - returns bool\\n require(unstake(proof.id), \\\"Teller: borrower nft not staked\\\");\\n\\n require(verifyLoanSize(proof), \\\"Teller invalid nft proof\\\");\\n\\n // Apply NFT to loan\\n EnumerableSet.add(s().loanNFTs[loanID], proof.id);\\n }\\n\\n function restakeLinked(uint256 loanID, address owner) internal {\\n // Get linked NFT\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n // Restake the NFT\\n stake(EnumerableSet.at(nfts, i), owner);\\n }\\n }\\n\\n function verifyLoanSize(NftLoanSizeProof calldata proof)\\n internal\\n view\\n returns (bool verified_)\\n {\\n verified_ = MerkleProof.verify(\\n proof.proof,\\n s().nftMerkleRoot,\\n keccak256(abi.encodePacked(proof.id, proof.baseLoanSize))\\n );\\n }\\n}\\n\",\"keccak256\":\"0xb063eb66af8d3844af1125125ac2629ee0225b20209e3464d560ebe1b3d3d407\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @dev It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @dev Tries to calculate a price from Compound and Chainlink.\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @dev Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @dev Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @dev Scales the {value} by the difference in decimal values.\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @dev Tries to calculate the price of {src} in {dst}\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address WETH = AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n if (dst != WETH) {\\n int256 price1 = _priceFor(src, WETH);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, WETH);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf84fd8d9a179ca7a70e75677870bdd7a5be7da097cf5f1bccf1c9f93253bda90\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { PriceAggFacet } from \\\"./PriceAggFacet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\n/**\\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\\n */\\nlibrary PriceAggLib {\\n /**\\n * @notice See {PriceAggFacet.getValueFor}\\n */\\n function valueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) internal view returns (uint256 value_) {\\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\\n }\\n\\n /**\\n * @notice See {PriceAggFacet.getPriceFor}\\n */\\n function priceFor(address src, address dst)\\n internal\\n view\\n returns (int256 price_)\\n {\\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\\n }\\n}\\n\",\"keccak256\":\"0x510633e39e7a30533d703eb7ec314c037772721fdb7cea96046cd6837bcb76c3\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\nabstract contract PausableMods {\\n /**\\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\\n * @param id id of the facet to check if is paused.\\n * @param state Boolean that the protocol AND facet should be in.\\n */\\n modifier paused(bytes32 id, bool state) {\\n require(\\n __isPaused(\\\"\\\") == state && __isPaused(id) == state,\\n __pausedMessage(state)\\n );\\n _;\\n }\\n\\n /**\\n * @dev Checks if the given id is paused.\\n * @param id Encoded id of the facet to check if is paused.\\n */\\n function __isPaused(bytes32 id) private view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n\\n /**\\n * @dev Gets the message that should be reverted with given a state it should be in.\\n * @param state Boolean that an id should be in.\\n */\\n function __pausedMessage(bool state) private pure returns (string memory) {\\n return state ? \\\"Pausable: not paused\\\" : \\\"Pausable: paused\\\";\\n }\\n}\\n\",\"keccak256\":\"0x772d8b9b63e9b8e78f243a70988f1a1e1100272cf317259ea173829f7b9bdf0e\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0xbeef1937dc1ed1f6f78b80f0737f018565ab264184cf05ef54c3c28ecd55a09b\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xacf6bcb8c4afd2f337a0161e8be64b016c1b350d336cd862245dd922fcd10f33\",\"license\":\"MIT\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n function claimComp(address holder) external;\\n\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x495d8bb746a524fea6ddc4286c955d7a0160718bf662456330a9d6d14b8a5da9\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n\\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x208769886b3db8f03ef1fa26f1caee189038dfc744b9a499402fc4e4c0090c38\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4d9045666e86d675f7bd48202f9a77d0675fa20b2184131ad369710ac5eb3203\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @notice CETH is the only Compound token that does not support the {underlying} function.\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x14e96659912e9d03ae30732faca8e3d617f3e756a215d948cabedab6642c1465\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0x998aefaf4edbe7b0cb41032750b65b3822b4bec0fec3ee5b396f8fb73b5e9e03\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0x8919fcdfb49018474c872c462c11b21a50faa7ab80f0162abd6b657cbbc5d04c\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x0888cf40ea019be9f0ee94cb8af1e030454c28f8c6512db9d89ed027fe21f18f\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n bool initialized;\\n bool platformRestricted;\\n mapping(bytes32 => bool) paused;\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0xade1dda8163fc39658e5f6929b662187584b29cce47e9cb0915fc0d1832fb4f7\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) loanTerms;\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5f3fdba19ae8040e2007affe422527b7dca58ba424df33ba4dd9cb08d83d00de\",\"license\":\"MIT\"},\"contracts/storage/nft.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Utils\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct NFTStorage {\\n // Maps NFT owner to set of token IDs owned\\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\\n // Maps loanID to NFT IDs indicating NFT being used for the loan\\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\\n // Merkle root used for verifying nft IDs to base loan size\\n bytes32 nftMerkleRoot;\\n}\\n\\nbytes32 constant NFT_STORAGE_POS = keccak256(\\\"teller.staking.storage\\\");\\n\\nlibrary NFTStorageLib {\\n function store() internal pure returns (NFTStorage storage s) {\\n bytes32 pos = NFT_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x8d58bb6ba00310d8c3d89b95c62e5c997430a1124d73224897f7d9b2a43ab50a\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "params": { + "borrower": "Account address of the borrower", + "liquidator": "Account address of the liquidator", + "loanID": "ID of loan from which collateral was withdrawn", + "reward": "Value in lending token paid out to liquidator", + "tokensIn": "Percentage of the collateral price paid by the liquidator to the lending pool" + } + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "params": { + "amountPaid": "Amount of the loan paid back", + "borrower": "Account address of the borrower", + "loanID": "ID of loan from which collateral was withdrawn", + "payer": "Account address of the payer", + "totalOwed": "Total amount of the loan to be repaid" + } + } + }, + "kind": "dev", + "methods": { + "escrowRepay(uint256,uint256)": { + "details": "If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.", + "params": { + "amount": "The amount being repaid.", + "loanID": "The id of the loan being used." + } + }, + "getLiquidationReward(uint256)": { + "params": { + "loanID": "The loan ID to get the info." + }, + "returns": { + "inCollateral_": "The value the liquidator will receive denoted in collateral tokens.", + "inLending_": "The value the liquidator will receive denoted in lending tokens." + } + }, + "liquidateLoan(uint256)": { + "params": { + "loanID": "The ID of the loan to be liquidated" + } + }, + "repayLoan(uint256,uint256)": { + "params": { + "amount": "The amount of tokens to pay back to the loan", + "loanID": "The ID of the loan the payment is for" + } + } + }, + "version": 1 + }, + "userdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "notice": "This event is emitted when a loan has been successfully liquidated" + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "notice": "This event is emitted when a loan has been successfully repaid" + } + }, + "kind": "user", + "methods": { + "escrowRepay(uint256,uint256)": { + "notice": "Repay this Escrow's loan." + }, + "getLiquidationReward(uint256)": { + "notice": "It gets the current liquidation reward for a given loan." + }, + "liquidateLoan(uint256)": { + "notice": "Liquidate a loan if it is expired or under collateralized" + }, + "repayLoan(uint256,uint256)": { + "notice": "Make a payment to a loan" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "params": { + "borrower": "Account address of the borrower", + "liquidator": "Account address of the liquidator", + "loanID": "ID of loan from which collateral was withdrawn", + "reward": "Value in lending token paid out to liquidator", + "tokensIn": "Percentage of the collateral price paid by the liquidator to the lending pool" + } + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "params": { + "amountPaid": "Amount of the loan paid back", + "borrower": "Account address of the borrower", + "loanID": "ID of loan from which collateral was withdrawn", + "payer": "Account address of the payer", + "totalOwed": "Total amount of the loan to be repaid" + } + } + }, + "kind": "dev", + "methods": { + "escrowRepay(uint256,uint256)": { + "details": "If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.", + "params": { + "amount": "The amount being repaid.", + "loanID": "The id of the loan being used." + } + }, + "getLiquidationReward(uint256)": { + "params": { + "loanID": "The loan ID to get the info." + }, + "returns": { + "inCollateral_": "The value the liquidator will receive denoted in collateral tokens.", + "inLending_": "The value the liquidator will receive denoted in lending tokens." + } + }, + "liquidateLoan(uint256)": { + "params": { + "loanID": "The ID of the loan to be liquidated" + } + }, + "repayLoan(uint256,uint256)": { + "params": { + "amount": "The amount of tokens to pay back to the loan", + "loanID": "The ID of the loan the payment is for" + } + } + }, + "version": 1 + }, + "userdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "notice": "This event is emitted when a loan has been successfully liquidated" + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "notice": "This event is emitted when a loan has been successfully repaid" + } + }, + "kind": "user", + "methods": { + "escrowRepay(uint256,uint256)": { + "notice": "Repay this Escrow's loan." + }, + "getLiquidationReward(uint256)": { + "notice": "It gets the current liquidation reward for a given loan." + }, + "liquidateLoan(uint256)": { + "notice": "Liquidate a loan if it is expired or under collateralized" + }, + "repayLoan(uint256,uint256)": { + "notice": "Make a payment to a loan" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "params": { + "borrower": "Account address of the borrower", + "liquidator": "Account address of the liquidator", + "loanID": "ID of loan from which collateral was withdrawn", + "reward": "Value in lending token paid out to liquidator", + "tokensIn": "Percentage of the collateral price paid by the liquidator to the lending pool" + } + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "params": { + "amountPaid": "Amount of the loan paid back", + "borrower": "Account address of the borrower", + "loanID": "ID of loan from which collateral was withdrawn", + "payer": "Account address of the payer", + "totalOwed": "Total amount of the loan to be repaid" + } + } + }, + "kind": "dev", + "methods": { + "claimTokens(uint256)": { + "params": { + "loanID": "The id of the loan being used." + } + }, + "escrowRepay(uint256,uint256)": { + "details": "If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.", + "params": { + "amount": "The amount being repaid.", + "loanID": "The id of the loan being used." + } + }, + "getLiquidationReward(uint256)": { + "params": { + "loanID": "The loan ID to get the info." + }, + "returns": { + "inCollateral_": "The value the liquidator will receive denoted in collateral tokens.", + "inLending_": "The value the liquidator will receive denoted in lending tokens." + } + }, + "liquidateLoan(uint256)": { + "params": { + "loanID": "The ID of the loan to be liquidated" + } + }, + "repayLoan(uint256,uint256)": { + "params": { + "amount": "The amount of tokens to pay back to the loan", + "loanID": "The ID of the loan the payment is for" + } + } + }, + "version": 1 + }, + "userdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "notice": "This event is emitted when a loan has been successfully liquidated" + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "notice": "This event is emitted when a loan has been successfully repaid" + }, + "TokensClaimed(address)": { + "notice": "Notifies when the Escrow's tokens have been claimed." + } + }, + "kind": "user", + "methods": { + "claimTokens(uint256)": { + "notice": "Sends the tokens owned by this escrow to the owner." + }, + "escrowRepay(uint256,uint256)": { + "notice": "Repay this Escrow's loan." + }, + "getLiquidationReward(uint256)": { + "notice": "It gets the current liquidation reward for a given loan." + }, + "liquidateLoan(uint256)": { + "notice": "Liquidate a loan if it is expired or under collateralized" + }, + "repayLoan(uint256,uint256)": { + "notice": "Make a payment to a loan" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } } ], "devdoc": { diff --git a/deployments/mainnet/TellerDiamond.json b/deployments/mainnet/TellerDiamond.json index 433167e6b..502d89755 100644 --- a/deployments/mainnet/TellerDiamond.json +++ b/deployments/mainnet/TellerDiamond.json @@ -2299,56 +2299,46 @@ } ], "artifactName": "Diamond", - "transactionHash": "0xe28545ae61df0f3e5aab652a3bb86f243aded6916f410259d873494df064c660", + "transactionHash": "0x0b1a42f5fc4b93954cda4050b098c8ec7872b29df619342034c4c2447388f2b1", "receipt": { "to": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", "contractAddress": null, - "transactionIndex": 59, - "gasUsed": "286207", + "transactionIndex": 171, + "gasUsed": "132502", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000100000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020", - "blockHash": "0x0ee4a0ddb36bcd41372c41b77fd52eff8df4cbd221bf09051e71eb9de33d662b", - "transactionHash": "0xe28545ae61df0f3e5aab652a3bb86f243aded6916f410259d873494df064c660", + "blockHash": "0xf1c3c0f3983cc3c8344ecf46a76107c79ad9074c349307be7aad048b55ac6146", + "transactionHash": "0x0b1a42f5fc4b93954cda4050b098c8ec7872b29df619342034c4c2447388f2b1", "logs": [ { - "transactionIndex": 59, - "blockNumber": 12647881, - "transactionHash": "0xe28545ae61df0f3e5aab652a3bb86f243aded6916f410259d873494df064c660", + "transactionIndex": 171, + "blockNumber": 12692220, + "transactionHash": "0x0b1a42f5fc4b93954cda4050b098c8ec7872b29df619342034c4c2447388f2b1", "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", "topics": [ "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" ], - "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000580000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000001a00000000000000000000000000000000000000000000000000000000000000260000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000004600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004ce6e9f9f0000000000000000000000000000000000000000000000000000000002bc2cdb000000000000000000000000000000000000000000000000000000000448a5c4000000000000000000000000000000000000000000000000000000000967aa820000000000000000000000000000000000000000000000000000000000000000000000000000000021c3c004dab0a4e1ff0f4473667e51a93d127cdd000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002ea40e51a00000000000000000000000000000000000000000000000000000000fe5d095b000000000000000000000000000000000000000000000000000000000000000000000000000000002057f8dd4bcc637edbf716fdaf7dccc86e58808200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000546e04a2f00000000000000000000000000000000000000000000000000000000e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b53000000000000000000000000000000000000000000000000000000000000000000000000000000007cdff3fd2063cb725da6eb5e951fa3766d376d47000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003a7baf6fc000000000000000000000000000000000000000000000000000000006f70d212000000000000000000000000000000000000000000000000000000000f48a482000000000000000000000000000000000000000000000000000000000000000000000000000000007cdff3fd2063cb725da6eb5e951fa3766d376d47000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000001987df220000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "logIndex": 103, - "blockHash": "0x0ee4a0ddb36bcd41372c41b77fd52eff8df4cbd221bf09051e71eb9de33d662b" + "data": "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001c000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000b43707f26d6356ae753e9c92d3c94d23c70c405700000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000546e04a2f00000000000000000000000000000000000000000000000000000000e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b53000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 317, + "blockHash": "0xf1c3c0f3983cc3c8344ecf46a76107c79ad9074c349307be7aad048b55ac6146" } ], "events": [ { - "transactionIndex": 59, - "blockNumber": 12647881, - "transactionHash": "0xe28545ae61df0f3e5aab652a3bb86f243aded6916f410259d873494df064c660", + "transactionIndex": 171, + "blockNumber": 12692220, + "transactionHash": "0x0b1a42f5fc4b93954cda4050b098c8ec7872b29df619342034c4c2447388f2b1", "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", "topics": [ "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" ], - "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000580000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000001a00000000000000000000000000000000000000000000000000000000000000260000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000004600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004ce6e9f9f0000000000000000000000000000000000000000000000000000000002bc2cdb000000000000000000000000000000000000000000000000000000000448a5c4000000000000000000000000000000000000000000000000000000000967aa820000000000000000000000000000000000000000000000000000000000000000000000000000000021c3c004dab0a4e1ff0f4473667e51a93d127cdd000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002ea40e51a00000000000000000000000000000000000000000000000000000000fe5d095b000000000000000000000000000000000000000000000000000000000000000000000000000000002057f8dd4bcc637edbf716fdaf7dccc86e58808200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000546e04a2f00000000000000000000000000000000000000000000000000000000e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b53000000000000000000000000000000000000000000000000000000000000000000000000000000007cdff3fd2063cb725da6eb5e951fa3766d376d47000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003a7baf6fc000000000000000000000000000000000000000000000000000000006f70d212000000000000000000000000000000000000000000000000000000000f48a482000000000000000000000000000000000000000000000000000000000000000000000000000000007cdff3fd2063cb725da6eb5e951fa3766d376d47000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000001987df220000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "logIndex": 103, - "blockHash": "0x0ee4a0ddb36bcd41372c41b77fd52eff8df4cbd221bf09051e71eb9de33d662b", + "data": "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001c000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000b43707f26d6356ae753e9c92d3c94d23c70c405700000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000546e04a2f00000000000000000000000000000000000000000000000000000000e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b53000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 317, + "blockHash": "0xf1c3c0f3983cc3c8344ecf46a76107c79ad9074c349307be7aad048b55ac6146", "args": [ [ [ - "0x0000000000000000000000000000000000000000", - 2, - ["0xce6e9f9f", "0x02bc2cdb", "0x0448a5c4", "0x0967aa82"] - ], - [ - "0x21c3c004DAB0A4e1ff0f4473667e51A93d127CdD", - 0, - ["0xea40e51a", "0xfe5d095b"] - ], - [ - "0x2057f8DD4bcC637edBF716fdaF7DCCC86E588082", + "0xb43707f26D6356ae753E9C92d3C94D23c70c4057", 1, [ "0x46e04a2f", @@ -2357,13 +2347,7 @@ "0xccdd9f5d", "0x8a700b53" ] - ], - [ - "0x7cDFF3Fd2063cb725dA6EB5e951fa3766d376D47", - 1, - ["0xa7baf6fc", "0x6f70d212", "0x0f48a482"] - ], - ["0x7cDFF3Fd2063cb725dA6EB5e951fa3766d376D47", 0, ["0x987df220"]] + ] ], "0x0000000000000000000000000000000000000000", "0x" @@ -2372,8 +2356,8 @@ "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" } ], - "blockNumber": 12647881, - "cumulativeGasUsed": "3921705", + "blockNumber": 12692220, + "cumulativeGasUsed": "14786623", "status": 1, "byzantium": true }, @@ -2476,7 +2460,7 @@ ] }, { - "facetAddress": "0x2057f8DD4bcC637edBF716fdaF7DCCC86E588082", + "facetAddress": "0xb43707f26D6356ae753E9C92d3C94D23c70c4057", "functionSelectors": [ "0x46e04a2f", "0xe89ad656", @@ -2509,22 +2493,7 @@ ], "diamondCut": [ { - "facetAddress": "0x0000000000000000000000000000000000000000", - "functionSelectors": [ - "0xce6e9f9f", - "0x02bc2cdb", - "0x0448a5c4", - "0x0967aa82" - ], - "action": 2 - }, - { - "facetAddress": "0x21c3c004DAB0A4e1ff0f4473667e51A93d127CdD", - "functionSelectors": ["0xea40e51a", "0xfe5d095b"], - "action": 0 - }, - { - "facetAddress": "0x2057f8DD4bcC637edBF716fdaF7DCCC86E588082", + "facetAddress": "0xb43707f26D6356ae753E9C92d3C94D23c70c4057", "functionSelectors": [ "0x46e04a2f", "0xe89ad656", @@ -2533,16 +2502,6 @@ "0x8a700b53" ], "action": 1 - }, - { - "facetAddress": "0x7cDFF3Fd2063cb725dA6EB5e951fa3766d376D47", - "functionSelectors": ["0xa7baf6fc", "0x6f70d212", "0x0f48a482"], - "action": 1 - }, - { - "facetAddress": "0x7cDFF3Fd2063cb725dA6EB5e951fa3766d376D47", - "functionSelectors": ["0x987df220"], - "action": 0 } ], "history": [ @@ -42984,6 +42943,43275 @@ "storage": [], "types": null } + }, + { + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanUserRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanConsensusResponse[]", + "name": "responses", + "type": "tuple[]" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanUserRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanConsensusResponse[]", + "name": "responses", + "type": "tuple[]" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "internalType": "uint16[]", + "name": "nftIDs", + "type": "uint16[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "dictAddress", + "type": "address" + } + ], + "name": "setNFTDictionary", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0xe28545ae61df0f3e5aab652a3bb86f243aded6916f410259d873494df064c660", + "receipt": { + "to": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 59, + "gasUsed": "286207", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000100000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020", + "blockHash": "0x0ee4a0ddb36bcd41372c41b77fd52eff8df4cbd221bf09051e71eb9de33d662b", + "transactionHash": "0xe28545ae61df0f3e5aab652a3bb86f243aded6916f410259d873494df064c660", + "logs": [ + { + "transactionIndex": 59, + "blockNumber": 12647881, + "transactionHash": "0xe28545ae61df0f3e5aab652a3bb86f243aded6916f410259d873494df064c660", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000580000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000001a00000000000000000000000000000000000000000000000000000000000000260000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000004600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004ce6e9f9f0000000000000000000000000000000000000000000000000000000002bc2cdb000000000000000000000000000000000000000000000000000000000448a5c4000000000000000000000000000000000000000000000000000000000967aa820000000000000000000000000000000000000000000000000000000000000000000000000000000021c3c004dab0a4e1ff0f4473667e51a93d127cdd000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002ea40e51a00000000000000000000000000000000000000000000000000000000fe5d095b000000000000000000000000000000000000000000000000000000000000000000000000000000002057f8dd4bcc637edbf716fdaf7dccc86e58808200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000546e04a2f00000000000000000000000000000000000000000000000000000000e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b53000000000000000000000000000000000000000000000000000000000000000000000000000000007cdff3fd2063cb725da6eb5e951fa3766d376d47000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003a7baf6fc000000000000000000000000000000000000000000000000000000006f70d212000000000000000000000000000000000000000000000000000000000f48a482000000000000000000000000000000000000000000000000000000000000000000000000000000007cdff3fd2063cb725da6eb5e951fa3766d376d47000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000001987df220000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 103, + "blockHash": "0x0ee4a0ddb36bcd41372c41b77fd52eff8df4cbd221bf09051e71eb9de33d662b" + } + ], + "events": [ + { + "transactionIndex": 59, + "blockNumber": 12647881, + "transactionHash": "0xe28545ae61df0f3e5aab652a3bb86f243aded6916f410259d873494df064c660", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000580000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000001a00000000000000000000000000000000000000000000000000000000000000260000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000004600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004ce6e9f9f0000000000000000000000000000000000000000000000000000000002bc2cdb000000000000000000000000000000000000000000000000000000000448a5c4000000000000000000000000000000000000000000000000000000000967aa820000000000000000000000000000000000000000000000000000000000000000000000000000000021c3c004dab0a4e1ff0f4473667e51a93d127cdd000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002ea40e51a00000000000000000000000000000000000000000000000000000000fe5d095b000000000000000000000000000000000000000000000000000000000000000000000000000000002057f8dd4bcc637edbf716fdaf7dccc86e58808200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000546e04a2f00000000000000000000000000000000000000000000000000000000e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b53000000000000000000000000000000000000000000000000000000000000000000000000000000007cdff3fd2063cb725da6eb5e951fa3766d376d47000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003a7baf6fc000000000000000000000000000000000000000000000000000000006f70d212000000000000000000000000000000000000000000000000000000000f48a482000000000000000000000000000000000000000000000000000000000000000000000000000000007cdff3fd2063cb725da6eb5e951fa3766d376d47000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000001987df220000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 103, + "blockHash": "0x0ee4a0ddb36bcd41372c41b77fd52eff8df4cbd221bf09051e71eb9de33d662b", + "args": [ + [ + [ + "0x0000000000000000000000000000000000000000", + 2, + ["0xce6e9f9f", "0x02bc2cdb", "0x0448a5c4", "0x0967aa82"] + ], + [ + "0x21c3c004DAB0A4e1ff0f4473667e51A93d127CdD", + 0, + ["0xea40e51a", "0xfe5d095b"] + ], + [ + "0x2057f8DD4bcC637edBF716fdaF7DCCC86E588082", + 1, + [ + "0x46e04a2f", + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + ], + [ + "0x7cDFF3Fd2063cb725dA6EB5e951fa3766d376D47", + 1, + ["0xa7baf6fc", "0x6f70d212", "0x0f48a482"] + ], + [ + "0x7cDFF3Fd2063cb725dA6EB5e951fa3766d376D47", + 0, + ["0x987df220"] + ] + ], + "0x0000000000000000000000000000000000000000", + "0x" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 12647881, + "cumulativeGasUsed": "3921705", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + ["0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", ["0x1f931c1c"]], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + ["0xadfca15e", "0x7a0ed627", "0xcdffacc6", "0x52ef6b2c", "0x01ffc9a7"] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": ["0xc76d202d", "0x839bb9a6", "0x8e756bb3"] + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": ["0x9912dde8", "0x5a601668", "0x8a4f4f92"] + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x21c3c004DAB0A4e1ff0f4473667e51A93d127CdD", + "functionSelectors": ["0xea40e51a", "0xfe5d095b"] + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0x2057f8DD4bcC637edBF716fdaF7DCCC86E588082", + "functionSelectors": [ + "0x46e04a2f", + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": ["0x2239f556", "0x46efd16c", "0x78b248e4"] + }, + { + "facetAddress": "0x7cDFF3Fd2063cb725dA6EB5e951fa3766d376D47", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x987df220", + "0x0f48a482" + ] + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"] + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"] + } + ], + "diamondCut": [ + { + "facetAddress": "0x0000000000000000000000000000000000000000", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4", + "0x0967aa82" + ], + "action": 2 + }, + { + "facetAddress": "0x21c3c004DAB0A4e1ff0f4473667e51A93d127CdD", + "functionSelectors": ["0xea40e51a", "0xfe5d095b"], + "action": 0 + }, + { + "facetAddress": "0x2057f8DD4bcC637edBF716fdaF7DCCC86E588082", + "functionSelectors": [ + "0x46e04a2f", + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 1 + }, + { + "facetAddress": "0x7cDFF3Fd2063cb725dA6EB5e951fa3766d376D47", + "functionSelectors": ["0xa7baf6fc", "0x6f70d212", "0x0f48a482"], + "action": 1 + }, + { + "facetAddress": "0x7cDFF3Fd2063cb725dA6EB5e951fa3766d376D47", + "functionSelectors": ["0x987df220"], + "action": 0 + } + ], + "history": [ + { + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 7, + "gasUsed": "5726914", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000120000020000008000000800000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000000000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000020000000000000000000000000000000000000000000000000000000000000008020", + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57", + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "logs": [ + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 25, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 26, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000c14d994fe7c5858c93936cc3bd42bb9467d6fb2c", + "logIndex": 27, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 28, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 29, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 30, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 31, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + } + ], + "events": [ + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 25, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 26, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000c14d994fe7c5858c93936cc3bd42bb9467d6fb2c", + "logIndex": 27, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57", + "args": ["0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C"], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 28, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 29, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 30, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 31, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + } + ], + "blockNumber": 12438084, + "cumulativeGasUsed": "6500765", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": ["0xc76d202d", "0x839bb9a6", "0x8e756bb3"], + "action": 0 + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": ["0x9912dde8", "0x5a601668", "0x8a4f4f92"], + "action": 0 + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x01503bAF774aB3aDb6AF79a6fB725c1610D45b2a", + "functionSelectors": ["0xce6e9f9f", "0x02bc2cdb", "0x0448a5c4"], + "action": 0 + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": ["0x2239f556", "0x46efd16c", "0x78b248e4"], + "action": 0 + }, + { + "facetAddress": "0x2a51f0d8DaA9BB4Dc75597cb77B99BDc1754dE00", + "functionSelectors": ["0x6f70d212", "0x0967aa82", "0x0f48a482"], + "action": 0 + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"], + "action": 0 + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "0x60806040523661000b57005b600080357fffffffff000000000000000000000000000000000000000000000000000000001681527fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c6020819052604090912054819073ffffffffffffffffffffffffffffffffffffffff16806100b7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906115f3565b60405180910390fd5b3660008037600080366000845af43d6000803e8080156100d6573d6000f35b3d6000fd5b60005b83518110156102325760008482815181106100f557fe5b60200260200101516020015190506000600281111561011057fe5b81600281111561011c57fe5b141561015f5761015a85838151811061013157fe5b60200260200101516000015186848151811061014957fe5b602002602001015160400151610326565b610229565b600181600281111561016d57fe5b14156101ab5761015a85838151811061018257fe5b60200260200101516000015186848151811061019a57fe5b60200260200101516040015161065e565b60028160028111156101b957fe5b14156101f75761015a8583815181106101ce57fe5b6020026020010151600001518684815181106101e657fe5b6020026020010151604001516109ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611539565b506001016100de565b507f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb67383838360405161026693929190611282565b60405180910390a16102788282610acb565b505050565b6000610287610302565b60048101805473ffffffffffffffffffffffffffffffffffffffff8581167fffffffffffffffffffffffff000000000000000000000000000000000000000083168117909355604051939450169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c90565b6000815111610361576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b600061036b610302565b905073ffffffffffffffffffffffffffffffffffffffff83166103ba576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166104ab5761040d8460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106104c557fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff168015610554576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906116e2565b5073ffffffffffffffffffffffffffffffffffffffff86166000818152600186810160209081526040808420805480850182559085528285206008820401805463ffffffff60079093166004026101000a928302191660e089901c929092029190911790557fffffffff00000000000000000000000000000000000000000000000000000000909516835287905292902080547fffffffffffffffffffffffff0000000000000000000000000000000000000000169091177fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff86160217905591820191016104ae565b5050505050565b6000815111610699576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006106a3610302565b905073ffffffffffffffffffffffffffffffffffffffff83166106f2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166107e3576107458460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106107fd57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff908116908716811415610892576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061173f565b61089c8183610cbc565b507fffffffff00000000000000000000000000000000000000000000000000000000811660008181526020868152604080832080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8a160217815573ffffffffffffffffffffffffffffffffffffffff8b168085526001808b018552928520805480850182559086528486206008820401805463ffffffff60079093166004026101000a928302191660e09990991c91909102979097179096559390925286905281547fffffffffffffffffffffffff000000000000000000000000000000000000000016909217905591820191016107e6565b60008151116109e6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006109f0610302565b905073ffffffffffffffffffffffffffffffffffffffff831615610a40576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061179c565b60005b8251811015610ac5576000838281518110610a5a57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529185905260409091205490915073ffffffffffffffffffffffffffffffffffffffff16610abb8183610cbc565b5050600101610a43565b50505050565b73ffffffffffffffffffffffffffffffffffffffff8216610b2457805115610b1f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906113c5565b610c7d565b6000815111610b5f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611628565b73ffffffffffffffffffffffffffffffffffffffff82163014610b9e57610b9e8260405180606001604052806028815260200161182660289139610c81565b6000808373ffffffffffffffffffffffffffffffffffffffff1683604051610bc69190611266565b600060405180830381855af49150503d8060008114610c01576040519150601f19603f3d011682016040523d82523d6000602084013e610c06565b606091505b509150915081610ac557805115610c4b57806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611422565b5050565b813b8181610ac5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6000610cc6610302565b905073ffffffffffffffffffffffffffffffffffffffff8316610d15576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906114dc565b73ffffffffffffffffffffffffffffffffffffffff8316301415610d65576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611685565b7fffffffff0000000000000000000000000000000000000000000000000000000082166000908152602082815260408083205473ffffffffffffffffffffffffffffffffffffffff8716845260018501909252909120547401000000000000000000000000000000000000000090910461ffff16907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01808214610f375773ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260408120805483908110610e3657fe5b6000918252602080832060088304015473ffffffffffffffffffffffffffffffffffffffff8a168452600188019091526040909220805460079092166004026101000a90920460e01b925082919085908110610e8e57fe5b600091825260208083206008830401805463ffffffff60079094166004026101000a938402191660e09590951c929092029390931790557fffffffff000000000000000000000000000000000000000000000000000000009290921682528490526040902080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8516021790555b73ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260409020805480610f6757fe5b6000828152602080822060087fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90940193840401805463ffffffff600460078716026101000a0219169055919092557fffffffff00000000000000000000000000000000000000000000000000000000861682528490526040902080547fffffffffffffffffffff000000000000000000000000000000000000000000001690558061065757600283015473ffffffffffffffffffffffffffffffffffffffff861660009081526001858101602052604090912001547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9091019061ffff1680821461114357600085600201838154811061107e57fe5b60009182526020909120015460028701805473ffffffffffffffffffffffffffffffffffffffff90921692508291849081106110b657fe5b600091825260208083209190910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff9485161790559290911681526001878101909252604090200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff83161790555b8460020180548061115057fe5b6000828152602080822083017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90810180547fffffffffffffffffffffffff000000000000000000000000000000000000000016905590920190925573ffffffffffffffffffffffffffffffffffffffff89168252600187810190915260409091200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000016905550505050505050565b73ffffffffffffffffffffffffffffffffffffffff169052565b600081518084526112348160208601602086016117f9565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b600082516112788184602087016117f9565b9190910192915050565b606080825284518282018190526000919060809081850190602080820287018401818b01875b8481101561137c577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff808a8403018652815188840173ffffffffffffffffffffffffffffffffffffffff8251168552858201516003811061130457fe5b858701526040918201519185018a9052815190819052908501908a90898601905b808310156113675783517fffffffff00000000000000000000000000000000000000000000000000000000168252928701926001929092019190870190611325565b509786019794505050908301906001016112a8565b505061138a8289018b611202565b878103604089015261139c818a61121c565b9b9a5050505050505050505050565b6000602082526113be602083018461121c565b9392505050565b6020808252603c908201527f4c69624469616d6f6e644375743a205f696e697420697320616464726573732860408201527f3029206275745f63616c6c64617461206973206e6f7420656d70747900000000606082015260800190565b60208082526026908201527f4c69624469616d6f6e644375743a205f696e69742066756e6374696f6e20726560408201527f7665727465640000000000000000000000000000000000000000000000000000606082015260800190565b6020808252602b908201527f4c69624469616d6f6e644375743a204e6f2073656c6563746f727320696e206660408201527f6163657420746f20637574000000000000000000000000000000000000000000606082015260800190565b60208082526037908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f76652066756e6360408201527f74696f6e207468617420646f65736e2774206578697374000000000000000000606082015260800190565b60208082526027908201527f4c69624469616d6f6e644375743a20496e636f7272656374204661636574437560408201527f74416374696f6e00000000000000000000000000000000000000000000000000606082015260800190565b6020808252602c908201527f4c69624469616d6f6e644375743a204164642066616365742063616e2774206260408201527f6520616464726573732830290000000000000000000000000000000000000000606082015260800190565b6020808252818101527f4469616d6f6e643a2046756e6374696f6e20646f6573206e6f74206578697374604082015260600190565b6020808252603d908201527f4c69624469616d6f6e644375743a205f63616c6c6461746120697320656d707460408201527f7920627574205f696e6974206973206e6f742061646472657373283029000000606082015260800190565b6020808252602e908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f766520696d6d7560408201527f7461626c652066756e6374696f6e000000000000000000000000000000000000606082015260800190565b60208082526035908201527f4c69624469616d6f6e644375743a2043616e2774206164642066756e6374696f60408201527f6e207468617420616c7265616479206578697374730000000000000000000000606082015260800190565b60208082526038908201527f4c69624469616d6f6e644375743a2043616e2774207265706c6163652066756e60408201527f6374696f6e20776974682073616d652066756e6374696f6e0000000000000000606082015260800190565b60208082526036908201527f4c69624469616d6f6e644375743a2052656d6f7665206661636574206164647260408201527f657373206d757374206265206164647265737328302900000000000000000000606082015260800190565b60005b838110156118145781810151838201526020016117fc565b83811115610ac5575050600091015256fe4c69624469616d6f6e644375743a205f696e6974206164647265737320686173206e6f20636f64654c69624469616d6f6e644375743a204e657720666163657420686173206e6f20636f6465a264697066735822122054a3c3a118803545231f43700030cb5e290869be0182196a4a05e7d4a1b71d7e64736f6c63430007060033", + "facets": [ + ["0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", ["0x1f931c1c"]], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": ["0xc76d202d", "0x839bb9a6", "0x8e756bb3"] + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": ["0x9912dde8", "0x5a601668", "0x8a4f4f92"] + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x01503bAF774aB3aDb6AF79a6fB725c1610D45b2a", + "functionSelectors": ["0xce6e9f9f", "0x02bc2cdb", "0x0448a5c4"] + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": ["0x2239f556", "0x46efd16c", "0x78b248e4"] + }, + { + "facetAddress": "0x2a51f0d8DaA9BB4Dc75597cb77B99BDc1754dE00", + "functionSelectors": ["0x6f70d212", "0x0967aa82", "0x0f48a482"] + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"] + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0xc00e94cb662c3520282e6f5717214004a7f26888" + }, + { + "sym": "AAVE", + "addr": "0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9" + }, + { + "sym": "ADAI", + "addr": "0x028171bCA77440897B824Ca71D1c56caC55b68A3" + }, + { + "sym": "PCDAI", + "addr": "0xEBfb47A7ad0FD6e57323C8A42B2E5A6a4F68fc1a" + }, + { + "sym": "YDAI", + "addr": "0x19D3364A399d251E894aC732651be8B0E4e85001" + }, + { + "sym": "WETH", + "addr": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" + }, + { + "sym": "DAI", + "addr": "0x6B175474E89094C44Da98b954EedeAC495271d0F" + }, + { + "sym": "USDC", + "addr": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" + }, + { + "sym": "USDT", + "addr": "0xdac17f958d2ee523a2206206994597c13d831ec7" + }, + { + "sym": "LINK", + "addr": "0x514910771AF9Ca656af840dff83E8264EcF986CA" + }, + { + "sym": "WBTC", + "addr": "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599" + }, + { + "sym": "SNX", + "addr": "0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f" + }, + { + "sym": "MKR", + "addr": "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2" + }, + { + "sym": "YFI", + "addr": "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e" + } + ], + "cTokens": [ + "0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643", + "0x39aa39c021dfbae8fac545936693ac917d5e7563", + "0x4ddc2d193948926d02f9b1fe9e1daa0718270ed5" + ], + "tellerNFT": "0x2ceB85a2402C94305526ab108e7597a102D6C175", + "loansEscrowBeacon": "0x95F5c6Dbac30Ee95d582926b1b865ab2Ec69AE57", + "collateralEscrowBeacon": "0x3b3692a5e1E82FA02D38d0A5f6EBb0070D84eB70", + "tTokenBeacon": "0xA8E03D0E75FA9a0bBa097266FC8e14284118e0EF", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x719c7ae0fa6711e223c5e41c41adf1558426db72b18235afc452b2dc751023d1", + "receipt": { + "to": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 84, + "gasUsed": "174681", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000100000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020", + "blockHash": "0x7ae5b9cbda1bed2be7cdc04a140c5b194fbe3001c4c36d5ff70e66f50b5ffdd4", + "transactionHash": "0x719c7ae0fa6711e223c5e41c41adf1558426db72b18235afc452b2dc751023d1", + "logs": [ + { + "transactionIndex": 84, + "blockNumber": 12442872, + "transactionHash": "0x719c7ae0fa6711e223c5e41c41adf1558426db72b18235afc452b2dc751023d1", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 79, + "blockHash": "0x7ae5b9cbda1bed2be7cdc04a140c5b194fbe3001c4c36d5ff70e66f50b5ffdd4" + } + ], + "events": [ + { + "transactionIndex": 84, + "blockNumber": 12442872, + "transactionHash": "0x719c7ae0fa6711e223c5e41c41adf1558426db72b18235afc452b2dc751023d1", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 79, + "blockHash": "0x7ae5b9cbda1bed2be7cdc04a140c5b194fbe3001c4c36d5ff70e66f50b5ffdd4", + "args": [ + [ + [ + "0x06D8890A98851081c464a8106d61eA1967d62754", + 1, + ["0xce6e9f9f", "0x02bc2cdb", "0x0448a5c4"] + ] + ], + "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "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" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 12442872, + "cumulativeGasUsed": "4195569", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + ["0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", ["0x1f931c1c"]], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": ["0xc76d202d", "0x839bb9a6", "0x8e756bb3"] + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": ["0x9912dde8", "0x5a601668", "0x8a4f4f92"] + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x06D8890A98851081c464a8106d61eA1967d62754", + "functionSelectors": ["0xce6e9f9f", "0x02bc2cdb", "0x0448a5c4"] + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": ["0x2239f556", "0x46efd16c", "0x78b248e4"] + }, + { + "facetAddress": "0x2a51f0d8DaA9BB4Dc75597cb77B99BDc1754dE00", + "functionSelectors": ["0x6f70d212", "0x0967aa82", "0x0f48a482"] + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"] + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0x06D8890A98851081c464a8106d61eA1967d62754", + "functionSelectors": ["0xce6e9f9f", "0x02bc2cdb", "0x0448a5c4"], + "action": 1 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0xc00e94cb662c3520282e6f5717214004a7f26888" + }, + { + "sym": "AAVE", + "addr": "0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9" + }, + { + "sym": "ADAI", + "addr": "0x028171bCA77440897B824Ca71D1c56caC55b68A3" + }, + { + "sym": "PCDAI", + "addr": "0xEBfb47A7ad0FD6e57323C8A42B2E5A6a4F68fc1a" + }, + { + "sym": "YDAI", + "addr": "0x19D3364A399d251E894aC732651be8B0E4e85001" + }, + { + "sym": "WETH", + "addr": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" + }, + { + "sym": "DAI", + "addr": "0x6B175474E89094C44Da98b954EedeAC495271d0F" + }, + { + "sym": "USDC", + "addr": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" + }, + { + "sym": "USDT", + "addr": "0xdac17f958d2ee523a2206206994597c13d831ec7" + }, + { + "sym": "LINK", + "addr": "0x514910771AF9Ca656af840dff83E8264EcF986CA" + }, + { + "sym": "WBTC", + "addr": "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599" + }, + { + "sym": "SNX", + "addr": "0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f" + }, + { + "sym": "MKR", + "addr": "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2" + }, + { + "sym": "YFI", + "addr": "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e" + } + ], + "cTokens": [ + "0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643", + "0x39aa39c021dfbae8fac545936693ac917d5e7563", + "0x4ddc2d193948926d02f9b1fe9e1daa0718270ed5" + ], + "tellerNFT": "0x2ceB85a2402C94305526ab108e7597a102D6C175", + "loansEscrowBeacon": "0x95F5c6Dbac30Ee95d582926b1b865ab2Ec69AE57", + "collateralEscrowBeacon": "0x3b3692a5e1E82FA02D38d0A5f6EBb0070D84eB70", + "tTokenBeacon": "0xA8E03D0E75FA9a0bBa097266FC8e14284118e0EF", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "history": [ + { + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 7, + "gasUsed": "5726914", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000120000020000008000000800000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000000000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000020000000000000000000000000000000000000000000000000000000000000008020", + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57", + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "logs": [ + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 25, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 26, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000c14d994fe7c5858c93936cc3bd42bb9467d6fb2c", + "logIndex": 27, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 28, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 29, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 30, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 31, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + } + ], + "events": [ + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 25, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 26, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000c14d994fe7c5858c93936cc3bd42bb9467d6fb2c", + "logIndex": 27, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57", + "args": ["0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C"], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 28, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 29, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 30, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 31, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + } + ], + "blockNumber": 12438084, + "cumulativeGasUsed": "6500765", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x01503bAF774aB3aDb6AF79a6fB725c1610D45b2a", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x2a51f0d8DaA9BB4Dc75597cb77B99BDc1754dE00", + "functionSelectors": [ + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ], + "action": 0 + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + ["0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", ["0x1f931c1c"]], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x01503bAF774aB3aDb6AF79a6fB725c1610D45b2a", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x2a51f0d8DaA9BB4Dc75597cb77B99BDc1754dE00", + "functionSelectors": [ + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ] + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0xc00e94cb662c3520282e6f5717214004a7f26888" + }, + { + "sym": "AAVE", + "addr": "0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9" + }, + { + "sym": "ADAI", + "addr": "0x028171bCA77440897B824Ca71D1c56caC55b68A3" + }, + { + "sym": "PCDAI", + "addr": "0xEBfb47A7ad0FD6e57323C8A42B2E5A6a4F68fc1a" + }, + { + "sym": "YDAI", + "addr": "0x19D3364A399d251E894aC732651be8B0E4e85001" + }, + { + "sym": "WETH", + "addr": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" + }, + { + "sym": "DAI", + "addr": "0x6B175474E89094C44Da98b954EedeAC495271d0F" + }, + { + "sym": "USDC", + "addr": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" + }, + { + "sym": "USDT", + "addr": "0xdac17f958d2ee523a2206206994597c13d831ec7" + }, + { + "sym": "LINK", + "addr": "0x514910771AF9Ca656af840dff83E8264EcF986CA" + }, + { + "sym": "WBTC", + "addr": "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599" + }, + { + "sym": "SNX", + "addr": "0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f" + }, + { + "sym": "MKR", + "addr": "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2" + }, + { + "sym": "YFI", + "addr": "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e" + } + ], + "cTokens": [ + "0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643", + "0x39aa39c021dfbae8fac545936693ac917d5e7563", + "0x4ddc2d193948926d02f9b1fe9e1daa0718270ed5" + ], + "tellerNFT": "0x2ceB85a2402C94305526ab108e7597a102D6C175", + "loansEscrowBeacon": "0x95F5c6Dbac30Ee95d582926b1b865ab2Ec69AE57", + "collateralEscrowBeacon": "0x3b3692a5e1E82FA02D38d0A5f6EBb0070D84eB70", + "tTokenBeacon": "0xA8E03D0E75FA9a0bBa097266FC8e14284118e0EF", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x88e01fe91cf0b07c7fdb7abc353c133855f7a2a7689f57c9625c272fad9f323b", + "receipt": { + "to": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 104, + "gasUsed": "202643", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000100000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020", + "blockHash": "0x3a6c889ed5c0d94441c57791453053474b1d52817f07a676a12e8867beeafb55", + "transactionHash": "0x88e01fe91cf0b07c7fdb7abc353c133855f7a2a7689f57c9625c272fad9f323b", + "logs": [ + { + "transactionIndex": 104, + "blockNumber": 12442962, + "transactionHash": "0x88e01fe91cf0b07c7fdb7abc353c133855f7a2a7689f57c9625c272fad9f323b", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 134, + "blockHash": "0x3a6c889ed5c0d94441c57791453053474b1d52817f07a676a12e8867beeafb55" + } + ], + "events": [ + { + "transactionIndex": 104, + "blockNumber": 12442962, + "transactionHash": "0x88e01fe91cf0b07c7fdb7abc353c133855f7a2a7689f57c9625c272fad9f323b", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 134, + "blockHash": "0x3a6c889ed5c0d94441c57791453053474b1d52817f07a676a12e8867beeafb55", + "args": [ + [ + [ + "0xA5EF6445042e9e9Fce4ee8622183956110535F11", + 1, + ["0x6f70d212", "0x0967aa82", "0x0f48a482"] + ], + [ + "0xA5EF6445042e9e9Fce4ee8622183956110535F11", + 0, + ["0xa7baf6fc"] + ] + ], + "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "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" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 12442962, + "cumulativeGasUsed": "6468104", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + ["0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", ["0x1f931c1c"]], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": ["0xc76d202d", "0x839bb9a6", "0x8e756bb3"] + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": ["0x9912dde8", "0x5a601668", "0x8a4f4f92"] + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x06D8890A98851081c464a8106d61eA1967d62754", + "functionSelectors": ["0xce6e9f9f", "0x02bc2cdb", "0x0448a5c4"] + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": ["0x2239f556", "0x46efd16c", "0x78b248e4"] + }, + { + "facetAddress": "0xA5EF6445042e9e9Fce4ee8622183956110535F11", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"] + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0xA5EF6445042e9e9Fce4ee8622183956110535F11", + "functionSelectors": ["0x6f70d212", "0x0967aa82", "0x0f48a482"], + "action": 1 + }, + { + "facetAddress": "0xA5EF6445042e9e9Fce4ee8622183956110535F11", + "functionSelectors": ["0xa7baf6fc"], + "action": 0 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0xc00e94cb662c3520282e6f5717214004a7f26888" + }, + { + "sym": "AAVE", + "addr": "0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9" + }, + { + "sym": "ADAI", + "addr": "0x028171bCA77440897B824Ca71D1c56caC55b68A3" + }, + { + "sym": "PCDAI", + "addr": "0xEBfb47A7ad0FD6e57323C8A42B2E5A6a4F68fc1a" + }, + { + "sym": "YDAI", + "addr": "0x19D3364A399d251E894aC732651be8B0E4e85001" + }, + { + "sym": "WETH", + "addr": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" + }, + { + "sym": "DAI", + "addr": "0x6B175474E89094C44Da98b954EedeAC495271d0F" + }, + { + "sym": "USDC", + "addr": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" + }, + { + "sym": "USDT", + "addr": "0xdac17f958d2ee523a2206206994597c13d831ec7" + }, + { + "sym": "LINK", + "addr": "0x514910771AF9Ca656af840dff83E8264EcF986CA" + }, + { + "sym": "WBTC", + "addr": "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599" + }, + { + "sym": "SNX", + "addr": "0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f" + }, + { + "sym": "MKR", + "addr": "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2" + }, + { + "sym": "YFI", + "addr": "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e" + } + ], + "cTokens": [ + "0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643", + "0x39aa39c021dfbae8fac545936693ac917d5e7563", + "0x4ddc2d193948926d02f9b1fe9e1daa0718270ed5" + ], + "tellerNFT": "0x2ceB85a2402C94305526ab108e7597a102D6C175", + "loansEscrowBeacon": "0x95F5c6Dbac30Ee95d582926b1b865ab2Ec69AE57", + "collateralEscrowBeacon": "0x3b3692a5e1E82FA02D38d0A5f6EBb0070D84eB70", + "tTokenBeacon": "0xA8E03D0E75FA9a0bBa097266FC8e14284118e0EF", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "history": [ + { + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 7, + "gasUsed": "5726914", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000120000020000008000000800000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000000000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000020000000000000000000000000000000000000000000000000000000000000008020", + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57", + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "logs": [ + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 25, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 26, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000c14d994fe7c5858c93936cc3bd42bb9467d6fb2c", + "logIndex": 27, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 28, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 29, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 30, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 31, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + } + ], + "events": [ + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 25, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 26, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000c14d994fe7c5858c93936cc3bd42bb9467d6fb2c", + "logIndex": 27, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57", + "args": ["0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C"], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 28, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 29, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 30, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 31, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + } + ], + "blockNumber": 12438084, + "cumulativeGasUsed": "6500765", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x01503bAF774aB3aDb6AF79a6fB725c1610D45b2a", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x2a51f0d8DaA9BB4Dc75597cb77B99BDc1754dE00", + "functionSelectors": [ + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ], + "action": 0 + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + ["0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", ["0x1f931c1c"]], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x01503bAF774aB3aDb6AF79a6fB725c1610D45b2a", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x2a51f0d8DaA9BB4Dc75597cb77B99BDc1754dE00", + "functionSelectors": [ + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ] + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0xc00e94cb662c3520282e6f5717214004a7f26888" + }, + { + "sym": "AAVE", + "addr": "0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9" + }, + { + "sym": "ADAI", + "addr": "0x028171bCA77440897B824Ca71D1c56caC55b68A3" + }, + { + "sym": "PCDAI", + "addr": "0xEBfb47A7ad0FD6e57323C8A42B2E5A6a4F68fc1a" + }, + { + "sym": "YDAI", + "addr": "0x19D3364A399d251E894aC732651be8B0E4e85001" + }, + { + "sym": "WETH", + "addr": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" + }, + { + "sym": "DAI", + "addr": "0x6B175474E89094C44Da98b954EedeAC495271d0F" + }, + { + "sym": "USDC", + "addr": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" + }, + { + "sym": "USDT", + "addr": "0xdac17f958d2ee523a2206206994597c13d831ec7" + }, + { + "sym": "LINK", + "addr": "0x514910771AF9Ca656af840dff83E8264EcF986CA" + }, + { + "sym": "WBTC", + "addr": "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599" + }, + { + "sym": "SNX", + "addr": "0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f" + }, + { + "sym": "MKR", + "addr": "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2" + }, + { + "sym": "YFI", + "addr": "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e" + } + ], + "cTokens": [ + "0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643", + "0x39aa39c021dfbae8fac545936693ac917d5e7563", + "0x4ddc2d193948926d02f9b1fe9e1daa0718270ed5" + ], + "tellerNFT": "0x2ceB85a2402C94305526ab108e7597a102D6C175", + "loansEscrowBeacon": "0x95F5c6Dbac30Ee95d582926b1b865ab2Ec69AE57", + "collateralEscrowBeacon": "0x3b3692a5e1E82FA02D38d0A5f6EBb0070D84eB70", + "tTokenBeacon": "0xA8E03D0E75FA9a0bBa097266FC8e14284118e0EF", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x719c7ae0fa6711e223c5e41c41adf1558426db72b18235afc452b2dc751023d1", + "receipt": { + "to": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 84, + "gasUsed": "174681", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000100000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020", + "blockHash": "0x7ae5b9cbda1bed2be7cdc04a140c5b194fbe3001c4c36d5ff70e66f50b5ffdd4", + "transactionHash": "0x719c7ae0fa6711e223c5e41c41adf1558426db72b18235afc452b2dc751023d1", + "logs": [ + { + "transactionIndex": 84, + "blockNumber": 12442872, + "transactionHash": "0x719c7ae0fa6711e223c5e41c41adf1558426db72b18235afc452b2dc751023d1", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 79, + "blockHash": "0x7ae5b9cbda1bed2be7cdc04a140c5b194fbe3001c4c36d5ff70e66f50b5ffdd4" + } + ], + "events": [ + { + "transactionIndex": 84, + "blockNumber": 12442872, + "transactionHash": "0x719c7ae0fa6711e223c5e41c41adf1558426db72b18235afc452b2dc751023d1", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 79, + "blockHash": "0x7ae5b9cbda1bed2be7cdc04a140c5b194fbe3001c4c36d5ff70e66f50b5ffdd4", + "args": [ + [ + [ + "0x06D8890A98851081c464a8106d61eA1967d62754", + 1, + ["0xce6e9f9f", "0x02bc2cdb", "0x0448a5c4"] + ] + ], + "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "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" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 12442872, + "cumulativeGasUsed": "4195569", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + ["0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", ["0x1f931c1c"]], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x06D8890A98851081c464a8106d61eA1967d62754", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x2a51f0d8DaA9BB4Dc75597cb77B99BDc1754dE00", + "functionSelectors": [ + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ] + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0x06D8890A98851081c464a8106d61eA1967d62754", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 1 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0xc00e94cb662c3520282e6f5717214004a7f26888" + }, + { + "sym": "AAVE", + "addr": "0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9" + }, + { + "sym": "ADAI", + "addr": "0x028171bCA77440897B824Ca71D1c56caC55b68A3" + }, + { + "sym": "PCDAI", + "addr": "0xEBfb47A7ad0FD6e57323C8A42B2E5A6a4F68fc1a" + }, + { + "sym": "YDAI", + "addr": "0x19D3364A399d251E894aC732651be8B0E4e85001" + }, + { + "sym": "WETH", + "addr": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" + }, + { + "sym": "DAI", + "addr": "0x6B175474E89094C44Da98b954EedeAC495271d0F" + }, + { + "sym": "USDC", + "addr": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" + }, + { + "sym": "USDT", + "addr": "0xdac17f958d2ee523a2206206994597c13d831ec7" + }, + { + "sym": "LINK", + "addr": "0x514910771AF9Ca656af840dff83E8264EcF986CA" + }, + { + "sym": "WBTC", + "addr": "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599" + }, + { + "sym": "SNX", + "addr": "0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f" + }, + { + "sym": "MKR", + "addr": "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2" + }, + { + "sym": "YFI", + "addr": "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e" + } + ], + "cTokens": [ + "0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643", + "0x39aa39c021dfbae8fac545936693ac917d5e7563", + "0x4ddc2d193948926d02f9b1fe9e1daa0718270ed5" + ], + "tellerNFT": "0x2ceB85a2402C94305526ab108e7597a102D6C175", + "loansEscrowBeacon": "0x95F5c6Dbac30Ee95d582926b1b865ab2Ec69AE57", + "collateralEscrowBeacon": "0x3b3692a5e1E82FA02D38d0A5f6EBb0070D84eB70", + "tTokenBeacon": "0xA8E03D0E75FA9a0bBa097266FC8e14284118e0EF", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "history": [ + { + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 7, + "gasUsed": "5726914", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000120000020000008000000800000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000000000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000020000000000000000000000000000000000000000000000000000000000000008020", + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57", + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "logs": [ + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 25, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 26, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000c14d994fe7c5858c93936cc3bd42bb9467d6fb2c", + "logIndex": 27, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 28, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 29, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 30, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 31, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + } + ], + "events": [ + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 25, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 26, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000c14d994fe7c5858c93936cc3bd42bb9467d6fb2c", + "logIndex": 27, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57", + "args": ["0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C"], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 28, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 29, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 30, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 31, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + } + ], + "blockNumber": 12438084, + "cumulativeGasUsed": "6500765", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x01503bAF774aB3aDb6AF79a6fB725c1610D45b2a", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x2a51f0d8DaA9BB4Dc75597cb77B99BDc1754dE00", + "functionSelectors": [ + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ], + "action": 0 + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + [ + "0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", + ["0x1f931c1c"] + ], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x01503bAF774aB3aDb6AF79a6fB725c1610D45b2a", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x2a51f0d8DaA9BB4Dc75597cb77B99BDc1754dE00", + "functionSelectors": [ + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ] + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0xc00e94cb662c3520282e6f5717214004a7f26888" + }, + { + "sym": "AAVE", + "addr": "0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9" + }, + { + "sym": "ADAI", + "addr": "0x028171bCA77440897B824Ca71D1c56caC55b68A3" + }, + { + "sym": "PCDAI", + "addr": "0xEBfb47A7ad0FD6e57323C8A42B2E5A6a4F68fc1a" + }, + { + "sym": "YDAI", + "addr": "0x19D3364A399d251E894aC732651be8B0E4e85001" + }, + { + "sym": "WETH", + "addr": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" + }, + { + "sym": "DAI", + "addr": "0x6B175474E89094C44Da98b954EedeAC495271d0F" + }, + { + "sym": "USDC", + "addr": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" + }, + { + "sym": "USDT", + "addr": "0xdac17f958d2ee523a2206206994597c13d831ec7" + }, + { + "sym": "LINK", + "addr": "0x514910771AF9Ca656af840dff83E8264EcF986CA" + }, + { + "sym": "WBTC", + "addr": "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599" + }, + { + "sym": "SNX", + "addr": "0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f" + }, + { + "sym": "MKR", + "addr": "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2" + }, + { + "sym": "YFI", + "addr": "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e" + } + ], + "cTokens": [ + "0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643", + "0x39aa39c021dfbae8fac545936693ac917d5e7563", + "0x4ddc2d193948926d02f9b1fe9e1daa0718270ed5" + ], + "tellerNFT": "0x2ceB85a2402C94305526ab108e7597a102D6C175", + "loansEscrowBeacon": "0x95F5c6Dbac30Ee95d582926b1b865ab2Ec69AE57", + "collateralEscrowBeacon": "0x3b3692a5e1E82FA02D38d0A5f6EBb0070D84eB70", + "tTokenBeacon": "0xA8E03D0E75FA9a0bBa097266FC8e14284118e0EF", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x7ebc63dfc2d69c9ef12a6d19496e2bede17d556875e55486eae2146ecc1903d6", + "receipt": { + "to": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 323, + "gasUsed": "184761", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000100000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020", + "blockHash": "0x747442fd65baabf6fb1ff23913a2e513e4712a72f29732a3f8cd2ee23044c65f", + "transactionHash": "0x7ebc63dfc2d69c9ef12a6d19496e2bede17d556875e55486eae2146ecc1903d6", + "logs": [ + { + "transactionIndex": 323, + "blockNumber": 12451270, + "transactionHash": "0x7ebc63dfc2d69c9ef12a6d19496e2bede17d556875e55486eae2146ecc1903d6", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 53, + "blockHash": "0x747442fd65baabf6fb1ff23913a2e513e4712a72f29732a3f8cd2ee23044c65f" + } + ], + "events": [ + { + "transactionIndex": 323, + "blockNumber": 12451270, + "transactionHash": "0x7ebc63dfc2d69c9ef12a6d19496e2bede17d556875e55486eae2146ecc1903d6", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 53, + "blockHash": "0x747442fd65baabf6fb1ff23913a2e513e4712a72f29732a3f8cd2ee23044c65f", + "args": [ + [ + [ + "0x1843F635aE17eae7763b14C02E0288DAC806A680", + 1, + ["0xe89ad656", "0x5ebc6334", "0xccdd9f5d", "0x8a700b53"] + ] + ], + "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "0x1cf14f330000000000000000000000000000000000000000000000000000000000000020000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000009e00000000000000000000000002ceb85a2402c94305526ab108e7597a102d6c17500000000000000000000000095f5c6dbac30ee95d582926b1b865ab2ec69ae570000000000000000000000003b3692a5e1e82fa02d38d0a5f6ebb0070d84eb70000000000000000000000000a8e03d0e75fa9a0bba097266fc8e14284118e0ef00000000000000000000000095143890162bd671d77ae9b771881a1cb76c29a4000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000001c0000000000000000000000000000000000000000000000000000000000000024000000000000000000000000000000000000000000000000000000000000002c0000000000000000000000000000000000000000000000000000000000000034000000000000000000000000000000000000000000000000000000000000003c0000000000000000000000000000000000000000000000000000000000000044000000000000000000000000000000000000000000000000000000000000004c0000000000000000000000000000000000000000000000000000000000000054000000000000000000000000000000000000000000000000000000000000005c0000000000000000000000000000000000000000000000000000000000000064000000000000000000000000000000000000000000000000000000000000006c0000000000000000000000000000000000000000000000000000000000000074000000000000000000000000000000000000000000000000000000000000007c000000000000000000000000000000000000000000000000000000000000008400000000000000000000000000000000000000000000000000000000000000040000000000000000000000000c00e94cb662c3520282e6f5717214004a7f268880000000000000000000000000000000000000000000000000000000000000004434f4d500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000007fc66500c84a76ad7e9c93437bfc5ac33e2ddae9000000000000000000000000000000000000000000000000000000000000000441415645000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000028171bca77440897b824ca71d1c56cac55b68a3000000000000000000000000000000000000000000000000000000000000000441444149000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000ebfb47a7ad0fd6e57323c8a42b2e5a6a4f68fc1a00000000000000000000000000000000000000000000000000000000000000055043444149000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000019d3364a399d251e894ac732651be8b0e4e85001000000000000000000000000000000000000000000000000000000000000000459444149000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc20000000000000000000000000000000000000000000000000000000000000004574554480000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000006b175474e89094c44da98b954eedeac495271d0f000000000000000000000000000000000000000000000000000000000000000344414900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48000000000000000000000000000000000000000000000000000000000000000455534443000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7000000000000000000000000000000000000000000000000000000000000000455534454000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000514910771af9ca656af840dff83e8264ecf986ca00000000000000000000000000000000000000000000000000000000000000044c494e4b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000002260fac5e5542a773aa44fbcfedf7c193bc2c599000000000000000000000000000000000000000000000000000000000000000457425443000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000c011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f0000000000000000000000000000000000000000000000000000000000000003534e58000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000009f8f72aa9304c8b593d555f12ef6589cc3a579a200000000000000000000000000000000000000000000000000000000000000034d4b52000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000bc529c00c6401aef6d220be8c6ea1667f6ad93e0000000000000000000000000000000000000000000000000000000000000003594649000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000030000000000000000000000005d3a536e4d6dbd6114cc1ead35777bab948e364300000000000000000000000039aa39c021dfbae8fac545936693ac917d5e75630000000000000000000000004ddc2d193948926d02f9b1fe9e1daa0718270ed5" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 12451270, + "cumulativeGasUsed": "8732510", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + ["0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", ["0x1f931c1c"]], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": ["0xc76d202d", "0x839bb9a6", "0x8e756bb3"] + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": ["0x9912dde8", "0x5a601668", "0x8a4f4f92"] + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x06D8890A98851081c464a8106d61eA1967d62754", + "functionSelectors": ["0xce6e9f9f", "0x02bc2cdb", "0x0448a5c4"] + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0x1843F635aE17eae7763b14C02E0288DAC806A680", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": ["0x2239f556", "0x46efd16c", "0x78b248e4"] + }, + { + "facetAddress": "0xA5EF6445042e9e9Fce4ee8622183956110535F11", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": ["0x7197d575", "0x3ca4c96b", "0x5d86dbe7"] + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0xc00e94cb662c3520282e6f5717214004a7f26888" + }, + { + "sym": "AAVE", + "addr": "0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9" + }, + { + "sym": "ADAI", + "addr": "0x028171bCA77440897B824Ca71D1c56caC55b68A3" + }, + { + "sym": "PCDAI", + "addr": "0xEBfb47A7ad0FD6e57323C8A42B2E5A6a4F68fc1a" + }, + { + "sym": "YDAI", + "addr": "0x19D3364A399d251E894aC732651be8B0E4e85001" + }, + { + "sym": "WETH", + "addr": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" + }, + { + "sym": "DAI", + "addr": "0x6B175474E89094C44Da98b954EedeAC495271d0F" + }, + { + "sym": "USDC", + "addr": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" + }, + { + "sym": "USDT", + "addr": "0xdac17f958d2ee523a2206206994597c13d831ec7" + }, + { + "sym": "LINK", + "addr": "0x514910771AF9Ca656af840dff83E8264EcF986CA" + }, + { + "sym": "WBTC", + "addr": "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599" + }, + { + "sym": "SNX", + "addr": "0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f" + }, + { + "sym": "MKR", + "addr": "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2" + }, + { + "sym": "YFI", + "addr": "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e" + } + ], + "cTokens": [ + "0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643", + "0x39aa39c021dfbae8fac545936693ac917d5e7563", + "0x4ddc2d193948926d02f9b1fe9e1daa0718270ed5" + ], + "tellerNFT": "0x2ceB85a2402C94305526ab108e7597a102D6C175", + "loansEscrowBeacon": "0x95F5c6Dbac30Ee95d582926b1b865ab2Ec69AE57", + "collateralEscrowBeacon": "0x3b3692a5e1E82FA02D38d0A5f6EBb0070D84eB70", + "tTokenBeacon": "0xA8E03D0E75FA9a0bBa097266FC8e14284118e0EF", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "history": [ + { + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 7, + "gasUsed": "5726914", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000120000020000008000000800000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000000000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000020000000000000000000000000000000000000000000000000000000000000008020", + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57", + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "logs": [ + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 25, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 26, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000c14d994fe7c5858c93936cc3bd42bb9467d6fb2c", + "logIndex": 27, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 28, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 29, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 30, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 31, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + } + ], + "events": [ + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 25, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 26, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000c14d994fe7c5858c93936cc3bd42bb9467d6fb2c", + "logIndex": 27, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57", + "args": ["0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C"], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 28, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 29, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 30, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 31, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + } + ], + "blockNumber": 12438084, + "cumulativeGasUsed": "6500765", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x01503bAF774aB3aDb6AF79a6fB725c1610D45b2a", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x2a51f0d8DaA9BB4Dc75597cb77B99BDc1754dE00", + "functionSelectors": [ + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ], + "action": 0 + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + ["0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", ["0x1f931c1c"]], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x01503bAF774aB3aDb6AF79a6fB725c1610D45b2a", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x2a51f0d8DaA9BB4Dc75597cb77B99BDc1754dE00", + "functionSelectors": [ + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ] + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0xc00e94cb662c3520282e6f5717214004a7f26888" + }, + { + "sym": "AAVE", + "addr": "0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9" + }, + { + "sym": "ADAI", + "addr": "0x028171bCA77440897B824Ca71D1c56caC55b68A3" + }, + { + "sym": "PCDAI", + "addr": "0xEBfb47A7ad0FD6e57323C8A42B2E5A6a4F68fc1a" + }, + { + "sym": "YDAI", + "addr": "0x19D3364A399d251E894aC732651be8B0E4e85001" + }, + { + "sym": "WETH", + "addr": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" + }, + { + "sym": "DAI", + "addr": "0x6B175474E89094C44Da98b954EedeAC495271d0F" + }, + { + "sym": "USDC", + "addr": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" + }, + { + "sym": "USDT", + "addr": "0xdac17f958d2ee523a2206206994597c13d831ec7" + }, + { + "sym": "LINK", + "addr": "0x514910771AF9Ca656af840dff83E8264EcF986CA" + }, + { + "sym": "WBTC", + "addr": "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599" + }, + { + "sym": "SNX", + "addr": "0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f" + }, + { + "sym": "MKR", + "addr": "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2" + }, + { + "sym": "YFI", + "addr": "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e" + } + ], + "cTokens": [ + "0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643", + "0x39aa39c021dfbae8fac545936693ac917d5e7563", + "0x4ddc2d193948926d02f9b1fe9e1daa0718270ed5" + ], + "tellerNFT": "0x2ceB85a2402C94305526ab108e7597a102D6C175", + "loansEscrowBeacon": "0x95F5c6Dbac30Ee95d582926b1b865ab2Ec69AE57", + "collateralEscrowBeacon": "0x3b3692a5e1E82FA02D38d0A5f6EBb0070D84eB70", + "tTokenBeacon": "0xA8E03D0E75FA9a0bBa097266FC8e14284118e0EF", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x719c7ae0fa6711e223c5e41c41adf1558426db72b18235afc452b2dc751023d1", + "receipt": { + "to": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 84, + "gasUsed": "174681", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000100000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020", + "blockHash": "0x7ae5b9cbda1bed2be7cdc04a140c5b194fbe3001c4c36d5ff70e66f50b5ffdd4", + "transactionHash": "0x719c7ae0fa6711e223c5e41c41adf1558426db72b18235afc452b2dc751023d1", + "logs": [ + { + "transactionIndex": 84, + "blockNumber": 12442872, + "transactionHash": "0x719c7ae0fa6711e223c5e41c41adf1558426db72b18235afc452b2dc751023d1", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 79, + "blockHash": "0x7ae5b9cbda1bed2be7cdc04a140c5b194fbe3001c4c36d5ff70e66f50b5ffdd4" + } + ], + "events": [ + { + "transactionIndex": 84, + "blockNumber": 12442872, + "transactionHash": "0x719c7ae0fa6711e223c5e41c41adf1558426db72b18235afc452b2dc751023d1", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 79, + "blockHash": "0x7ae5b9cbda1bed2be7cdc04a140c5b194fbe3001c4c36d5ff70e66f50b5ffdd4", + "args": [ + [ + [ + "0x06D8890A98851081c464a8106d61eA1967d62754", + 1, + ["0xce6e9f9f", "0x02bc2cdb", "0x0448a5c4"] + ] + ], + "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "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" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 12442872, + "cumulativeGasUsed": "4195569", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + ["0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", ["0x1f931c1c"]], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x06D8890A98851081c464a8106d61eA1967d62754", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x2a51f0d8DaA9BB4Dc75597cb77B99BDc1754dE00", + "functionSelectors": [ + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ] + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0x06D8890A98851081c464a8106d61eA1967d62754", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 1 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0xc00e94cb662c3520282e6f5717214004a7f26888" + }, + { + "sym": "AAVE", + "addr": "0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9" + }, + { + "sym": "ADAI", + "addr": "0x028171bCA77440897B824Ca71D1c56caC55b68A3" + }, + { + "sym": "PCDAI", + "addr": "0xEBfb47A7ad0FD6e57323C8A42B2E5A6a4F68fc1a" + }, + { + "sym": "YDAI", + "addr": "0x19D3364A399d251E894aC732651be8B0E4e85001" + }, + { + "sym": "WETH", + "addr": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" + }, + { + "sym": "DAI", + "addr": "0x6B175474E89094C44Da98b954EedeAC495271d0F" + }, + { + "sym": "USDC", + "addr": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" + }, + { + "sym": "USDT", + "addr": "0xdac17f958d2ee523a2206206994597c13d831ec7" + }, + { + "sym": "LINK", + "addr": "0x514910771AF9Ca656af840dff83E8264EcF986CA" + }, + { + "sym": "WBTC", + "addr": "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599" + }, + { + "sym": "SNX", + "addr": "0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f" + }, + { + "sym": "MKR", + "addr": "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2" + }, + { + "sym": "YFI", + "addr": "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e" + } + ], + "cTokens": [ + "0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643", + "0x39aa39c021dfbae8fac545936693ac917d5e7563", + "0x4ddc2d193948926d02f9b1fe9e1daa0718270ed5" + ], + "tellerNFT": "0x2ceB85a2402C94305526ab108e7597a102D6C175", + "loansEscrowBeacon": "0x95F5c6Dbac30Ee95d582926b1b865ab2Ec69AE57", + "collateralEscrowBeacon": "0x3b3692a5e1E82FA02D38d0A5f6EBb0070D84eB70", + "tTokenBeacon": "0xA8E03D0E75FA9a0bBa097266FC8e14284118e0EF", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "history": [ + { + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 7, + "gasUsed": "5726914", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000120000020000008000000800000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000000000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000020000000000000000000000000000000000000000000000000000000000000008020", + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57", + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "logs": [ + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 25, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 26, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000c14d994fe7c5858c93936cc3bd42bb9467d6fb2c", + "logIndex": 27, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 28, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 29, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 30, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 31, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + } + ], + "events": [ + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 25, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 26, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000c14d994fe7c5858c93936cc3bd42bb9467d6fb2c", + "logIndex": 27, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57", + "args": ["0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C"], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000c14d994fe7c5858c93936cc3bd42bb9467d6fb2c00000000000000000000000000000000000000000000000000000000000012e0000000000000000000000000000000000000000000000000000000000000001100000000000000000000000000000000000000000000000000000000000002200000000000000000000000000000000000000000000000000000000000000380000000000000000000000000000000000000000000000000000000000000048000000000000000000000000000000000000000000000000000000000000005600000000000000000000000000000000000000000000000000000000000000660000000000000000000000000000000000000000000000000000000000000072000000000000000000000000000000000000000000000000000000000000007e000000000000000000000000000000000000000000000000000000000000008e000000000000000000000000000000000000000000000000000000000000009c00000000000000000000000000000000000000000000000000000000000000ae00000000000000000000000000000000000000000000000000000000000000bc00000000000000000000000000000000000000000000000000000000000000d800000000000000000000000000000000000000000000000000000000000000e800000000000000000000000000000000000000000000000000000000000000f60000000000000000000000000000000000000000000000000000000000000104000000000000000000000000000000000000000000000000000000000000010e000000000000000000000000000000000000000000000000000000000000011c00000000000000000000000001caa9fd102b88813a6a52792703f1307fe8e5e9200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000742f1181e000000000000000000000000000000000000000000000000000000006eade577000000000000000000000000000000000000000000000000000000004dc2304d00000000000000000000000000000000000000000000000000000000ad21879e000000000000000000000000000000000000000000000000000000001cf14f330000000000000000000000000000000000000000000000000000000070712939000000000000000000000000000000000000000000000000000000006e4d22c200000000000000000000000000000000000000000000000000000000000000000000000000000000ef2508e1673bd0bc26379d2b7d43c0a8047e92b40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000049dec88b900000000000000000000000000000000000000000000000000000000ce19912900000000000000000000000000000000000000000000000000000000d10a0aec0000000000000000000000000000000000000000000000000000000074b1d75d00000000000000000000000000000000000000000000000000000000000000000000000000000000a9777f43f61562dcad8a209fed4af1e0cb6c2623000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003c76d202d00000000000000000000000000000000000000000000000000000000839bb9a6000000000000000000000000000000000000000000000000000000008e756bb3000000000000000000000000000000000000000000000000000000000000000000000000000000002d6db3a2e4a14cf90e502d35c544cff26131fb53000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004fee2792b00000000000000000000000000000000000000000000000000000000bf6d79ab00000000000000000000000000000000000000000000000000000000c1c52f8800000000000000000000000000000000000000000000000000000000ec1c2bb5000000000000000000000000000000000000000000000000000000000000000000000000000000003425c0cab7b6fa2729181e24aecf21a5eb8f968f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002241b71bb00000000000000000000000000000000000000000000000000000000bb14516c00000000000000000000000000000000000000000000000000000000000000000000000000000000fcb61eb1d058557db0fbf971c096d5b628cedc7500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000235a7206d00000000000000000000000000000000000000000000000000000000c05b1ec3000000000000000000000000000000000000000000000000000000000000000000000000000000008075462bc2d2f2587cc9874199729bc7a3226eca000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004961113df0000000000000000000000000000000000000000000000000000000010d94006000000000000000000000000000000000000000000000000000000008fe2b41400000000000000000000000000000000000000000000000000000000020ce3a600000000000000000000000000000000000000000000000000000000000000000000000000000000ddd76632bca1fc65e2832f0652d601d08339cca60000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000039912dde8000000000000000000000000000000000000000000000000000000005a601668000000000000000000000000000000000000000000000000000000008a4f4f92000000000000000000000000000000000000000000000000000000000000000000000000000000000308917d99aa92d7e5f27ceca5250fa09a2224aa00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000513abaf0700000000000000000000000000000000000000000000000000000000ece1373200000000000000000000000000000000000000000000000000000000ed903f7a00000000000000000000000000000000000000000000000000000000010d573000000000000000000000000000000000000000000000000000000000767a7b050000000000000000000000000000000000000000000000000000000000000000000000000000000001503baf774ab3adb6af79a6fb725c1610d45b2a000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003ce6e9f9f0000000000000000000000000000000000000000000000000000000002bc2cdb000000000000000000000000000000000000000000000000000000000448a5c4000000000000000000000000000000000000000000000000000000000000000000000000000000007c8bf7f55f3140c8ea68448a3c503546a86aef1e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000aeee8b7ff0000000000000000000000000000000000000000000000000000000072e1132700000000000000000000000000000000000000000000000000000000f4f015700000000000000000000000000000000000000000000000000000000046a384be00000000000000000000000000000000000000000000000000000000e949756100000000000000000000000000000000000000000000000000000000504006ca00000000000000000000000000000000000000000000000000000000c4c1662b00000000000000000000000000000000000000000000000000000000bddffdc4000000000000000000000000000000000000000000000000000000000634612f000000000000000000000000000000000000000000000000000000003b92930000000000000000000000000000000000000000000000000000000000000000000000000000000000624edbd5e58341617d6683eae1985f7560ee1660000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b530000000000000000000000000000000000000000000000000000000000000000000000000000000036a1f5d199ad88b93623ee1444a43d24a2da0ec50000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000032239f5560000000000000000000000000000000000000000000000000000000046efd16c0000000000000000000000000000000000000000000000000000000078b248e4000000000000000000000000000000000000000000000000000000000000000000000000000000002a51f0d8daa9bb4dc75597cb77b99bdc1754de000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000036f70d212000000000000000000000000000000000000000000000000000000000967aa82000000000000000000000000000000000000000000000000000000000f48a48200000000000000000000000000000000000000000000000000000000000000000000000000000000b86de5840485eb7ba11e7771eb52342492f6f26400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000146e04a2f0000000000000000000000000000000000000000000000000000000000000000000000000000000025ff8028cde05c4d875d651b5cf0e4acfd7a34b30000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000037197d575000000000000000000000000000000000000000000000000000000003ca4c96b000000000000000000000000000000000000000000000000000000005d86dbe700000000000000000000000000000000000000000000000000000000000000000000000000000000998b447e1d20535e154acd0ea2b574c761a535ba000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000001262201b6000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a841cf14f330000000000000000000000000000000000000000000000000000000000000020000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000009e00000000000000000000000002ceb85a2402c94305526ab108e7597a102d6c17500000000000000000000000095f5c6dbac30ee95d582926b1b865ab2ec69ae570000000000000000000000003b3692a5e1e82fa02d38d0a5f6ebb0070d84eb70000000000000000000000000a8e03d0e75fa9a0bba097266fc8e14284118e0ef00000000000000000000000095143890162bd671d77ae9b771881a1cb76c29a4000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000001c0000000000000000000000000000000000000000000000000000000000000024000000000000000000000000000000000000000000000000000000000000002c0000000000000000000000000000000000000000000000000000000000000034000000000000000000000000000000000000000000000000000000000000003c0000000000000000000000000000000000000000000000000000000000000044000000000000000000000000000000000000000000000000000000000000004c0000000000000000000000000000000000000000000000000000000000000054000000000000000000000000000000000000000000000000000000000000005c0000000000000000000000000000000000000000000000000000000000000064000000000000000000000000000000000000000000000000000000000000006c0000000000000000000000000000000000000000000000000000000000000074000000000000000000000000000000000000000000000000000000000000007c000000000000000000000000000000000000000000000000000000000000008400000000000000000000000000000000000000000000000000000000000000040000000000000000000000000c00e94cb662c3520282e6f5717214004a7f268880000000000000000000000000000000000000000000000000000000000000004434f4d500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000007fc66500c84a76ad7e9c93437bfc5ac33e2ddae9000000000000000000000000000000000000000000000000000000000000000441415645000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000028171bca77440897b824ca71d1c56cac55b68a3000000000000000000000000000000000000000000000000000000000000000441444149000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000ebfb47a7ad0fd6e57323c8a42b2e5a6a4f68fc1a00000000000000000000000000000000000000000000000000000000000000055043444149000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000019d3364a399d251e894ac732651be8b0e4e85001000000000000000000000000000000000000000000000000000000000000000459444149000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc20000000000000000000000000000000000000000000000000000000000000004574554480000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000006b175474e89094c44da98b954eedeac495271d0f000000000000000000000000000000000000000000000000000000000000000344414900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48000000000000000000000000000000000000000000000000000000000000000455534443000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7000000000000000000000000000000000000000000000000000000000000000455534454000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000514910771af9ca656af840dff83e8264ecf986ca00000000000000000000000000000000000000000000000000000000000000044c494e4b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000002260fac5e5542a773aa44fbcfedf7c193bc2c599000000000000000000000000000000000000000000000000000000000000000457425443000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000c011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f0000000000000000000000000000000000000000000000000000000000000003534e58000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000009f8f72aa9304c8b593d555f12ef6589cc3a579a200000000000000000000000000000000000000000000000000000000000000034d4b52000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000bc529c00c6401aef6d220be8c6ea1667f6ad93e0000000000000000000000000000000000000000000000000000000000000003594649000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000030000000000000000000000005d3a536e4d6dbd6114cc1ead35777bab948e364300000000000000000000000039aa39c021dfbae8fac545936693ac917d5e75630000000000000000000000004ddc2d193948926d02f9b1fe9e1daa0718270ed500000000000000000000000000000000000000000000000000000000", + "logIndex": 28, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 29, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 30, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 31, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + } + ], + "blockNumber": 12438084, + "cumulativeGasUsed": "6500765", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x01503bAF774aB3aDb6AF79a6fB725c1610D45b2a", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x2a51f0d8DaA9BB4Dc75597cb77B99BDc1754dE00", + "functionSelectors": [ + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ], + "action": 0 + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + [ + "0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", + ["0x1f931c1c"] + ], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x01503bAF774aB3aDb6AF79a6fB725c1610D45b2a", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x2a51f0d8DaA9BB4Dc75597cb77B99BDc1754dE00", + "functionSelectors": [ + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ] + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0xc00e94cb662c3520282e6f5717214004a7f26888" + }, + { + "sym": "AAVE", + "addr": "0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9" + }, + { + "sym": "ADAI", + "addr": "0x028171bCA77440897B824Ca71D1c56caC55b68A3" + }, + { + "sym": "PCDAI", + "addr": "0xEBfb47A7ad0FD6e57323C8A42B2E5A6a4F68fc1a" + }, + { + "sym": "YDAI", + "addr": "0x19D3364A399d251E894aC732651be8B0E4e85001" + }, + { + "sym": "WETH", + "addr": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" + }, + { + "sym": "DAI", + "addr": "0x6B175474E89094C44Da98b954EedeAC495271d0F" + }, + { + "sym": "USDC", + "addr": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" + }, + { + "sym": "USDT", + "addr": "0xdac17f958d2ee523a2206206994597c13d831ec7" + }, + { + "sym": "LINK", + "addr": "0x514910771AF9Ca656af840dff83E8264EcF986CA" + }, + { + "sym": "WBTC", + "addr": "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599" + }, + { + "sym": "SNX", + "addr": "0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f" + }, + { + "sym": "MKR", + "addr": "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2" + }, + { + "sym": "YFI", + "addr": "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e" + } + ], + "cTokens": [ + "0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643", + "0x39aa39c021dfbae8fac545936693ac917d5e7563", + "0x4ddc2d193948926d02f9b1fe9e1daa0718270ed5" + ], + "tellerNFT": "0x2ceB85a2402C94305526ab108e7597a102D6C175", + "loansEscrowBeacon": "0x95F5c6Dbac30Ee95d582926b1b865ab2Ec69AE57", + "collateralEscrowBeacon": "0x3b3692a5e1E82FA02D38d0A5f6EBb0070D84eB70", + "tTokenBeacon": "0xA8E03D0E75FA9a0bBa097266FC8e14284118e0EF", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x88e01fe91cf0b07c7fdb7abc353c133855f7a2a7689f57c9625c272fad9f323b", + "receipt": { + "to": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 104, + "gasUsed": "202643", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000100000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020", + "blockHash": "0x3a6c889ed5c0d94441c57791453053474b1d52817f07a676a12e8867beeafb55", + "transactionHash": "0x88e01fe91cf0b07c7fdb7abc353c133855f7a2a7689f57c9625c272fad9f323b", + "logs": [ + { + "transactionIndex": 104, + "blockNumber": 12442962, + "transactionHash": "0x88e01fe91cf0b07c7fdb7abc353c133855f7a2a7689f57c9625c272fad9f323b", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 134, + "blockHash": "0x3a6c889ed5c0d94441c57791453053474b1d52817f07a676a12e8867beeafb55" + } + ], + "events": [ + { + "transactionIndex": 104, + "blockNumber": 12442962, + "transactionHash": "0x88e01fe91cf0b07c7fdb7abc353c133855f7a2a7689f57c9625c272fad9f323b", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000c14d994fe7c5858c93936cc3bd42bb9467d6fb2c0000000000000000000000000000000000000000000000000000000000000240000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000120000000000000000000000000a5ef6445042e9e9fce4ee8622183956110535f110000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000036f70d212000000000000000000000000000000000000000000000000000000000967aa82000000000000000000000000000000000000000000000000000000000f48a48200000000000000000000000000000000000000000000000000000000000000000000000000000000a5ef6445042e9e9fce4ee8622183956110535f11000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000001a7baf6fc000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a841cf14f330000000000000000000000000000000000000000000000000000000000000020000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000009e00000000000000000000000002ceb85a2402c94305526ab108e7597a102d6c17500000000000000000000000095f5c6dbac30ee95d582926b1b865ab2ec69ae570000000000000000000000003b3692a5e1e82fa02d38d0a5f6ebb0070d84eb70000000000000000000000000a8e03d0e75fa9a0bba097266fc8e14284118e0ef00000000000000000000000095143890162bd671d77ae9b771881a1cb76c29a4000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000001c0000000000000000000000000000000000000000000000000000000000000024000000000000000000000000000000000000000000000000000000000000002c0000000000000000000000000000000000000000000000000000000000000034000000000000000000000000000000000000000000000000000000000000003c0000000000000000000000000000000000000000000000000000000000000044000000000000000000000000000000000000000000000000000000000000004c0000000000000000000000000000000000000000000000000000000000000054000000000000000000000000000000000000000000000000000000000000005c0000000000000000000000000000000000000000000000000000000000000064000000000000000000000000000000000000000000000000000000000000006c0000000000000000000000000000000000000000000000000000000000000074000000000000000000000000000000000000000000000000000000000000007c000000000000000000000000000000000000000000000000000000000000008400000000000000000000000000000000000000000000000000000000000000040000000000000000000000000c00e94cb662c3520282e6f5717214004a7f268880000000000000000000000000000000000000000000000000000000000000004434f4d500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000007fc66500c84a76ad7e9c93437bfc5ac33e2ddae9000000000000000000000000000000000000000000000000000000000000000441415645000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000028171bca77440897b824ca71d1c56cac55b68a3000000000000000000000000000000000000000000000000000000000000000441444149000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000ebfb47a7ad0fd6e57323c8a42b2e5a6a4f68fc1a00000000000000000000000000000000000000000000000000000000000000055043444149000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000019d3364a399d251e894ac732651be8b0e4e85001000000000000000000000000000000000000000000000000000000000000000459444149000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc20000000000000000000000000000000000000000000000000000000000000004574554480000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000006b175474e89094c44da98b954eedeac495271d0f000000000000000000000000000000000000000000000000000000000000000344414900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48000000000000000000000000000000000000000000000000000000000000000455534443000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7000000000000000000000000000000000000000000000000000000000000000455534454000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000514910771af9ca656af840dff83e8264ecf986ca00000000000000000000000000000000000000000000000000000000000000044c494e4b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000002260fac5e5542a773aa44fbcfedf7c193bc2c599000000000000000000000000000000000000000000000000000000000000000457425443000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000c011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f0000000000000000000000000000000000000000000000000000000000000003534e58000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000009f8f72aa9304c8b593d555f12ef6589cc3a579a200000000000000000000000000000000000000000000000000000000000000034d4b52000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000bc529c00c6401aef6d220be8c6ea1667f6ad93e0000000000000000000000000000000000000000000000000000000000000003594649000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000030000000000000000000000005d3a536e4d6dbd6114cc1ead35777bab948e364300000000000000000000000039aa39c021dfbae8fac545936693ac917d5e75630000000000000000000000004ddc2d193948926d02f9b1fe9e1daa0718270ed500000000000000000000000000000000000000000000000000000000", + "logIndex": 134, + "blockHash": "0x3a6c889ed5c0d94441c57791453053474b1d52817f07a676a12e8867beeafb55", + "args": [ + [ + [ + "0xA5EF6445042e9e9Fce4ee8622183956110535F11", + 1, + ["0x6f70d212", "0x0967aa82", "0x0f48a482"] + ], + [ + "0xA5EF6445042e9e9Fce4ee8622183956110535F11", + 0, + ["0xa7baf6fc"] + ] + ], + "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "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" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 12442962, + "cumulativeGasUsed": "6468104", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "0x608060405260405162002d4538038062002d45833981016040819052620000269162000db2565b604080516000808252602082019092526200004e918491620000f560201b620000db1760201c565b620000688160000151620002b560201b6200027d1760201c565b60006200007f6200031760201b620003021760201c565b6301ffc9a760e01b600090815260039091016020526040808220805460ff1990811660019081179092556307e4c70760e21b845282842080548216831790556348e2b09360e01b845282842080548216831790556307f5828d60e41b845291909220805490911690911790555062001442915050565b60005b8351811015620002665760008482815181106200011157fe5b6020026020010151602001519050600060028111156200012d57fe5b8160028111156200013a57fe5b14156200018957620001838583815181106200015257fe5b6020026020010151600001518684815181106200016b57fe5b6020026020010151604001516200033b60201b60201c565b6200025c565b60018160028111156200019857fe5b1415620001e15762000183858381518110620001b057fe5b602002602001015160000151868481518110620001c957fe5b6020026020010151604001516200054e60201b60201c565b6002816002811115620001f057fe5b14156200023957620001838583815181106200020857fe5b6020026020010151600001518684815181106200022157fe5b6020026020010151604001516200077860201b60201c565b60405162461bcd60e51b815260040162000253906200117c565b60405180910390fd5b50600101620000f8565b507f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb6738383836040516200029c9392919062000f25565b60405180910390a1620002b082826200083f565b505050565b6000620002c162000317565b6004810180546001600160a01b038581166001600160a01b031983168117909355604051939450169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c90565b60008151116200035f5760405162461bcd60e51b81526004016200025390620010d4565b60006200036b62000317565b90506001600160a01b038316620003965760405162461bcd60e51b81526004016200025390620011c3565b6001600160a01b038316600090815260018201602052604090205461ffff81166200043c57620003e08460405180606001604052806024815260200162002d21602491396200097c565b6002820180546001600160a01b038616600081815260018087016020908152604083208201805461ffff191661ffff90961695909517909455845490810185559381529190912090910180546001600160a01b03191690911790555b60005b8351811015620005475760008482815181106200045857fe5b6020908102919091018101516001600160e01b031981166000908152918690526040909120549091506001600160a01b03168015620004ab5760405162461bcd60e51b81526004016200025390620012ba565b506001600160a01b0386166000818152600186810160209081526040808420805480850182559085528285206008820401805463ffffffff60079093166004026101000a928302191660e089901c929092029190911790556001600160e01b0319909516835287905292902080546001600160a01b03191690911761ffff60a01b1916600160a01b61ffff86160217905591820191016200043f565b5050505050565b6000815111620005725760405162461bcd60e51b81526004016200025390620010d4565b60006200057e62000317565b90506001600160a01b038316620005a95760405162461bcd60e51b81526004016200025390620011c3565b6001600160a01b038316600090815260018201602052604090205461ffff81166200064f57620005f38460405180606001604052806024815260200162002d21602491396200097c565b6002820180546001600160a01b038616600081815260018087016020908152604083208201805461ffff191661ffff90961695909517909455845490810185559381529190912090910180546001600160a01b03191690911790555b60005b8351811015620005475760008482815181106200066b57fe5b6020908102919091018101516001600160e01b031981166000908152918690526040909120549091506001600160a01b03908116908716811415620006c45760405162461bcd60e51b8152600401620002539062001317565b620006d08183620009a0565b506001600160e01b03198116600081815260208681526040808320805461ffff60a01b1916600160a01b61ffff8a16021781556001600160a01b038b168085526001808b018552928520805480850182559086528486206008820401805463ffffffff60079093166004026101000a928302191660e09990991c91909102979097179096559390925286905281546001600160a01b0319169092179055918201910162000652565b60008151116200079c5760405162461bcd60e51b81526004016200025390620010d4565b6000620007a862000317565b90506001600160a01b03831615620007d45760405162461bcd60e51b8152600401620002539062001374565b60005b825181101562000839576000838281518110620007f057fe5b6020908102919091018101516001600160e01b031981166000908152918590526040909120549091506001600160a01b03166200082e8183620009a0565b5050600101620007d7565b50505050565b6001600160a01b0382166200087657805115620008705760405162461bcd60e51b8152600401620002539062001031565b62000978565b60008151116200089a5760405162461bcd60e51b815260040162000253906200120f565b6001600160a01b0382163014620008d057620008d08260405180606001604052806028815260200162002cf9602891396200097c565b600080836001600160a01b031683604051620008ed919062000f07565b600060405180830381855af49150503d80600081146200092a576040519150601f19603f3d011682016040523d82523d6000602084013e6200092f565b606091505b50915091508162000839578051156200095e578060405162461bcd60e51b815260040162000253919062001015565b60405162461bcd60e51b815260040162000253906200108e565b5050565b813b8181620008395760405162461bcd60e51b815260040162000253919062001015565b6000620009ac62000317565b90506001600160a01b038316620009d75760405162461bcd60e51b815260040162000253906200111f565b6001600160a01b03831630141562000a035760405162461bcd60e51b815260040162000253906200126c565b6001600160e01b03198216600090815260208281526040808320546001600160a01b03871684526001850190925290912054600160a01b90910461ffff16906000190180821462000b27576001600160a01b0385166000908152600184016020526040812080548390811062000a7557fe5b600091825260208083206008830401546001600160a01b038a168452600188019091526040909220805460079092166004026101000a90920460e01b92508291908590811062000ac157fe5b600091825260208083206008830401805463ffffffff60079094166004026101000a938402191660e09590951c929092029390931790556001600160e01b031992909216825284905260409020805461ffff60a01b1916600160a01b61ffff8516021790555b6001600160a01b0385166000908152600184016020526040902080548062000b4b57fe5b60008281526020808220600860001990940193840401805463ffffffff600460078716026101000a0219169055919092556001600160e01b0319861682528490526040902080546001600160b01b031916905580620005475760028301546001600160a01b03861660009081526001858101602052604090912001546000199091019061ffff1680821462000c6357600085600201838154811062000bec57fe5b6000918252602090912001546002870180546001600160a01b03909216925082918490811062000c1857fe5b600091825260208083209190910180546001600160a01b0319166001600160a01b0394851617905592909116815260018781019092526040902001805461ffff191661ffff83161790555b8460020180548062000c7157fe5b60008281526020808220830160001990810180546001600160a01b03191690559092019092556001600160a01b03891682526001878101909152604090912001805461ffff1916905550505050505050565b80516001600160a01b038116811462000cdb57600080fd5b919050565b600082601f83011262000cf1578081fd5b8151602062000d0a62000d0483620013f5565b620013d1565b828152818101908583018385028701840188101562000d27578586fd5b855b8581101562000d5d5781516001600160e01b03198116811462000d4a578788fd5b8452928401929084019060010162000d29565b5090979650505050505050565b60006020828403121562000d7c578081fd5b604051602081016001600160401b038111828210171562000d9957fe5b60405290508062000daa8362000cc3565b905292915050565b6000806040838503121562000dc5578182fd5b82516001600160401b038082111562000ddc578384fd5b818501915085601f83011262000df0578384fd5b8151602062000e0362000d0483620013f5565b82815281810190858301885b8581101562000eaa57815188016060818e03601f1901121562000e30578a8bfd5b604051606081018181108a8211171562000e4657fe5b60405262000e5682880162000cc3565b815260408201516003811062000e6a578c8dfd5b8188015260608201518981111562000e80578c8dfd5b62000e908f898386010162000ce0565b604083015250855250928401929084019060010162000e0f565b5050809750505062000ebf8882890162000d6a565b9450505050509250929050565b6001600160a01b03169052565b6000815180845262000ef381602086016020860162001413565b601f01601f19169290920160200192915050565b6000825162000f1b81846020870162001413565b9190910192915050565b606080825284518282018190526000919060809081850190602080820287018401818b01875b8481101562000fe257898303607f19018652815180516001600160a01b0316845284810151898501906003811062000f7f57fe5b858701526040918201519185018a9052815190819052908501908a90898601905b8083101562000fcc5783516001600160e01b031916825292870192600192909201919087019062000fa0565b5097860197945050509083019060010162000f4b565b505062000ff28289018b62000ecc565b878103604089015262001006818a62000ed9565b9b9a5050505050505050505050565b6000602082526200102a602083018462000ed9565b9392505050565b6020808252603c908201527f4c69624469616d6f6e644375743a205f696e697420697320616464726573732860408201527f3029206275745f63616c6c64617461206973206e6f7420656d70747900000000606082015260800190565b60208082526026908201527f4c69624469616d6f6e644375743a205f696e69742066756e6374696f6e2072656040820152651d995c9d195960d21b606082015260800190565b6020808252602b908201527f4c69624469616d6f6e644375743a204e6f2073656c6563746f727320696e206660408201526a1858d95d081d1bc818dd5d60aa1b606082015260800190565b60208082526037908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f76652066756e6360408201527f74696f6e207468617420646f65736e2774206578697374000000000000000000606082015260800190565b60208082526027908201527f4c69624469616d6f6e644375743a20496e636f727265637420466163657443756040820152663a20b1ba34b7b760c91b606082015260800190565b6020808252602c908201527f4c69624469616d6f6e644375743a204164642066616365742063616e2774206260408201526b65206164647265737328302960a01b606082015260800190565b6020808252603d908201527f4c69624469616d6f6e644375743a205f63616c6c6461746120697320656d707460408201527f7920627574205f696e6974206973206e6f742061646472657373283029000000606082015260800190565b6020808252602e908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f766520696d6d7560408201526d3a30b1363290333ab731ba34b7b760911b606082015260800190565b60208082526035908201527f4c69624469616d6f6e644375743a2043616e2774206164642066756e6374696f60408201527f6e207468617420616c7265616479206578697374730000000000000000000000606082015260800190565b60208082526038908201527f4c69624469616d6f6e644375743a2043616e2774207265706c6163652066756e60408201527f6374696f6e20776974682073616d652066756e6374696f6e0000000000000000606082015260800190565b60208082526036908201527f4c69624469616d6f6e644375743a2052656d6f7665206661636574206164647260408201527f657373206d757374206265206164647265737328302900000000000000000000606082015260800190565b6040518181016001600160401b0381118282101715620013ed57fe5b604052919050565b60006001600160401b038211156200140957fe5b5060209081020190565b60005b838110156200143057818101518382015260200162001416565b83811115620008395750506000910152565b6118a780620014526000396000f3fe60806040523661000b57005b600080357fffffffff000000000000000000000000000000000000000000000000000000001681527fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c6020819052604090912054819073ffffffffffffffffffffffffffffffffffffffff16806100b7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906115f3565b60405180910390fd5b3660008037600080366000845af43d6000803e8080156100d6573d6000f35b3d6000fd5b60005b83518110156102325760008482815181106100f557fe5b60200260200101516020015190506000600281111561011057fe5b81600281111561011c57fe5b141561015f5761015a85838151811061013157fe5b60200260200101516000015186848151811061014957fe5b602002602001015160400151610326565b610229565b600181600281111561016d57fe5b14156101ab5761015a85838151811061018257fe5b60200260200101516000015186848151811061019a57fe5b60200260200101516040015161065e565b60028160028111156101b957fe5b14156101f75761015a8583815181106101ce57fe5b6020026020010151600001518684815181106101e657fe5b6020026020010151604001516109ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611539565b506001016100de565b507f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb67383838360405161026693929190611282565b60405180910390a16102788282610acb565b505050565b6000610287610302565b60048101805473ffffffffffffffffffffffffffffffffffffffff8581167fffffffffffffffffffffffff000000000000000000000000000000000000000083168117909355604051939450169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c90565b6000815111610361576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b600061036b610302565b905073ffffffffffffffffffffffffffffffffffffffff83166103ba576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166104ab5761040d8460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106104c557fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff168015610554576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906116e2565b5073ffffffffffffffffffffffffffffffffffffffff86166000818152600186810160209081526040808420805480850182559085528285206008820401805463ffffffff60079093166004026101000a928302191660e089901c929092029190911790557fffffffff00000000000000000000000000000000000000000000000000000000909516835287905292902080547fffffffffffffffffffffffff0000000000000000000000000000000000000000169091177fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff86160217905591820191016104ae565b5050505050565b6000815111610699576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006106a3610302565b905073ffffffffffffffffffffffffffffffffffffffff83166106f2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166107e3576107458460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106107fd57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff908116908716811415610892576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061173f565b61089c8183610cbc565b507fffffffff00000000000000000000000000000000000000000000000000000000811660008181526020868152604080832080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8a160217815573ffffffffffffffffffffffffffffffffffffffff8b168085526001808b018552928520805480850182559086528486206008820401805463ffffffff60079093166004026101000a928302191660e09990991c91909102979097179096559390925286905281547fffffffffffffffffffffffff000000000000000000000000000000000000000016909217905591820191016107e6565b60008151116109e6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006109f0610302565b905073ffffffffffffffffffffffffffffffffffffffff831615610a40576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061179c565b60005b8251811015610ac5576000838281518110610a5a57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529185905260409091205490915073ffffffffffffffffffffffffffffffffffffffff16610abb8183610cbc565b5050600101610a43565b50505050565b73ffffffffffffffffffffffffffffffffffffffff8216610b2457805115610b1f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906113c5565b610c7d565b6000815111610b5f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611628565b73ffffffffffffffffffffffffffffffffffffffff82163014610b9e57610b9e8260405180606001604052806028815260200161182660289139610c81565b6000808373ffffffffffffffffffffffffffffffffffffffff1683604051610bc69190611266565b600060405180830381855af49150503d8060008114610c01576040519150601f19603f3d011682016040523d82523d6000602084013e610c06565b606091505b509150915081610ac557805115610c4b57806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611422565b5050565b813b8181610ac5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6000610cc6610302565b905073ffffffffffffffffffffffffffffffffffffffff8316610d15576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906114dc565b73ffffffffffffffffffffffffffffffffffffffff8316301415610d65576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611685565b7fffffffff0000000000000000000000000000000000000000000000000000000082166000908152602082815260408083205473ffffffffffffffffffffffffffffffffffffffff8716845260018501909252909120547401000000000000000000000000000000000000000090910461ffff16907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01808214610f375773ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260408120805483908110610e3657fe5b6000918252602080832060088304015473ffffffffffffffffffffffffffffffffffffffff8a168452600188019091526040909220805460079092166004026101000a90920460e01b925082919085908110610e8e57fe5b600091825260208083206008830401805463ffffffff60079094166004026101000a938402191660e09590951c929092029390931790557fffffffff000000000000000000000000000000000000000000000000000000009290921682528490526040902080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8516021790555b73ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260409020805480610f6757fe5b6000828152602080822060087fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90940193840401805463ffffffff600460078716026101000a0219169055919092557fffffffff00000000000000000000000000000000000000000000000000000000861682528490526040902080547fffffffffffffffffffff000000000000000000000000000000000000000000001690558061065757600283015473ffffffffffffffffffffffffffffffffffffffff861660009081526001858101602052604090912001547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9091019061ffff1680821461114357600085600201838154811061107e57fe5b60009182526020909120015460028701805473ffffffffffffffffffffffffffffffffffffffff90921692508291849081106110b657fe5b600091825260208083209190910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff9485161790559290911681526001878101909252604090200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff83161790555b8460020180548061115057fe5b6000828152602080822083017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90810180547fffffffffffffffffffffffff000000000000000000000000000000000000000016905590920190925573ffffffffffffffffffffffffffffffffffffffff89168252600187810190915260409091200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000016905550505050505050565b73ffffffffffffffffffffffffffffffffffffffff169052565b600081518084526112348160208601602086016117f9565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b600082516112788184602087016117f9565b9190910192915050565b606080825284518282018190526000919060809081850190602080820287018401818b01875b8481101561137c577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff808a8403018652815188840173ffffffffffffffffffffffffffffffffffffffff8251168552858201516003811061130457fe5b858701526040918201519185018a9052815190819052908501908a90898601905b808310156113675783517fffffffff00000000000000000000000000000000000000000000000000000000168252928701926001929092019190870190611325565b509786019794505050908301906001016112a8565b505061138a8289018b611202565b878103604089015261139c818a61121c565b9b9a5050505050505050505050565b6000602082526113be602083018461121c565b9392505050565b6020808252603c908201527f4c69624469616d6f6e644375743a205f696e697420697320616464726573732860408201527f3029206275745f63616c6c64617461206973206e6f7420656d70747900000000606082015260800190565b60208082526026908201527f4c69624469616d6f6e644375743a205f696e69742066756e6374696f6e20726560408201527f7665727465640000000000000000000000000000000000000000000000000000606082015260800190565b6020808252602b908201527f4c69624469616d6f6e644375743a204e6f2073656c6563746f727320696e206660408201527f6163657420746f20637574000000000000000000000000000000000000000000606082015260800190565b60208082526037908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f76652066756e6360408201527f74696f6e207468617420646f65736e2774206578697374000000000000000000606082015260800190565b60208082526027908201527f4c69624469616d6f6e644375743a20496e636f7272656374204661636574437560408201527f74416374696f6e00000000000000000000000000000000000000000000000000606082015260800190565b6020808252602c908201527f4c69624469616d6f6e644375743a204164642066616365742063616e2774206260408201527f6520616464726573732830290000000000000000000000000000000000000000606082015260800190565b6020808252818101527f4469616d6f6e643a2046756e6374696f6e20646f6573206e6f74206578697374604082015260600190565b6020808252603d908201527f4c69624469616d6f6e644375743a205f63616c6c6461746120697320656d707460408201527f7920627574205f696e6974206973206e6f742061646472657373283029000000606082015260800190565b6020808252602e908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f766520696d6d7560408201527f7461626c652066756e6374696f6e000000000000000000000000000000000000606082015260800190565b60208082526035908201527f4c69624469616d6f6e644375743a2043616e2774206164642066756e6374696f60408201527f6e207468617420616c7265616479206578697374730000000000000000000000606082015260800190565b60208082526038908201527f4c69624469616d6f6e644375743a2043616e2774207265706c6163652066756e60408201527f6374696f6e20776974682073616d652066756e6374696f6e0000000000000000606082015260800190565b60208082526036908201527f4c69624469616d6f6e644375743a2052656d6f7665206661636574206164647260408201527f657373206d757374206265206164647265737328302900000000000000000000606082015260800190565b60005b838110156118145781810151838201526020016117fc565b83811115610ac5575050600091015256fe4c69624469616d6f6e644375743a205f696e6974206164647265737320686173206e6f20636f64654c69624469616d6f6e644375743a204e657720666163657420686173206e6f20636f6465a264697066735822122054a3c3a118803545231f43700030cb5e290869be0182196a4a05e7d4a1b71d7e64736f6c634300070600334c69624469616d6f6e644375743a205f696e6974206164647265737320686173206e6f20636f64654c69624469616d6f6e644375743a204e657720666163657420686173206e6f20636f6465", + "deployedBytecode": "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", + "facets": [ + ["0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", ["0x1f931c1c"]], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x06D8890A98851081c464a8106d61eA1967d62754", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0xA5EF6445042e9e9Fce4ee8622183956110535F11", + "functionSelectors": [ + "0xa7baf6fc", + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ] + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0xA5EF6445042e9e9Fce4ee8622183956110535F11", + "functionSelectors": [ + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 1 + }, + { + "facetAddress": "0xA5EF6445042e9e9Fce4ee8622183956110535F11", + "functionSelectors": ["0xa7baf6fc"], + "action": 0 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0xc00e94cb662c3520282e6f5717214004a7f26888" + }, + { + "sym": "AAVE", + "addr": "0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9" + }, + { + "sym": "ADAI", + "addr": "0x028171bCA77440897B824Ca71D1c56caC55b68A3" + }, + { + "sym": "PCDAI", + "addr": "0xEBfb47A7ad0FD6e57323C8A42B2E5A6a4F68fc1a" + }, + { + "sym": "YDAI", + "addr": "0x19D3364A399d251E894aC732651be8B0E4e85001" + }, + { + "sym": "WETH", + "addr": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" + }, + { + "sym": "DAI", + "addr": "0x6B175474E89094C44Da98b954EedeAC495271d0F" + }, + { + "sym": "USDC", + "addr": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" + }, + { + "sym": "USDT", + "addr": "0xdac17f958d2ee523a2206206994597c13d831ec7" + }, + { + "sym": "LINK", + "addr": "0x514910771AF9Ca656af840dff83E8264EcF986CA" + }, + { + "sym": "WBTC", + "addr": "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599" + }, + { + "sym": "SNX", + "addr": "0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f" + }, + { + "sym": "MKR", + "addr": "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2" + }, + { + "sym": "YFI", + "addr": "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e" + } + ], + "cTokens": [ + "0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643", + "0x39aa39c021dfbae8fac545936693ac917d5e7563", + "0x4ddc2d193948926d02f9b1fe9e1daa0718270ed5" + ], + "tellerNFT": "0x2ceB85a2402C94305526ab108e7597a102D6C175", + "loansEscrowBeacon": "0x95F5c6Dbac30Ee95d582926b1b865ab2Ec69AE57", + "collateralEscrowBeacon": "0x3b3692a5e1E82FA02D38d0A5f6EBb0070D84eB70", + "tTokenBeacon": "0xA8E03D0E75FA9a0bBa097266FC8e14284118e0EF", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "history": [ + { + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 7, + "gasUsed": "5726914", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000120000020000008000000800000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000000000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000020000000000000000000000000000000000000000000000000000000000000008020", + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57", + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "logs": [ + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 25, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 26, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000c14d994fe7c5858c93936cc3bd42bb9467d6fb2c", + "logIndex": 27, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 28, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 29, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 30, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 31, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + } + ], + "events": [ + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 25, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 26, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000c14d994fe7c5858c93936cc3bd42bb9467d6fb2c", + "logIndex": 27, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57", + "args": ["0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C"], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 28, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 29, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 30, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 31, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + } + ], + "blockNumber": 12438084, + "cumulativeGasUsed": "6500765", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x01503bAF774aB3aDb6AF79a6fB725c1610D45b2a", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x2a51f0d8DaA9BB4Dc75597cb77B99BDc1754dE00", + "functionSelectors": [ + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ], + "action": 0 + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + [ + "0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", + ["0x1f931c1c"] + ], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x01503bAF774aB3aDb6AF79a6fB725c1610D45b2a", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x2a51f0d8DaA9BB4Dc75597cb77B99BDc1754dE00", + "functionSelectors": [ + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ] + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0xc00e94cb662c3520282e6f5717214004a7f26888" + }, + { + "sym": "AAVE", + "addr": "0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9" + }, + { + "sym": "ADAI", + "addr": "0x028171bCA77440897B824Ca71D1c56caC55b68A3" + }, + { + "sym": "PCDAI", + "addr": "0xEBfb47A7ad0FD6e57323C8A42B2E5A6a4F68fc1a" + }, + { + "sym": "YDAI", + "addr": "0x19D3364A399d251E894aC732651be8B0E4e85001" + }, + { + "sym": "WETH", + "addr": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" + }, + { + "sym": "DAI", + "addr": "0x6B175474E89094C44Da98b954EedeAC495271d0F" + }, + { + "sym": "USDC", + "addr": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" + }, + { + "sym": "USDT", + "addr": "0xdac17f958d2ee523a2206206994597c13d831ec7" + }, + { + "sym": "LINK", + "addr": "0x514910771AF9Ca656af840dff83E8264EcF986CA" + }, + { + "sym": "WBTC", + "addr": "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599" + }, + { + "sym": "SNX", + "addr": "0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f" + }, + { + "sym": "MKR", + "addr": "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2" + }, + { + "sym": "YFI", + "addr": "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e" + } + ], + "cTokens": [ + "0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643", + "0x39aa39c021dfbae8fac545936693ac917d5e7563", + "0x4ddc2d193948926d02f9b1fe9e1daa0718270ed5" + ], + "tellerNFT": "0x2ceB85a2402C94305526ab108e7597a102D6C175", + "loansEscrowBeacon": "0x95F5c6Dbac30Ee95d582926b1b865ab2Ec69AE57", + "collateralEscrowBeacon": "0x3b3692a5e1E82FA02D38d0A5f6EBb0070D84eB70", + "tTokenBeacon": "0xA8E03D0E75FA9a0bBa097266FC8e14284118e0EF", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + }, + { + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x719c7ae0fa6711e223c5e41c41adf1558426db72b18235afc452b2dc751023d1", + "receipt": { + "to": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 84, + "gasUsed": "174681", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000800000000000000000000100000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020", + "blockHash": "0x7ae5b9cbda1bed2be7cdc04a140c5b194fbe3001c4c36d5ff70e66f50b5ffdd4", + "transactionHash": "0x719c7ae0fa6711e223c5e41c41adf1558426db72b18235afc452b2dc751023d1", + "logs": [ + { + "transactionIndex": 84, + "blockNumber": 12442872, + "transactionHash": "0x719c7ae0fa6711e223c5e41c41adf1558426db72b18235afc452b2dc751023d1", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 79, + "blockHash": "0x7ae5b9cbda1bed2be7cdc04a140c5b194fbe3001c4c36d5ff70e66f50b5ffdd4" + } + ], + "events": [ + { + "transactionIndex": 84, + "blockNumber": 12442872, + "transactionHash": "0x719c7ae0fa6711e223c5e41c41adf1558426db72b18235afc452b2dc751023d1", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 79, + "blockHash": "0x7ae5b9cbda1bed2be7cdc04a140c5b194fbe3001c4c36d5ff70e66f50b5ffdd4", + "args": [ + [ + [ + "0x06D8890A98851081c464a8106d61eA1967d62754", + 1, + ["0xce6e9f9f", "0x02bc2cdb", "0x0448a5c4"] + ] + ], + "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "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" + ], + "event": "DiamondCut", + "eventSignature": "DiamondCut((address,uint8,bytes4[])[],address,bytes)" + } + ], + "blockNumber": 12442872, + "cumulativeGasUsed": "4195569", + "status": 1, + "byzantium": true + }, + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + [ + "0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", + ["0x1f931c1c"] + ], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x06D8890A98851081c464a8106d61eA1967d62754", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x2a51f0d8DaA9BB4Dc75597cb77B99BDc1754dE00", + "functionSelectors": [ + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ] + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [ + { + "facetAddress": "0x06D8890A98851081c464a8106d61eA1967d62754", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 1 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0xc00e94cb662c3520282e6f5717214004a7f26888" + }, + { + "sym": "AAVE", + "addr": "0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9" + }, + { + "sym": "ADAI", + "addr": "0x028171bCA77440897B824Ca71D1c56caC55b68A3" + }, + { + "sym": "PCDAI", + "addr": "0xEBfb47A7ad0FD6e57323C8A42B2E5A6a4F68fc1a" + }, + { + "sym": "YDAI", + "addr": "0x19D3364A399d251E894aC732651be8B0E4e85001" + }, + { + "sym": "WETH", + "addr": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" + }, + { + "sym": "DAI", + "addr": "0x6B175474E89094C44Da98b954EedeAC495271d0F" + }, + { + "sym": "USDC", + "addr": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" + }, + { + "sym": "USDT", + "addr": "0xdac17f958d2ee523a2206206994597c13d831ec7" + }, + { + "sym": "LINK", + "addr": "0x514910771AF9Ca656af840dff83E8264EcF986CA" + }, + { + "sym": "WBTC", + "addr": "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599" + }, + { + "sym": "SNX", + "addr": "0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f" + }, + { + "sym": "MKR", + "addr": "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2" + }, + { + "sym": "YFI", + "addr": "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e" + } + ], + "cTokens": [ + "0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643", + "0x39aa39c021dfbae8fac545936693ac917d5e7563", + "0x4ddc2d193948926d02f9b1fe9e1daa0718270ed5" + ], + "tellerNFT": "0x2ceB85a2402C94305526ab108e7597a102D6C175", + "loansEscrowBeacon": "0x95F5c6Dbac30Ee95d582926b1b865ab2Ec69AE57", + "collateralEscrowBeacon": "0x3b3692a5e1E82FA02D38d0A5f6EBb0070D84eB70", + "tTokenBeacon": "0xA8E03D0E75FA9a0bBa097266FC8e14284118e0EF", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "history": [ + { + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "LoanTermsSet", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanResponse[]", + "name": "responses", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "createLoanWithTerms", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "proof", + "type": "bytes32[]" + } + ], + "internalType": "struct NftLoanSizeProof[]", + "name": "proofs", + "type": "tuple[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "setNFTMerkleRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundLended", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "cTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "CompoundRedeemed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundLend", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "compoundRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "compoundRedeemAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sourceToken", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "destinationToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "destinationAmount", + "type": "uint256" + } + ], + "name": "UniswapSwapped", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address[]", + "name": "path", + "type": "address[]" + }, + { + "internalType": "uint256", + "name": "sourceAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minDestination", + "type": "uint256" + } + ], + "name": "uniswapSwap", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 7, + "gasUsed": "5726914", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000101000001000000000800000000000000000000120000020000008000000800000000000000000000000000000000400020000000000000000000004000001000000000000000000000000000000000000000000000000000000000100000000000008000000000001000000000001000000000000100000000000000000000000000000020000100100000000020000000000000000000000000000000000000000000000000000000000000008020", + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57", + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "logs": [ + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 25, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 26, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000c14d994fe7c5858c93936cc3bd42bb9467d6fb2c", + "logIndex": 27, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 28, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 29, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 30, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 31, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + } + ], + "events": [ + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 25, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 26, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000c14d994fe7c5858c93936cc3bd42bb9467d6fb2c", + "logIndex": 27, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57", + "args": [ + "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C" + ], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 28, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 29, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 30, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + }, + { + "transactionIndex": 7, + "blockNumber": 12438084, + "transactionHash": "0x6eb6fd0c9135094e32a45bcf6ff2fa6ba3e2d14e7217aff4a35320f143dfa526", + "address": "0xc14D994fe7C5858c93936cc3bD42bb9467d6fB2C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 31, + "blockHash": "0x47ce1e2988e51ab9118313ec1356e601d0a3fb8891c9fff289329a430565eb57" + } + ], + "blockNumber": 12438084, + "cumulativeGasUsed": "6500765", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ], + "action": 0 + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ], + "action": 0 + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0x01503bAF774aB3aDb6AF79a6fB725c1610D45b2a", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ], + "action": 0 + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ], + "action": 0 + }, + { + "facetAddress": "0x2a51f0d8DaA9BB4Dc75597cb77B99BDc1754dE00", + "functionSelectors": [ + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ], + "action": 0 + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"], + "action": 0 + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ], + "action": 0 + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "0x608060405260405162002d4538038062002d45833981016040819052620000269162000db2565b604080516000808252602082019092526200004e918491620000f560201b620000db1760201c565b620000688160000151620002b560201b6200027d1760201c565b60006200007f6200031760201b620003021760201c565b6301ffc9a760e01b600090815260039091016020526040808220805460ff1990811660019081179092556307e4c70760e21b845282842080548216831790556348e2b09360e01b845282842080548216831790556307f5828d60e41b845291909220805490911690911790555062001442915050565b60005b8351811015620002665760008482815181106200011157fe5b6020026020010151602001519050600060028111156200012d57fe5b8160028111156200013a57fe5b14156200018957620001838583815181106200015257fe5b6020026020010151600001518684815181106200016b57fe5b6020026020010151604001516200033b60201b60201c565b6200025c565b60018160028111156200019857fe5b1415620001e15762000183858381518110620001b057fe5b602002602001015160000151868481518110620001c957fe5b6020026020010151604001516200054e60201b60201c565b6002816002811115620001f057fe5b14156200023957620001838583815181106200020857fe5b6020026020010151600001518684815181106200022157fe5b6020026020010151604001516200077860201b60201c565b60405162461bcd60e51b815260040162000253906200117c565b60405180910390fd5b50600101620000f8565b507f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb6738383836040516200029c9392919062000f25565b60405180910390a1620002b082826200083f565b505050565b6000620002c162000317565b6004810180546001600160a01b038581166001600160a01b031983168117909355604051939450169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c90565b60008151116200035f5760405162461bcd60e51b81526004016200025390620010d4565b60006200036b62000317565b90506001600160a01b038316620003965760405162461bcd60e51b81526004016200025390620011c3565b6001600160a01b038316600090815260018201602052604090205461ffff81166200043c57620003e08460405180606001604052806024815260200162002d21602491396200097c565b6002820180546001600160a01b038616600081815260018087016020908152604083208201805461ffff191661ffff90961695909517909455845490810185559381529190912090910180546001600160a01b03191690911790555b60005b8351811015620005475760008482815181106200045857fe5b6020908102919091018101516001600160e01b031981166000908152918690526040909120549091506001600160a01b03168015620004ab5760405162461bcd60e51b81526004016200025390620012ba565b506001600160a01b0386166000818152600186810160209081526040808420805480850182559085528285206008820401805463ffffffff60079093166004026101000a928302191660e089901c929092029190911790556001600160e01b0319909516835287905292902080546001600160a01b03191690911761ffff60a01b1916600160a01b61ffff86160217905591820191016200043f565b5050505050565b6000815111620005725760405162461bcd60e51b81526004016200025390620010d4565b60006200057e62000317565b90506001600160a01b038316620005a95760405162461bcd60e51b81526004016200025390620011c3565b6001600160a01b038316600090815260018201602052604090205461ffff81166200064f57620005f38460405180606001604052806024815260200162002d21602491396200097c565b6002820180546001600160a01b038616600081815260018087016020908152604083208201805461ffff191661ffff90961695909517909455845490810185559381529190912090910180546001600160a01b03191690911790555b60005b8351811015620005475760008482815181106200066b57fe5b6020908102919091018101516001600160e01b031981166000908152918690526040909120549091506001600160a01b03908116908716811415620006c45760405162461bcd60e51b8152600401620002539062001317565b620006d08183620009a0565b506001600160e01b03198116600081815260208681526040808320805461ffff60a01b1916600160a01b61ffff8a16021781556001600160a01b038b168085526001808b018552928520805480850182559086528486206008820401805463ffffffff60079093166004026101000a928302191660e09990991c91909102979097179096559390925286905281546001600160a01b0319169092179055918201910162000652565b60008151116200079c5760405162461bcd60e51b81526004016200025390620010d4565b6000620007a862000317565b90506001600160a01b03831615620007d45760405162461bcd60e51b8152600401620002539062001374565b60005b825181101562000839576000838281518110620007f057fe5b6020908102919091018101516001600160e01b031981166000908152918590526040909120549091506001600160a01b03166200082e8183620009a0565b5050600101620007d7565b50505050565b6001600160a01b0382166200087657805115620008705760405162461bcd60e51b8152600401620002539062001031565b62000978565b60008151116200089a5760405162461bcd60e51b815260040162000253906200120f565b6001600160a01b0382163014620008d057620008d08260405180606001604052806028815260200162002cf9602891396200097c565b600080836001600160a01b031683604051620008ed919062000f07565b600060405180830381855af49150503d80600081146200092a576040519150601f19603f3d011682016040523d82523d6000602084013e6200092f565b606091505b50915091508162000839578051156200095e578060405162461bcd60e51b815260040162000253919062001015565b60405162461bcd60e51b815260040162000253906200108e565b5050565b813b8181620008395760405162461bcd60e51b815260040162000253919062001015565b6000620009ac62000317565b90506001600160a01b038316620009d75760405162461bcd60e51b815260040162000253906200111f565b6001600160a01b03831630141562000a035760405162461bcd60e51b815260040162000253906200126c565b6001600160e01b03198216600090815260208281526040808320546001600160a01b03871684526001850190925290912054600160a01b90910461ffff16906000190180821462000b27576001600160a01b0385166000908152600184016020526040812080548390811062000a7557fe5b600091825260208083206008830401546001600160a01b038a168452600188019091526040909220805460079092166004026101000a90920460e01b92508291908590811062000ac157fe5b600091825260208083206008830401805463ffffffff60079094166004026101000a938402191660e09590951c929092029390931790556001600160e01b031992909216825284905260409020805461ffff60a01b1916600160a01b61ffff8516021790555b6001600160a01b0385166000908152600184016020526040902080548062000b4b57fe5b60008281526020808220600860001990940193840401805463ffffffff600460078716026101000a0219169055919092556001600160e01b0319861682528490526040902080546001600160b01b031916905580620005475760028301546001600160a01b03861660009081526001858101602052604090912001546000199091019061ffff1680821462000c6357600085600201838154811062000bec57fe5b6000918252602090912001546002870180546001600160a01b03909216925082918490811062000c1857fe5b600091825260208083209190910180546001600160a01b0319166001600160a01b0394851617905592909116815260018781019092526040902001805461ffff191661ffff83161790555b8460020180548062000c7157fe5b60008281526020808220830160001990810180546001600160a01b03191690559092019092556001600160a01b03891682526001878101909152604090912001805461ffff1916905550505050505050565b80516001600160a01b038116811462000cdb57600080fd5b919050565b600082601f83011262000cf1578081fd5b8151602062000d0a62000d0483620013f5565b620013d1565b828152818101908583018385028701840188101562000d27578586fd5b855b8581101562000d5d5781516001600160e01b03198116811462000d4a578788fd5b8452928401929084019060010162000d29565b5090979650505050505050565b60006020828403121562000d7c578081fd5b604051602081016001600160401b038111828210171562000d9957fe5b60405290508062000daa8362000cc3565b905292915050565b6000806040838503121562000dc5578182fd5b82516001600160401b038082111562000ddc578384fd5b818501915085601f83011262000df0578384fd5b8151602062000e0362000d0483620013f5565b82815281810190858301885b8581101562000eaa57815188016060818e03601f1901121562000e30578a8bfd5b604051606081018181108a8211171562000e4657fe5b60405262000e5682880162000cc3565b815260408201516003811062000e6a578c8dfd5b8188015260608201518981111562000e80578c8dfd5b62000e908f898386010162000ce0565b604083015250855250928401929084019060010162000e0f565b5050809750505062000ebf8882890162000d6a565b9450505050509250929050565b6001600160a01b03169052565b6000815180845262000ef381602086016020860162001413565b601f01601f19169290920160200192915050565b6000825162000f1b81846020870162001413565b9190910192915050565b606080825284518282018190526000919060809081850190602080820287018401818b01875b8481101562000fe257898303607f19018652815180516001600160a01b0316845284810151898501906003811062000f7f57fe5b858701526040918201519185018a9052815190819052908501908a90898601905b8083101562000fcc5783516001600160e01b031916825292870192600192909201919087019062000fa0565b5097860197945050509083019060010162000f4b565b505062000ff28289018b62000ecc565b878103604089015262001006818a62000ed9565b9b9a5050505050505050505050565b6000602082526200102a602083018462000ed9565b9392505050565b6020808252603c908201527f4c69624469616d6f6e644375743a205f696e697420697320616464726573732860408201527f3029206275745f63616c6c64617461206973206e6f7420656d70747900000000606082015260800190565b60208082526026908201527f4c69624469616d6f6e644375743a205f696e69742066756e6374696f6e2072656040820152651d995c9d195960d21b606082015260800190565b6020808252602b908201527f4c69624469616d6f6e644375743a204e6f2073656c6563746f727320696e206660408201526a1858d95d081d1bc818dd5d60aa1b606082015260800190565b60208082526037908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f76652066756e6360408201527f74696f6e207468617420646f65736e2774206578697374000000000000000000606082015260800190565b60208082526027908201527f4c69624469616d6f6e644375743a20496e636f727265637420466163657443756040820152663a20b1ba34b7b760c91b606082015260800190565b6020808252602c908201527f4c69624469616d6f6e644375743a204164642066616365742063616e2774206260408201526b65206164647265737328302960a01b606082015260800190565b6020808252603d908201527f4c69624469616d6f6e644375743a205f63616c6c6461746120697320656d707460408201527f7920627574205f696e6974206973206e6f742061646472657373283029000000606082015260800190565b6020808252602e908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f766520696d6d7560408201526d3a30b1363290333ab731ba34b7b760911b606082015260800190565b60208082526035908201527f4c69624469616d6f6e644375743a2043616e2774206164642066756e6374696f60408201527f6e207468617420616c7265616479206578697374730000000000000000000000606082015260800190565b60208082526038908201527f4c69624469616d6f6e644375743a2043616e2774207265706c6163652066756e60408201527f6374696f6e20776974682073616d652066756e6374696f6e0000000000000000606082015260800190565b60208082526036908201527f4c69624469616d6f6e644375743a2052656d6f7665206661636574206164647260408201527f657373206d757374206265206164647265737328302900000000000000000000606082015260800190565b6040518181016001600160401b0381118282101715620013ed57fe5b604052919050565b60006001600160401b038211156200140957fe5b5060209081020190565b60005b838110156200143057818101518382015260200162001416565b83811115620008395750506000910152565b6118a780620014526000396000f3fe60806040523661000b57005b600080357fffffffff000000000000000000000000000000000000000000000000000000001681527fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c6020819052604090912054819073ffffffffffffffffffffffffffffffffffffffff16806100b7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906115f3565b60405180910390fd5b3660008037600080366000845af43d6000803e8080156100d6573d6000f35b3d6000fd5b60005b83518110156102325760008482815181106100f557fe5b60200260200101516020015190506000600281111561011057fe5b81600281111561011c57fe5b141561015f5761015a85838151811061013157fe5b60200260200101516000015186848151811061014957fe5b602002602001015160400151610326565b610229565b600181600281111561016d57fe5b14156101ab5761015a85838151811061018257fe5b60200260200101516000015186848151811061019a57fe5b60200260200101516040015161065e565b60028160028111156101b957fe5b14156101f75761015a8583815181106101ce57fe5b6020026020010151600001518684815181106101e657fe5b6020026020010151604001516109ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611539565b506001016100de565b507f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb67383838360405161026693929190611282565b60405180910390a16102788282610acb565b505050565b6000610287610302565b60048101805473ffffffffffffffffffffffffffffffffffffffff8581167fffffffffffffffffffffffff000000000000000000000000000000000000000083168117909355604051939450169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c90565b6000815111610361576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b600061036b610302565b905073ffffffffffffffffffffffffffffffffffffffff83166103ba576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166104ab5761040d8460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106104c557fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff168015610554576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906116e2565b5073ffffffffffffffffffffffffffffffffffffffff86166000818152600186810160209081526040808420805480850182559085528285206008820401805463ffffffff60079093166004026101000a928302191660e089901c929092029190911790557fffffffff00000000000000000000000000000000000000000000000000000000909516835287905292902080547fffffffffffffffffffffffff0000000000000000000000000000000000000000169091177fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff86160217905591820191016104ae565b5050505050565b6000815111610699576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006106a3610302565b905073ffffffffffffffffffffffffffffffffffffffff83166106f2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166107e3576107458460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106107fd57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff908116908716811415610892576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061173f565b61089c8183610cbc565b507fffffffff00000000000000000000000000000000000000000000000000000000811660008181526020868152604080832080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8a160217815573ffffffffffffffffffffffffffffffffffffffff8b168085526001808b018552928520805480850182559086528486206008820401805463ffffffff60079093166004026101000a928302191660e09990991c91909102979097179096559390925286905281547fffffffffffffffffffffffff000000000000000000000000000000000000000016909217905591820191016107e6565b60008151116109e6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006109f0610302565b905073ffffffffffffffffffffffffffffffffffffffff831615610a40576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061179c565b60005b8251811015610ac5576000838281518110610a5a57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529185905260409091205490915073ffffffffffffffffffffffffffffffffffffffff16610abb8183610cbc565b5050600101610a43565b50505050565b73ffffffffffffffffffffffffffffffffffffffff8216610b2457805115610b1f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906113c5565b610c7d565b6000815111610b5f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611628565b73ffffffffffffffffffffffffffffffffffffffff82163014610b9e57610b9e8260405180606001604052806028815260200161182660289139610c81565b6000808373ffffffffffffffffffffffffffffffffffffffff1683604051610bc69190611266565b600060405180830381855af49150503d8060008114610c01576040519150601f19603f3d011682016040523d82523d6000602084013e610c06565b606091505b509150915081610ac557805115610c4b57806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611422565b5050565b813b8181610ac5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6000610cc6610302565b905073ffffffffffffffffffffffffffffffffffffffff8316610d15576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906114dc565b73ffffffffffffffffffffffffffffffffffffffff8316301415610d65576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611685565b7fffffffff0000000000000000000000000000000000000000000000000000000082166000908152602082815260408083205473ffffffffffffffffffffffffffffffffffffffff8716845260018501909252909120547401000000000000000000000000000000000000000090910461ffff16907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01808214610f375773ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260408120805483908110610e3657fe5b6000918252602080832060088304015473ffffffffffffffffffffffffffffffffffffffff8a168452600188019091526040909220805460079092166004026101000a90920460e01b925082919085908110610e8e57fe5b600091825260208083206008830401805463ffffffff60079094166004026101000a938402191660e09590951c929092029390931790557fffffffff000000000000000000000000000000000000000000000000000000009290921682528490526040902080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8516021790555b73ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260409020805480610f6757fe5b6000828152602080822060087fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90940193840401805463ffffffff600460078716026101000a0219169055919092557fffffffff00000000000000000000000000000000000000000000000000000000861682528490526040902080547fffffffffffffffffffff000000000000000000000000000000000000000000001690558061065757600283015473ffffffffffffffffffffffffffffffffffffffff861660009081526001858101602052604090912001547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9091019061ffff1680821461114357600085600201838154811061107e57fe5b60009182526020909120015460028701805473ffffffffffffffffffffffffffffffffffffffff90921692508291849081106110b657fe5b600091825260208083209190910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff9485161790559290911681526001878101909252604090200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff83161790555b8460020180548061115057fe5b6000828152602080822083017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90810180547fffffffffffffffffffffffff000000000000000000000000000000000000000016905590920190925573ffffffffffffffffffffffffffffffffffffffff89168252600187810190915260409091200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000016905550505050505050565b73ffffffffffffffffffffffffffffffffffffffff169052565b600081518084526112348160208601602086016117f9565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b600082516112788184602087016117f9565b9190910192915050565b606080825284518282018190526000919060809081850190602080820287018401818b01875b8481101561137c577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff808a8403018652815188840173ffffffffffffffffffffffffffffffffffffffff8251168552858201516003811061130457fe5b858701526040918201519185018a9052815190819052908501908a90898601905b808310156113675783517fffffffff00000000000000000000000000000000000000000000000000000000168252928701926001929092019190870190611325565b509786019794505050908301906001016112a8565b505061138a8289018b611202565b878103604089015261139c818a61121c565b9b9a5050505050505050505050565b6000602082526113be602083018461121c565b9392505050565b6020808252603c908201527f4c69624469616d6f6e644375743a205f696e697420697320616464726573732860408201527f3029206275745f63616c6c64617461206973206e6f7420656d70747900000000606082015260800190565b60208082526026908201527f4c69624469616d6f6e644375743a205f696e69742066756e6374696f6e20726560408201527f7665727465640000000000000000000000000000000000000000000000000000606082015260800190565b6020808252602b908201527f4c69624469616d6f6e644375743a204e6f2073656c6563746f727320696e206660408201527f6163657420746f20637574000000000000000000000000000000000000000000606082015260800190565b60208082526037908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f76652066756e6360408201527f74696f6e207468617420646f65736e2774206578697374000000000000000000606082015260800190565b60208082526027908201527f4c69624469616d6f6e644375743a20496e636f7272656374204661636574437560408201527f74416374696f6e00000000000000000000000000000000000000000000000000606082015260800190565b6020808252602c908201527f4c69624469616d6f6e644375743a204164642066616365742063616e2774206260408201527f6520616464726573732830290000000000000000000000000000000000000000606082015260800190565b6020808252818101527f4469616d6f6e643a2046756e6374696f6e20646f6573206e6f74206578697374604082015260600190565b6020808252603d908201527f4c69624469616d6f6e644375743a205f63616c6c6461746120697320656d707460408201527f7920627574205f696e6974206973206e6f742061646472657373283029000000606082015260800190565b6020808252602e908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f766520696d6d7560408201527f7461626c652066756e6374696f6e000000000000000000000000000000000000606082015260800190565b60208082526035908201527f4c69624469616d6f6e644375743a2043616e2774206164642066756e6374696f60408201527f6e207468617420616c7265616479206578697374730000000000000000000000606082015260800190565b60208082526038908201527f4c69624469616d6f6e644375743a2043616e2774207265706c6163652066756e60408201527f6374696f6e20776974682073616d652066756e6374696f6e0000000000000000606082015260800190565b60208082526036908201527f4c69624469616d6f6e644375743a2052656d6f7665206661636574206164647260408201527f657373206d757374206265206164647265737328302900000000000000000000606082015260800190565b60005b838110156118145781810151838201526020016117fc565b83811115610ac5575050600091015256fe4c69624469616d6f6e644375743a205f696e6974206164647265737320686173206e6f20636f64654c69624469616d6f6e644375743a204e657720666163657420686173206e6f20636f6465a264697066735822122054a3c3a118803545231f43700030cb5e290869be0182196a4a05e7d4a1b71d7e64736f6c634300070600334c69624469616d6f6e644375743a205f696e6974206164647265737320686173206e6f20636f64654c69624469616d6f6e644375743a204e657720666163657420686173206e6f20636f6465", + "deployedBytecode": "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", + "facets": [ + [ + "0x35D80A53F7be635f75152221d4D71CD4DCB07e5C", + ["0x1f931c1c"] + ], + [ + "0xC1bbdF9f8c0b6aE0B4d35E9A778080B691A72a3E", + [ + "0xadfca15e", + "0x7a0ed627", + "0xcdffacc6", + "0x52ef6b2c", + "0x01ffc9a7" + ] + ], + [ + "0xcfEe10af6C7A91863c2bbDbCCA3bCB5064A447BE", + ["0xf2fde38b", "0x8da5cb5b"] + ], + { + "facetAddress": "0x1cAA9Fd102b88813a6a52792703F1307fe8E5E92", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0x1cf14f33", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0xEF2508E1673BD0BC26379d2b7d43c0a8047E92B4", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0xa9777F43F61562DcAD8a209Fed4Af1E0Cb6c2623", + "functionSelectors": [ + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3" + ] + }, + { + "facetAddress": "0x2D6db3a2e4A14cf90e502D35C544CfF26131FB53", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0x3425c0caB7b6fA2729181e24Aecf21A5Eb8f968F", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0xFCB61eB1d058557dB0fBf971C096d5B628CeDc75", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0x8075462bc2d2f2587cc9874199729bc7a3226eca", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0xDdd76632BcA1fc65E2832F0652D601d08339CCa6", + "functionSelectors": [ + "0x9912dde8", + "0x5a601668", + "0x8a4f4f92" + ] + }, + { + "facetAddress": "0x0308917D99Aa92d7e5F27cECa5250Fa09a2224aa", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0x01503bAF774aB3aDb6AF79a6fB725c1610D45b2a", + "functionSelectors": [ + "0xce6e9f9f", + "0x02bc2cdb", + "0x0448a5c4" + ] + }, + { + "facetAddress": "0x7C8Bf7F55f3140c8eA68448a3c503546A86AEf1e", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0x624eDBD5E58341617d6683EAE1985f7560Ee1660", + "functionSelectors": [ + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0x36A1f5D199aD88B93623EE1444A43D24a2dA0ec5", + "functionSelectors": [ + "0x2239f556", + "0x46efd16c", + "0x78b248e4" + ] + }, + { + "facetAddress": "0x2a51f0d8DaA9BB4Dc75597cb77B99BDc1754dE00", + "functionSelectors": [ + "0x6f70d212", + "0x0967aa82", + "0x0f48a482" + ] + }, + { + "facetAddress": "0xb86de5840485eb7ba11e7771eb52342492f6f264", + "functionSelectors": ["0x46e04a2f"] + }, + { + "facetAddress": "0x25ff8028cde05C4D875d651B5CF0E4aCFD7a34B3", + "functionSelectors": [ + "0x7197d575", + "0x3ca4c96b", + "0x5d86dbe7" + ] + }, + { + "facetAddress": "0x998b447E1D20535E154acD0Ea2b574c761a535BA", + "functionSelectors": ["0x262201b6"] + } + ], + "diamondCut": [], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "COMP", + "addr": "0xc00e94cb662c3520282e6f5717214004a7f26888" + }, + { + "sym": "AAVE", + "addr": "0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9" + }, + { + "sym": "ADAI", + "addr": "0x028171bCA77440897B824Ca71D1c56caC55b68A3" + }, + { + "sym": "PCDAI", + "addr": "0xEBfb47A7ad0FD6e57323C8A42B2E5A6a4F68fc1a" + }, + { + "sym": "YDAI", + "addr": "0x19D3364A399d251E894aC732651be8B0E4e85001" + }, + { + "sym": "WETH", + "addr": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" + }, + { + "sym": "DAI", + "addr": "0x6B175474E89094C44Da98b954EedeAC495271d0F" + }, + { + "sym": "USDC", + "addr": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" + }, + { + "sym": "USDT", + "addr": "0xdac17f958d2ee523a2206206994597c13d831ec7" + }, + { + "sym": "LINK", + "addr": "0x514910771AF9Ca656af840dff83E8264EcF986CA" + }, + { + "sym": "WBTC", + "addr": "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599" + }, + { + "sym": "SNX", + "addr": "0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f" + }, + { + "sym": "MKR", + "addr": "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2" + }, + { + "sym": "YFI", + "addr": "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e" + } + ], + "cTokens": [ + "0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643", + "0x39aa39c021dfbae8fac545936693ac917d5e7563", + "0x4ddc2d193948926d02f9b1fe9e1daa0718270ed5" + ], + "tellerNFT": "0x2ceB85a2402C94305526ab108e7597a102D6C175", + "loansEscrowBeacon": "0x95F5c6Dbac30Ee95d582926b1b865ab2Ec69AE57", + "collateralEscrowBeacon": "0x3b3692a5e1E82FA02D38d0A5f6EBb0070D84eB70", + "tTokenBeacon": "0xA8E03D0E75FA9a0bBa097266FC8e14284118e0EF", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } } ], "devdoc": { diff --git a/deployments/mainnet/TellerNFTDistributor.json b/deployments/mainnet/TellerNFTDistributor.json index f823d8fea..14d9d4b62 100644 --- a/deployments/mainnet/TellerNFTDistributor.json +++ b/deployments/mainnet/TellerNFTDistributor.json @@ -554,10 +554,6 @@ } ], "diamondCut": [], - "execute": { - "methodName": "setNFTDictionaryAddress", - "args": ["0x72733102AB139FB0367cc29D492c955A7c736079"] - }, "history": [ { "address": "0x058F447199025e9ACF52E4A1473f4Ad9cC44D299", diff --git a/deployments/mainnet/solcInputs/151024dde4edc20ecc11a6b585cef1b4.json b/deployments/mainnet/solcInputs/151024dde4edc20ecc11a6b585cef1b4.json new file mode 100644 index 000000000..8168526a0 --- /dev/null +++ b/deployments/mainnet/solcInputs/151024dde4edc20ecc11a6b585cef1b4.json @@ -0,0 +1,561 @@ +{ + "language": "Solidity", + "sources": { + "contracts/contexts/access-control/context.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./internal/grant-role.sol\";\nimport \"./internal/revoke-role.sol\";\nimport \"./internal/renounce-role.sol\";\n\nabstract contract ctx_AccessControl_v1 is\n int_grantRole_AccessControl_v1,\n int_revokeRole_AccessControl_v1,\n int_renounceRole_AccessControl_v1\n{}\n" + }, + "contracts/contexts/access-control/internal/grant-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { AccessControlEvents } from \"../data.sol\";\nimport \"./has-role.sol\";\n\nabstract contract int_grantRole_AccessControl_v1 is\n int_hasRole_AccessControl_v1\n{\n /**\n * @dev Should only use when circumventing admin checking. See {../entry/grant-role.sol}\n */\n function _grantRole(bytes32 role, address account) internal {\n if (_hasRole(role, account)) return;\n accessControlRolesStore().roles[role].members[account] = true;\n emit AccessControlEvents.RoleGranted(role, account, msg.sender);\n }\n}\n" + }, + "contracts/contexts/access-control/internal/revoke-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { AccessControlEvents } from \"../data.sol\";\nimport \"./has-role.sol\";\n\nabstract contract int_revokeRole_AccessControl_v1 is\n int_hasRole_AccessControl_v1\n{\n function _revokeRole(bytes32 role, address account) internal {\n if (!_hasRole(role, account)) return;\n accessControlRolesStore().roles[role].members[account] = false;\n emit AccessControlEvents.RoleRevoked(role, account, msg.sender);\n }\n}\n" + }, + "contracts/contexts/access-control/internal/renounce-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlEvents } from \"../data.sol\";\nimport \"./has-role.sol\";\n\nabstract contract int_renounceRole_AccessControl_v1 is\n int_hasRole_AccessControl_v1\n{\n function _renounceRole(bytes32 role, address account) internal {\n require(_hasRole(role, msg.sender), \"CAN'T RENOUNCE\");\n accessControlRolesStore().roles[role].members[account] = false;\n emit AccessControlEvents.RoleRevoked(role, account, msg.sender);\n }\n}\n" + }, + "contracts/contexts/access-control/data.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nstruct RoleData {\n mapping(address => bool) members;\n bytes32 adminRole;\n}\n\nlibrary AccessControlEvents {\n event OwnerSet(address indexed owner);\n\n event OwnerTransferred(address indexed owner, address indexed prevOwner);\n\n /**\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n *\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n * {RoleAdminChanged} not being emitted signaling this.\n *\n * _Available since v3.1._\n */\n event RoleAdminChanged(\n bytes32 indexed role,\n bytes32 indexed previousAdminRole,\n bytes32 indexed newAdminRole\n );\n\n /**\n * @dev Emitted when `account` is granted `role`.\n *\n * `sender` is the account that originated the contract call, an admin role\n * bearer except when using {_setupRole}.\n */\n event RoleGranted(\n bytes32 indexed role,\n address indexed account,\n address indexed sender\n );\n\n /**\n * @dev Emitted when `account` is revoked `role`.\n *\n * `sender` is the account that originated the contract call:\n * - if using `revokeRole`, it is the admin role bearer\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\n */\n event RoleRevoked(\n bytes32 indexed role,\n address indexed account,\n address indexed sender\n );\n}\n" + }, + "contracts/contexts/access-control/internal/has-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"../storage/roles.sol\";\n\nabstract contract int_hasRole_AccessControl_v1 is sto_AccessControl_Roles {\n function _hasRole(bytes32 role, address account)\n internal\n view\n returns (bool hasRole_)\n {\n hasRole_ = accessControlRolesStore().roles[role].members[account];\n }\n}\n" + }, + "contracts/contexts/access-control/storage/roles.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { RoleData } from \"../data.sol\";\n\ncontract sto_AccessControl_Roles {\n bytes32 internal constant POS =\n keccak256(\"teller_protocol.storage.access_control.roles\");\n\n struct AccessControlRolesStorage {\n mapping(bytes32 => RoleData) roles;\n }\n\n function accessControlRolesStore()\n internal\n pure\n returns (AccessControlRolesStorage storage s)\n {\n bytes32 position = POS;\n\n assembly {\n s.slot := position\n }\n }\n}\n" + }, + "contracts/contexts/initializable/context.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"../access-control/internal/grant-role.sol\";\nimport \"../access-control/internal/revoke-role.sol\";\nimport \"../access-control/internal/renounce-role.sol\";\n\ncontract ctx_Initializable_v1 is\n int_grantRole_AccessControl_v1,\n int_revokeRole_AccessControl_v1,\n int_renounceRole_AccessControl_v1\n{}\n" + }, + "contracts/contexts/access-control/entry/revoke-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../data.sol\";\nimport \"../internal/revoke-role.sol\";\nimport \"../internal/is-admin-for-role.sol\";\n\ncontract ent_revokeRole_AccessControl_v1 is\n int_revokeRole_AccessControl_v1,\n int_isAdminForRole_AccessControl_v1\n{\n /**\n * @notice Removes a role from an address.\n *\n * Requirements:\n * - Sender must be role admin.\n */\n function revokeRole(bytes32 role, address account) external {\n require(_isAdminForRole(role, msg.sender), \"AccessControl: not admin\");\n _revokeRole(role, account);\n }\n}\n" + }, + "contracts/contexts/access-control/internal/is-admin-for-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"../storage/roles.sol\";\n\nabstract contract int_isAdminForRole_AccessControl_v1 is\n sto_AccessControl_Roles\n{\n function _isAdminForRole(bytes32 role, address account)\n internal\n view\n returns (bool isAdminForRole_)\n {\n isAdminForRole_ = accessControlRolesStore().roles[\n accessControlRolesStore().roles[role].adminRole\n ]\n .members[account];\n }\n}\n" + }, + "contracts/contexts/access-control/entry/renounce-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../data.sol\";\nimport \"../internal/revoke-role.sol\";\nimport \"../internal/is-admin-for-role.sol\";\n\ncontract ent_renounceRole_AccessControl_v1 is\n int_revokeRole_AccessControl_v1,\n int_isAdminForRole_AccessControl_v1\n{\n /**\n * @notice Grants an address a new role.\n * @param role the role to revoke for the account\n * @param account the address of the respective account to revoke\n * Requirements:\n * - Sender must be role admin.\n */\n function renounceRole(bytes32 role, address account) external {\n require(\n account == msg.sender,\n \"AccessControl: can only renounce roles for self\"\n );\n _revokeRole(role, account);\n }\n}\n" + }, + "contracts/contexts/access-control/storage.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./data.sol\";\n\ncontract sto_AccessControl {\n struct AccessControlLayout {\n mapping(bytes32 => RoleData) roles;\n bool notEntered;\n }\n\n function accessControl()\n internal\n pure\n returns (AccessControlLayout storage l_)\n {\n bytes32 position = keccak256(\"teller_protocol.storage.access_control\");\n\n assembly {\n l_.slot := position\n }\n }\n}\n" + }, + "contracts/contexts/access-control/modifiers/entry.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { sto_AccessControl } from \"../storage.sol\";\n\nabstract contract mod_entry_AccessControl_v1 is sto_AccessControl {\n modifier entry {\n AccessControlLayout storage layout = accessControl();\n require(layout.notEntered, \"RE_ENTRANCY\");\n layout.notEntered = false;\n _;\n layout.notEntered = true;\n }\n}\n" + }, + "contracts/contexts/access-control/internal/transfer-owner.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlEvents } from \"../data.sol\";\nimport \"../storage/owner.sol\";\n\nabstract contract int_transferOwner_AccessControl_v1 is\n sto_AccessControl_Owner\n{\n function _transferOwner(address owner) internal {\n require(\n accessControlOwnerStore().owner == msg.sender,\n \"AccessControl: cannot transfer; not owner\"\n );\n accessControlOwnerStore().owner = owner;\n emit AccessControlEvents.OwnerTransferred(owner, msg.sender);\n }\n}\n" + }, + "contracts/contexts/access-control/storage/owner.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract sto_AccessControl_Owner {\n bytes32 internal constant POS =\n keccak256(\"teller_protocol.storage.access_control.owner\");\n\n struct AccessControlOwnerStorage {\n address owner;\n }\n\n function accessControlOwnerStore()\n internal\n pure\n returns (AccessControlOwnerStorage storage s)\n {\n bytes32 position = POS;\n\n assembly {\n s.slot := position\n }\n }\n}\n" + }, + "contracts/contexts/access-control/modifiers/only-owner.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"../storage/owner.sol\";\n\nabstract contract mod_onlyOwner_AccessControl_v1 is sto_AccessControl_Owner {\n modifier onlyOwner() {\n require(\n accessControlOwnerStore().owner == msg.sender,\n \"AccessControl: not owner\"\n );\n _;\n }\n}\n\nabstract contract mod_onlyOwner_AccessControl is\n mod_onlyOwner_AccessControl_v1\n{}\n" + }, + "contracts/contexts/access-control/internal/set-owner.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlEvents } from \"../data.sol\";\nimport \"../storage/owner.sol\";\n\nabstract contract int_setOwner_AccessControl_v1 is sto_AccessControl_Owner {\n function _setOwner(address owner) internal {\n require(\n accessControlOwnerStore().owner == address(0),\n \"AccessControl: owner already set\"\n );\n accessControlOwnerStore().owner = owner;\n emit AccessControlEvents.OwnerSet(owner);\n }\n}\n" + }, + "contracts/contexts/access-control/internal/set-role-admin.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlEvents } from \"../data.sol\";\nimport \"./admin-role-for.sol\";\n\nabstract contract int_setRoleAdmin_AccessControl_v1 is\n int_adminRoleFor_AccessControl_v1\n{\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal {\n accessControlRolesStore().roles[role].adminRole = adminRole;\n emit AccessControlEvents.RoleAdminChanged(\n role,\n _adminRoleFor(role),\n adminRole\n );\n }\n}\n" + }, + "contracts/contexts/access-control/internal/admin-role-for.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../storage/roles.sol\";\n\nabstract contract int_adminRoleFor_AccessControl_v1 is sto_AccessControl_Roles {\n function _adminRoleFor(bytes32 role)\n internal\n view\n returns (bytes32 adminRoleFor_)\n {\n adminRoleFor_ = accessControlRolesStore().roles[role].adminRole;\n }\n}\n\nabstract contract int_adminRoleFor_AccessControl is\n int_adminRoleFor_AccessControl_v1\n{}\n" + }, + "contracts/contexts/access-control/internal/require-authorization.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./has-role.sol\";\n\nabstract contract int_requireAuthorization_AccessControl_v1 is\n int_hasRole_AccessControl_v1\n{\n function _requireAuthorization(bytes32 role, address account)\n internal\n view\n {\n require(_hasRole(role, account), \"AccessControl: unauthorized\");\n }\n}\n" + }, + "contracts/contexts/access-control/modifiers/authorized.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {\n int_requireAuthorization_AccessControl_v1\n} from \"../internal/require-authorization.sol\";\n\nabstract contract mod_authorized_AccessControl_v1 is\n int_requireAuthorization_AccessControl_v1\n{\n modifier authorized(bytes32 role, address account) {\n _requireAuthorization(role, account);\n _;\n }\n}\n\nabstract contract mod_authorized_AccessControl is\n mod_authorized_AccessControl_v1\n{}\n" + }, + "contracts/nft/distributor/entry/move-merkle.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../store.sol\";\nimport \"../../../contexts/access-control/modifiers/authorized.sol\";\n\n// Utils\nimport { DistributorEvents, ADMIN, MerkleRoot } from \"../data.sol\";\n\ncontract ent_moveMerkle_NFTDistributor_v1 is\n sto_NFTDistributor,\n mod_authorized_AccessControl_v1\n{\n /**\n * @notice Change a merkle to be for a different tier to be able to claim NFTs.\n * @param index Index of merkle to set.\n * @param tierIndex Index of NFT tier to assign merkle for.\n *\n * Requirements:\n * - Caller must be an admin\n */\n function moveMerkle(uint256 index, uint256 tierIndex)\n external\n authorized(ADMIN, msg.sender)\n {\n MerkleRoot storage merkle = distributorStore().merkleRoots[index];\n merkle.tierIndex = tierIndex;\n }\n}\n" + }, + "contracts/nft/distributor/store.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Interfaces\nimport \"../ITellerNFT.sol\";\nimport \"../TellerNFTDictionary.sol\";\n\n// Utils\nimport { MerkleRoot } from \"./data.sol\";\n\nabstract contract sto_NFTDistributor {\n struct DistributorStorage {\n ITellerNFT nft;\n MerkleRoot[] merkleRoots;\n mapping(uint256 => mapping(uint256 => uint256)) claimedBitMap;\n TellerNFTDictionary dictionary;\n }\n\n bytes32 constant POSITION = keccak256(\"teller_nft.distributor\");\n\n function distributorStore()\n internal\n pure\n returns (DistributorStorage storage s)\n {\n bytes32 P = POSITION;\n assembly {\n s.slot := P\n }\n }\n}\n" + }, + "contracts/nft/distributor/data.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nbytes32 constant ADMIN = keccak256(\"ADMIN\");\nbytes32 constant MINTER = keccak256(\"MINTER\");\n\nstruct MerkleRoot {\n bytes32 merkleRoot;\n uint256 tierIndex;\n}\n\nstruct ClaimNFTRequest {\n uint256 merkleIndex;\n uint256 nodeIndex;\n uint256 amount;\n bytes32[] merkleProof;\n}\n\nlibrary DistributorEvents {\n event Claimed(address indexed account);\n\n event MerkleAdded(uint256 index);\n}\n" + }, + "contracts/nft/ITellerNFT.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\npragma experimental ABIEncoderV2;\n\n// Interfaces\nimport \"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\";\n\ninterface ITellerNFT {\n struct Tier {\n uint256 baseLoanSize;\n string[] hashes;\n address contributionAsset;\n uint256 contributionSize;\n uint8 contributionMultiplier;\n }\n\n /**\n * @notice The contract metadata URI.\n * @return the contractURI in string\n */\n function contractURI() external view returns (string memory);\n\n /**\n * @notice It returns information about a Tier with from a tier index\n * @param index Tier index to get info.\n * @return tier_ the tier which belongs to the respective index\n */\n function getTier(uint256 index) external view returns (Tier memory tier_);\n\n /**\n * @notice It returns information about a Tier for a token ID.\n * @param tokenId ID of the token to get Tier info.\n * @return index_ the index of the tier the tokenID belongs in\n * @return tier_ the tier where the tokenID belongs in\n */\n function getTokenTier(uint256 tokenId)\n external\n view\n returns (uint256 index_, Tier memory tier_);\n\n /**\n * @notice It returns an array of hashes in a tier\n * @param tierIndex the tier index to get the tier hashes\n * @return hashes_ all the tokenID hashes\n */\n function getTierHashes(uint256 tierIndex)\n external\n view\n returns (string[] memory hashes_);\n\n /**\n * @notice It returns an array of token IDs owned by an address.\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\n * @dev Can be costly if calling within a contract for address with many tokens.\n * @return owned the array of tokenIDs owned by the address\n */\n function getOwnedTokens(address owner)\n external\n view\n returns (uint256[] memory owned);\n\n /**\n * @notice It mints a new token for a Tier index.\n * @param tierIndex the tier index to mint the token in\n * @param owner the owner of the new token\n * Requirements:\n * - Caller must be an authorized minter\n */\n function mint(uint256 tierIndex, address owner) external;\n\n /**\n * @notice Adds a new Tier to be minted with the given information.\n * @dev It auto increments the index of the next tier to add.\n * @param newTier Information about the new tier to add.\n *\n * Requirements:\n * - Caller must have the {MINTER} role\n */\n function addTier(Tier memory newTier) external;\n\n /**\n * @notice Sets the contract level metadata URI hash.\n * @param contractURIHash The hash to the initial contract level metadata.\n */\n function setContractURIHash(string memory contractURIHash) external;\n\n /**\n * @notice Initializes the TellerNFT.\n * @param minters The addresses that should allowed to mint tokens.\n */\n function initialize(address[] calldata minters) external;\n}\n" + }, + "contracts/nft/TellerNFTDictionary.sol": { + "content": "/**\n * @notice TellerNFTDictionary Version 1.02\n *\n * @notice This contract is used to gather data for TellerV1 NFTs more efficiently.\n * @notice This contract has data which must be continuously synchronized with the TellerV1 NFT data\n *\n * @author develop@teller.finance\n */\n\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\";\n\n// Interfaces\nimport \"./IStakeableNFT.sol\";\n\n/**\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\n *\n * @author develop@teller.finance\n */\ncontract TellerNFTDictionary is IStakeableNFT, AccessControlUpgradeable {\n struct Tier {\n uint256 baseLoanSize;\n string[] hashes;\n address contributionAsset;\n uint256 contributionSize;\n uint8 contributionMultiplier;\n }\n\n mapping(uint256 => uint256) public baseLoanSizes;\n mapping(uint256 => string[]) public hashes;\n mapping(uint256 => address) public contributionAssets;\n mapping(uint256 => uint256) public contributionSizes;\n mapping(uint256 => uint8) public contributionMultipliers;\n\n /* Constants */\n\n bytes32 public constant ADMIN = keccak256(\"ADMIN\");\n\n /* State Variables */\n\n mapping(uint256 => uint256) public _tokenTierMappingCompressed;\n bool public _tokenTierMappingCompressedSet;\n\n /* Modifiers */\n\n modifier onlyAdmin() {\n require(hasRole(ADMIN, _msgSender()), \"TellerNFTDictionary: not admin\");\n _;\n }\n\n function initialize(address initialAdmin) public {\n _setupRole(ADMIN, initialAdmin);\n _setRoleAdmin(ADMIN, ADMIN);\n\n __AccessControl_init();\n }\n\n /* External Functions */\n\n /**\n * @notice It returns information about a Tier for a token ID.\n * @param tokenId ID of the token to get Tier info.\n */\n function getTokenTierIndex(uint256 tokenId)\n public\n view\n returns (uint8 index_)\n {\n //32 * 8 = 256 - each uint256 holds the data of 32 tokens . 8 bits each.\n\n uint256 mappingIndex = tokenId / 32;\n\n uint256 compressedRegister = _tokenTierMappingCompressed[mappingIndex];\n\n //use 31 instead of 32 to account for the '0x' in the start.\n //the '31 -' reverses our bytes order which is necessary\n\n uint256 offset = ((31 - (tokenId % 32)) * 8);\n\n uint8 tierIndex = uint8((compressedRegister >> offset));\n\n return tierIndex;\n }\n\n function getTierHashes(uint256 tierIndex)\n external\n view\n returns (string[] memory)\n {\n return hashes[tierIndex];\n }\n\n /**\n * @notice Adds a new Tier to be minted with the given information.\n * @dev It auto increments the index of the next tier to add.\n * @param newTier Information about the new tier to add.\n *\n * Requirements:\n * - Caller must have the {Admin} role\n */\n function setTier(uint256 index, Tier memory newTier)\n external\n onlyAdmin\n returns (bool)\n {\n baseLoanSizes[index] = newTier.baseLoanSize;\n hashes[index] = newTier.hashes;\n contributionAssets[index] = newTier.contributionAsset;\n contributionSizes[index] = newTier.contributionSize;\n contributionMultipliers[index] = newTier.contributionMultiplier;\n\n return true;\n }\n\n /**\n * @notice Sets the tiers for each tokenId using compressed data.\n * @param tiersMapping Information about the new tiers to add.\n *\n * Requirements:\n * - Caller must have the {Admin} role\n */\n function setAllTokenTierMappings(uint256[] memory tiersMapping)\n public\n onlyAdmin\n returns (bool)\n {\n require(\n !_tokenTierMappingCompressedSet,\n \"TellerNFTDictionary: token tier mapping already set\"\n );\n for (uint256 i = 0; i < tiersMapping.length; i++) {\n _tokenTierMappingCompressed[i] = tiersMapping[i];\n }\n\n _tokenTierMappingCompressedSet = true;\n return true;\n }\n\n /**\n * @notice Sets the tiers for each tokenId using compressed data.\n * @param index the mapping row, each holds data for 32 tokens\n * @param tierMapping Information about the new tier to add.\n *\n * Requirements:\n * - Caller must have the {Admin} role\n */\n function setTokenTierMapping(uint256 index, uint256 tierMapping)\n public\n onlyAdmin\n returns (bool)\n {\n _tokenTierMappingCompressed[index] = tierMapping;\n\n return true;\n }\n\n /**\n * @notice Sets a specific tier for a specific tokenId using compressed data.\n * @param tokenIds the NFT token Ids for which to add data\n * @param tokenTier the index of the tier that these tokenIds should have\n *\n * Requirements:\n * - Caller must have the {Admin} role\n */\n function setTokenTierForTokenIds(\n uint256[] calldata tokenIds,\n uint256 tokenTier\n ) public onlyAdmin returns (bool) {\n for (uint256 i; i < tokenIds.length; i++) {\n setTokenTierForTokenId(tokenIds[i], tokenTier);\n }\n\n return true;\n }\n\n /**\n * @notice Sets a specific tier for a specific tokenId using compressed data.\n * @param tokenId the NFT token Id for which to add data\n * @param tokenTier the index of the tier that these tokenIds should have\n *\n * Requirements:\n * - Caller must have the {Admin} role\n */\n function setTokenTierForTokenId(uint256 tokenId, uint256 tokenTier)\n public\n onlyAdmin\n returns (bool)\n {\n uint256 mappingIndex = tokenId / 32;\n\n uint256 existingRegister = _tokenTierMappingCompressed[mappingIndex];\n\n uint256 offset = ((31 - (tokenId % 32)) * 8);\n\n uint256 updateMaskShifted =\n 0x00000000000000000000000000000000000000000000000000000000000000FF <<\n offset;\n\n uint256 updateMaskShiftedNegated = ~updateMaskShifted;\n\n uint256 tokenTierShifted =\n ((0x0000000000000000000000000000000000000000000000000000000000000000 |\n tokenTier) << offset);\n\n uint256 existingRegisterClearedWithMask =\n existingRegister & updateMaskShiftedNegated;\n\n uint256 updatedRegister =\n existingRegisterClearedWithMask | tokenTierShifted;\n\n _tokenTierMappingCompressed[mappingIndex] = updatedRegister;\n\n return true;\n }\n\n function supportsInterface(bytes4 interfaceId)\n public\n view\n override(AccessControlUpgradeable)\n returns (bool)\n {\n return\n interfaceId == type(IStakeableNFT).interfaceId ||\n AccessControlUpgradeable.supportsInterface(interfaceId);\n }\n\n /**\n New methods for the dictionary\n */\n\n /**\n * @notice It returns Base Loan Size for a token ID.\n * @param tokenId ID of the token to get info.\n */\n function tokenBaseLoanSize(uint256 tokenId)\n public\n view\n override\n returns (uint256)\n {\n uint8 tokenTier = getTokenTierIndex(tokenId);\n\n return baseLoanSizes[tokenTier];\n }\n\n /**\n * @notice It returns Token URI Hash for a token ID.\n * @param tokenId ID of the token to get info.\n */\n function tokenURIHash(uint256 tokenId)\n public\n view\n override\n returns (string memory)\n {\n uint8 tokenTier = getTokenTierIndex(tokenId);\n\n string[] memory tierImageHashes = hashes[tokenTier];\n return tierImageHashes[tokenId % (tierImageHashes.length)];\n }\n\n /**\n * @notice It returns Contribution Asset for a token ID.\n * @param tokenId ID of the token to get info.\n */\n function tokenContributionAsset(uint256 tokenId)\n public\n view\n override\n returns (address)\n {\n uint8 tokenTier = getTokenTierIndex(tokenId);\n\n return contributionAssets[tokenTier];\n }\n\n /**\n * @notice It returns Contribution Size for a token ID.\n * @param tokenId ID of the token to get info.\n */\n function tokenContributionSize(uint256 tokenId)\n public\n view\n override\n returns (uint256)\n {\n uint8 tokenTier = getTokenTierIndex(tokenId);\n\n return contributionSizes[tokenTier];\n }\n\n /**\n * @notice It returns Contribution Multiplier for a token ID.\n * @param tokenId ID of the token to get info.\n */\n function tokenContributionMultiplier(uint256 tokenId)\n public\n view\n override\n returns (uint8)\n {\n uint8 tokenTier = getTokenTierIndex(tokenId);\n\n return contributionMultipliers[tokenTier];\n }\n}\n" + }, + "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC721.sol\";\n\n/**\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\n * @dev See https://eips.ethereum.org/EIPS/eip-721\n */\ninterface IERC721Metadata is IERC721 {\n\n /**\n * @dev Returns the token collection name.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the token collection symbol.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\n */\n function tokenURI(uint256 tokenId) external view returns (string memory);\n}\n" + }, + "@openzeppelin/contracts/token/ERC721/IERC721.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev Required interface of an ERC721 compliant contract.\n */\ninterface IERC721 is IERC165 {\n /**\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\n */\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n\n /**\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\n */\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n\n /**\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\n */\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n /**\n * @dev Returns the number of tokens in ``owner``'s account.\n */\n function balanceOf(address owner) external view returns (uint256 balance);\n\n /**\n * @dev Returns the owner of the `tokenId` token.\n *\n * Requirements:\n *\n * - `tokenId` must exist.\n */\n function ownerOf(uint256 tokenId) external view returns (address owner);\n\n /**\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must exist and be owned by `from`.\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n *\n * Emits a {Transfer} event.\n */\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\n\n /**\n * @dev Transfers `tokenId` token from `from` to `to`.\n *\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must be owned by `from`.\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address from, address to, uint256 tokenId) external;\n\n /**\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\n * The approval is cleared when the token is transferred.\n *\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\n *\n * Requirements:\n *\n * - The caller must own the token or be an approved operator.\n * - `tokenId` must exist.\n *\n * Emits an {Approval} event.\n */\n function approve(address to, uint256 tokenId) external;\n\n /**\n * @dev Returns the account approved for `tokenId` token.\n *\n * Requirements:\n *\n * - `tokenId` must exist.\n */\n function getApproved(uint256 tokenId) external view returns (address operator);\n\n /**\n * @dev Approve or remove `operator` as an operator for the caller.\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\n *\n * Requirements:\n *\n * - The `operator` cannot be the caller.\n *\n * Emits an {ApprovalForAll} event.\n */\n function setApprovalForAll(address operator, bool _approved) external;\n\n /**\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\n *\n * See {setApprovalForAll}\n */\n function isApprovedForAll(address owner, address operator) external view returns (bool);\n\n /**\n * @dev Safely transfers `tokenId` token from `from` to `to`.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must exist and be owned by `from`.\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n *\n * Emits a {Transfer} event.\n */\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\n}\n" + }, + "@openzeppelin/contracts/utils/introspection/IERC165.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n /**\n * @dev Returns true if this contract implements the interface defined by\n * `interfaceId`. See the corresponding\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n * to learn more about how these ids are created.\n *\n * This function call must use less than 30 000 gas.\n */\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n" + }, + "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../utils/StringsUpgradeable.sol\";\nimport \"../utils/introspection/ERC165Upgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev External interface of AccessControl declared to support ERC165 detection.\n */\ninterface IAccessControlUpgradeable {\n function hasRole(bytes32 role, address account) external view returns (bool);\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\n function grantRole(bytes32 role, address account) external;\n function revokeRole(bytes32 role, address account) external;\n function renounceRole(bytes32 role, address account) external;\n}\n\n/**\n * @dev Contract module that allows children to implement role-based access\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\n * members except through off-chain means by accessing the contract event logs. Some\n * applications may benefit from on-chain enumerability, for those cases see\n * {AccessControlEnumerable}.\n *\n * Roles are referred to by their `bytes32` identifier. These should be exposed\n * in the external API and be unique. The best way to achieve this is by\n * using `public constant` hash digests:\n *\n * ```\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\n * ```\n *\n * Roles can be used to represent a set of permissions. To restrict access to a\n * function call, use {hasRole}:\n *\n * ```\n * function foo() public {\n * require(hasRole(MY_ROLE, msg.sender));\n * ...\n * }\n * ```\n *\n * Roles can be granted and revoked dynamically via the {grantRole} and\n * {revokeRole} functions. Each role has an associated admin role, and only\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\n *\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\n * that only accounts with this role will be able to grant or revoke other\n * roles. More complex role relationships can be created by using\n * {_setRoleAdmin}.\n *\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\n * grant and revoke this role. Extra precautions should be taken to secure\n * accounts that have been granted it.\n */\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\n function __AccessControl_init() internal initializer {\n __Context_init_unchained();\n __ERC165_init_unchained();\n __AccessControl_init_unchained();\n }\n\n function __AccessControl_init_unchained() internal initializer {\n }\n struct RoleData {\n mapping (address => bool) members;\n bytes32 adminRole;\n }\n\n mapping (bytes32 => RoleData) private _roles;\n\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n /**\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n *\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n * {RoleAdminChanged} not being emitted signaling this.\n *\n * _Available since v3.1._\n */\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n /**\n * @dev Emitted when `account` is granted `role`.\n *\n * `sender` is the account that originated the contract call, an admin role\n * bearer except when using {_setupRole}.\n */\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n /**\n * @dev Emitted when `account` is revoked `role`.\n *\n * `sender` is the account that originated the contract call:\n * - if using `revokeRole`, it is the admin role bearer\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\n */\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n /**\n * @dev Modifier that checks that an account has a specific role. Reverts\n * with a standardized message including the required role.\n *\n * The format of the revert reason is given by the following regular expression:\n *\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\n *\n * _Available since v4.1._\n */\n modifier onlyRole(bytes32 role) {\n _checkRole(role, _msgSender());\n _;\n }\n\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\n || super.supportsInterface(interfaceId);\n }\n\n /**\n * @dev Returns `true` if `account` has been granted `role`.\n */\n function hasRole(bytes32 role, address account) public view override returns (bool) {\n return _roles[role].members[account];\n }\n\n /**\n * @dev Revert with a standard message if `account` is missing `role`.\n *\n * The format of the revert reason is given by the following regular expression:\n *\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\n */\n function _checkRole(bytes32 role, address account) internal view {\n if(!hasRole(role, account)) {\n revert(string(abi.encodePacked(\n \"AccessControl: account \",\n StringsUpgradeable.toHexString(uint160(account), 20),\n \" is missing role \",\n StringsUpgradeable.toHexString(uint256(role), 32)\n )));\n }\n }\n\n /**\n * @dev Returns the admin role that controls `role`. See {grantRole} and\n * {revokeRole}.\n *\n * To change a role's admin, use {_setRoleAdmin}.\n */\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\n return _roles[role].adminRole;\n }\n\n /**\n * @dev Grants `role` to `account`.\n *\n * If `account` had not been already granted `role`, emits a {RoleGranted}\n * event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n */\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\n _grantRole(role, account);\n }\n\n /**\n * @dev Revokes `role` from `account`.\n *\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n */\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\n _revokeRole(role, account);\n }\n\n /**\n * @dev Revokes `role` from the calling account.\n *\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\n * purpose is to provide a mechanism for accounts to lose their privileges\n * if they are compromised (such as when a trusted device is misplaced).\n *\n * If the calling account had been granted `role`, emits a {RoleRevoked}\n * event.\n *\n * Requirements:\n *\n * - the caller must be `account`.\n */\n function renounceRole(bytes32 role, address account) public virtual override {\n require(account == _msgSender(), \"AccessControl: can only renounce roles for self\");\n\n _revokeRole(role, account);\n }\n\n /**\n * @dev Grants `role` to `account`.\n *\n * If `account` had not been already granted `role`, emits a {RoleGranted}\n * event. Note that unlike {grantRole}, this function doesn't perform any\n * checks on the calling account.\n *\n * [WARNING]\n * ====\n * This function should only be called from the constructor when setting\n * up the initial roles for the system.\n *\n * Using this function in any other way is effectively circumventing the admin\n * system imposed by {AccessControl}.\n * ====\n */\n function _setupRole(bytes32 role, address account) internal virtual {\n _grantRole(role, account);\n }\n\n /**\n * @dev Sets `adminRole` as ``role``'s admin role.\n *\n * Emits a {RoleAdminChanged} event.\n */\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\n _roles[role].adminRole = adminRole;\n }\n\n function _grantRole(bytes32 role, address account) private {\n if (!hasRole(role, account)) {\n _roles[role].members[account] = true;\n emit RoleGranted(role, account, _msgSender());\n }\n }\n\n function _revokeRole(bytes32 role, address account) private {\n if (hasRole(role, account)) {\n _roles[role].members[account] = false;\n emit RoleRevoked(role, account, _msgSender());\n }\n }\n uint256[49] private __gap;\n}\n" + }, + "contracts/nft/IStakeableNFT.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IStakeableNFT {\n function tokenBaseLoanSize(uint256 tokenId) external view returns (uint256);\n\n function tokenURIHash(uint256 tokenId)\n external\n view\n returns (string memory);\n\n function tokenContributionAsset(uint256 tokenId)\n external\n view\n returns (address);\n\n function tokenContributionSize(uint256 tokenId)\n external\n view\n returns (uint256);\n\n function tokenContributionMultiplier(uint256 tokenId)\n external\n view\n returns (uint8);\n}\n" + }, + "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\nimport \"../proxy/utils/Initializable.sol\";\n\n/*\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract ContextUpgradeable is Initializable {\n function __Context_init() internal initializer {\n __Context_init_unchained();\n }\n\n function __Context_init_unchained() internal initializer {\n }\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\n return msg.data;\n }\n uint256[50] private __gap;\n}\n" + }, + "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev String operations.\n */\nlibrary StringsUpgradeable {\n bytes16 private constant alphabet = \"0123456789abcdef\";\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n */\n function toString(uint256 value) internal pure returns (string memory) {\n // Inspired by OraclizeAPI's implementation - MIT licence\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\n\n if (value == 0) {\n return \"0\";\n }\n uint256 temp = value;\n uint256 digits;\n while (temp != 0) {\n digits++;\n temp /= 10;\n }\n bytes memory buffer = new bytes(digits);\n while (value != 0) {\n digits -= 1;\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\n value /= 10;\n }\n return string(buffer);\n }\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n */\n function toHexString(uint256 value) internal pure returns (string memory) {\n if (value == 0) {\n return \"0x00\";\n }\n uint256 temp = value;\n uint256 length = 0;\n while (temp != 0) {\n length++;\n temp >>= 8;\n }\n return toHexString(value, length);\n }\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n */\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n bytes memory buffer = new bytes(2 * length + 2);\n buffer[0] = \"0\";\n buffer[1] = \"x\";\n for (uint256 i = 2 * length + 1; i > 1; --i) {\n buffer[i] = alphabet[value & 0xf];\n value >>= 4;\n }\n require(value == 0, \"Strings: hex length insufficient\");\n return string(buffer);\n }\n\n}\n" + }, + "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165Upgradeable.sol\";\nimport \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n *\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\n */\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\n function __ERC165_init() internal initializer {\n __ERC165_init_unchained();\n }\n\n function __ERC165_init_unchained() internal initializer {\n }\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return interfaceId == type(IERC165Upgradeable).interfaceId;\n }\n uint256[50] private __gap;\n}\n" + }, + "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\n// solhint-disable-next-line compiler-version\npragma solidity ^0.8.0;\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n */\nabstract contract Initializable {\n\n /**\n * @dev Indicates that the contract has been initialized.\n */\n bool private _initialized;\n\n /**\n * @dev Indicates that the contract is in the process of being initialized.\n */\n bool private _initializing;\n\n /**\n * @dev Modifier to protect an initializer function from being invoked twice.\n */\n modifier initializer() {\n require(_initializing || !_initialized, \"Initializable: contract is already initialized\");\n\n bool isTopLevelCall = !_initializing;\n if (isTopLevelCall) {\n _initializing = true;\n _initialized = true;\n }\n\n _;\n\n if (isTopLevelCall) {\n _initializing = false;\n }\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165Upgradeable {\n /**\n * @dev Returns true if this contract implements the interface defined by\n * `interfaceId`. See the corresponding\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n * to learn more about how these ids are created.\n *\n * This function call must use less than 30 000 gas.\n */\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n" + }, + "contracts/nft/distributor/interfaces/ITellerNFTDistributor.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Interfaces\nimport \"../../ITellerNFT.sol\";\n\n// Utils\nimport { ClaimNFTRequest, MerkleRoot } from \"../data.sol\";\n\ninterface ITellerNFTDistributor {\n /**\n * @notice It gets the TellerNFT diamond instance used to mint.\n * @return _nft returns the TellerNFT diamond instance\n */\n function nft() external view returns (ITellerNFT _nft);\n\n /**\n * @notice It gets the merkle roots for NFTs it can distribute.\n * @return roots_ the returned merkle roots\n */\n function getMerkleRoots()\n external\n view\n returns (MerkleRoot[] memory roots_);\n\n /**\n * @notice It checks the merkle root for a tier if it has already been claimed.\n * @param merkleIndex Index of the tier.\n * @param nodeIndex Index of the node in the merkle root.\n * @return _claimed returns a boolean to check if the tier has already been claimed\n */\n function isClaimed(uint256 merkleIndex, uint256 nodeIndex)\n external\n view\n returns (bool _claimed);\n\n /**\n * @notice Claims TellerNFTs for a given verifiable merkle proofs for each tier.\n * @param account The address to claim NFTs on behalf.\n * @param requests An array requests data generated from the merkle tree.\n *\n * Requirements:\n * - Node in the merkle root must not be claimed already\n * - Proof of the node must match the merkle tree\n */\n function claim(address account, ClaimNFTRequest[] calldata requests)\n external;\n\n /**\n * @notice Adds a new merkle to be able to claim NFTs.\n * @param tierIndex Index of NFT tier to assign merkle for.\n * @param merkleRoot The merkle root to assign to the new tier.\n *\n * Requirements:\n * - Caller must be an admin\n */\n function addMerkle(uint256 tierIndex, bytes32 merkleRoot) external;\n\n /**\n * @notice Sets a merkle to be able to claim NFTs.\n * @param index Index of merkle to set.\n * @param tierIndex Index of NFT tier to assign merkle for.\n *\n * Requirements:\n * - Caller must be an admin\n */\n function moveMerkle(uint256 index, uint256 tierIndex) external;\n\n /**\n * @notice it grants either an ADMIN or a MINTER role into an account\n * @param role the role to be granted to an account\n * @param account the account address\n */\n function grantRole(bytes32 role, address account) external;\n\n /**\n * @notice it removes either an ADMIN or a MINTER role from an account\n * @param role the role to be granted to an account\n * @param account the account address\n */\n function revokeRole(bytes32 role, address account) external;\n\n /**\n * @notice Grants an address a new role.\n * @param role the role to revoke for the account\n * @param account the address of the respective account to revoke\n */\n function renounceRole(bytes32 role, address account) external;\n\n function setNFTDictionaryAddress(address dictionary) external;\n\n /**\n * @notice Initializes the Distributor contract with the TellerNFT\n * @param _nft The address of the TellerNFT.\n * @param admin The address of an admin.\n */\n function initialize(\n address _nft,\n address _dictionary,\n address admin\n ) external;\n}\n" + }, + "contracts/nft/distributor/entry/initialize.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../store.sol\";\nimport \"../../../contexts/initializable/modifiers/initializer.sol\";\nimport \"../../../contexts/access-control/entry/grant-role.sol\";\n\n// Utils\nimport { ADMIN } from \"../data.sol\";\n\n// Interfaces\nimport \"../../ITellerNFT.sol\";\nimport \"../../TellerNFTDictionary.sol\";\n\ncontract ent_initialize_NFTDistributor_v1 is\n sto_NFTDistributor,\n mod_initializer_Initializable_v1,\n ent_grantRole_AccessControl_v1\n{\n /**\n * @notice Initializes the Distributor contract with the TellerNFT\n * @param _nft The address of the TellerNFT.\n * @param admin The address of an admin.\n */\n function initialize(\n address _nft,\n address _dictionary,\n address admin\n ) external initializer {\n distributorStore().nft = ITellerNFT(_nft);\n distributorStore().dictionary = TellerNFTDictionary(_dictionary);\n\n _grantRole(ADMIN, admin);\n }\n}\n" + }, + "contracts/contexts/initializable/modifiers/initializer.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"../storage.sol\";\n\nabstract contract mod_initializer_Initializable_v1 is sto_Initializable {\n modifier initializer {\n require(\n !initializableStorage().initialized,\n \"Teller: already initialized\"\n );\n _;\n }\n}\n" + }, + "contracts/contexts/access-control/entry/grant-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../data.sol\";\nimport \"../internal/grant-role.sol\";\nimport \"../internal/is-admin-for-role.sol\";\n\ncontract ent_grantRole_AccessControl_v1 is\n int_grantRole_AccessControl_v1,\n int_isAdminForRole_AccessControl_v1\n{\n /**\n * @notice Grants an address a new role.\n *\n * Requirements:\n * - Sender must be role admin.\n */\n function grantRole(bytes32 role, address account) external {\n require(_isAdminForRole(role, msg.sender), \"AccessControl: not admin\");\n _grantRole(role, account);\n }\n}\n" + }, + "contracts/contexts/initializable/storage.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract sto_Initializable {\n struct InitializableLayout {\n bool initialized;\n }\n\n bytes32 internal constant INITIALIZABLE_STORAGE_POSITION =\n keccak256(abi.encode(\"teller_protocol.context.initializable.v1\"));\n\n function initializableStorage()\n internal\n pure\n returns (InitializableLayout storage l_)\n {\n bytes32 position = INITIALIZABLE_STORAGE_POSITION;\n\n assembly {\n l_.slot := position\n }\n }\n}\n" + }, + "contracts/nft/NFTFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { TellerNFT } from \"../nft/TellerNFT.sol\";\nimport { RolesMods } from \"../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN, AUTHORIZED } from \"../shared/roles.sol\";\nimport \"../nft/TellerNFTDictionary.sol\";\n\n// Libraries\nimport \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\nimport { NFTLib } from \"./libraries/NFTLib.sol\";\nimport { RolesLib } from \"../contexts2/access-control/roles/RolesLib.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\ncontract NFTFacet is RolesMods {\n /**\n * @notice it gets the staked NFTs mapped to an owner's address\n * @return staked_ the returned staked NFTs mapped to an owner's address\n */\n function getStakedNFTs(address nftOwner)\n public\n view\n returns (uint256[] memory staked_)\n {\n staked_ = NFTLib.stakedNFTs(nftOwner);\n }\n\n /**\n * @notice it returns the NFTs mapped to a loan\n * @param loanID the identifier of the respective loan to get the loan NFTs from\n * @return loanNFTs the loan NFTs mapped to a loan ID\n */\n function getLoanNFTs(uint256 loanID)\n external\n view\n returns (uint256[] memory loanNFTs)\n {\n EnumerableSet.UintSet storage nfts = NFTLib.s().loanNFTs[loanID];\n loanNFTs = new uint256[](EnumerableSet.length(nfts));\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\n loanNFTs[i] = EnumerableSet.at(nfts, i);\n }\n }\n\n /**\n * @notice Transfers multiple Teller NFTs to Diamond and applies user stake.\n * @param nftIDs IDs of Teller NFTs to stake.\n */\n function stakeNFTs(uint256[] calldata nftIDs) external {\n for (uint256 i; i < nftIDs.length; i++) {\n // Stake NFT and transfer into diamond\n NFTLib.stake(nftIDs[i], msg.sender);\n }\n // Give the caller authorization to protocol\n RolesLib.grantRole(AUTHORIZED, msg.sender);\n }\n\n /**\n * @notice Sets the NFTDictionary address used to get information about an NFT and its tier.\n * @param dictAddress Dictionary address to use.\n *\n * Requirements:\n * - Sender must have `ADMIN` role\n */\n function setNFTDictionary(address dictAddress)\n external\n authorized(ADMIN, msg.sender)\n {\n NFTLib.s().nftDictionary = TellerNFTDictionary(dictAddress);\n }\n}\n" + }, + "contracts/nft/TellerNFT.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\npragma experimental ABIEncoderV2;\n\n// Contracts\nimport \"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\";\nimport \"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\";\n\n// Libraries\nimport \"@openzeppelin/contracts/utils/Counters.sol\";\nimport \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\nimport \"@openzeppelin/contracts/utils/math/SafeMath.sol\";\n\n// Interfaces\nimport \"./ITellerNFT.sol\";\n\n/*****************************************************************************************************/\n/** WARNING **/\n/** THIS CONTRACT IS UPGRADEABLE! **/\n/** --------------------------------------------------------------------------------------------- **/\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\n/** **/\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\n/** more information. **/\n/*****************************************************************************************************/\n/**\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\n *\n * @author develop@teller.finance\n */\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\n using Counters for Counters.Counter;\n using EnumerableSet for EnumerableSet.UintSet;\n using SafeMath for uint256;\n\n /* Constants */\n\n bytes32 public constant ADMIN = keccak256(\"ADMIN\");\n bytes32 public constant MINTER = keccak256(\"MINTER\");\n\n /* State Variables */\n\n // It holds the total number of tiers.\n Counters.Counter internal _tierCounter;\n\n // It holds the total number of tokens minted.\n Counters.Counter internal _tokenCounter;\n\n // It holds the information about a tier.\n mapping(uint256 => Tier) internal _tiers;\n\n // It holds which tier a token ID is in.\n mapping(uint256 => uint256) internal _tokenTier;\n\n // It holds a set of token IDs for an owner address.\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\n\n // Link to the contract metadata\n string private _metadataBaseURI;\n\n // Hash to the contract metadata located on the {_metadataBaseURI}\n string private _contractURIHash;\n\n /* Modifiers */\n\n modifier onlyAdmin() {\n require(hasRole(ADMIN, _msgSender()), \"TellerNFT: not admin\");\n _;\n }\n\n modifier onlyMinter() {\n require(hasRole(MINTER, _msgSender()), \"TellerNFT: not minter\");\n _;\n }\n\n /* External Functions */\n\n /**\n * @notice It returns information about a Tier for a token ID.\n * @param index Tier index to get info.\n * @return tier_ the tier which belongs to the respective index\n */\n function getTier(uint256 index)\n external\n view\n override\n returns (Tier memory tier_)\n {\n tier_ = _tiers[index];\n }\n\n /**\n * @notice It returns information about a Tier for a token ID.\n * @param tokenId ID of the token to get Tier info.\n * @return index_ the index of the tier the tokenID belongs in\n * @return tier_ the tier where the tokenID belongs in\n */\n function getTokenTier(uint256 tokenId)\n external\n view\n override\n returns (uint256 index_, Tier memory tier_)\n {\n index_ = _tokenTier[tokenId];\n tier_ = _tiers[index_];\n }\n\n /**\n * @notice It returns an array of hashes in a tier\n * @param tierIndex the tier index to get the tier hashes\n * @return hashes_ all the tokenID hashes\n */\n function getTierHashes(uint256 tierIndex)\n external\n view\n override\n returns (string[] memory hashes_)\n {\n hashes_ = _tiers[tierIndex].hashes;\n }\n\n /**\n * @notice It returns an array of token IDs owned by an address.\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\n * @dev Can be costly if calling within a contract for address with many tokens.\n * @return owned_ the array of tokenIDs owned by the address\n */\n function getOwnedTokens(address owner)\n external\n view\n override\n returns (uint256[] memory owned_)\n {\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\n owned_ = new uint256[](set.length());\n for (uint256 i; i < owned_.length; i++) {\n owned_[i] = set.at(i);\n }\n }\n\n /**\n * @notice The contract metadata URI.\n * @return the contract URI hash\n */\n function contractURI() external view override returns (string memory) {\n return _contractURIHash;\n }\n\n /**\n * @notice The token URI is based on the token ID.\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\n * @return the tokenURI\n */\n function tokenURI(uint256 tokenId)\n public\n view\n override\n returns (string memory)\n {\n require(_exists(tokenId), \"TellerNFT: URI query for nonexistent token\");\n\n string memory baseURI = _baseURI();\n return\n bytes(baseURI).length > 0\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\n : \"\";\n }\n\n /**\n * @notice It mints a new token for a Tier index.\n * @param tierIndex Tier to mint token on.\n * @param owner The owner of the new token.\n *\n * Requirements:\n * - Caller must be an authorized minter\n */\n function mint(uint256 tierIndex, address owner)\n external\n override\n onlyMinter\n {\n // Get the new token ID\n uint256 tokenId = _tokenCounter.current();\n _tokenCounter.increment();\n\n // Mint and set the token to the tier index\n _safeMint(owner, tokenId);\n _tokenTier[tokenId] = tierIndex;\n\n // Set owner\n _setOwner(owner, tokenId);\n }\n\n /**\n * @notice Adds a new Tier to be minted with the given information.\n * @dev It auto increments the index of the next tier to add.\n * @param newTier Information about the new tier to add.\n *\n * Requirements:\n * - Caller must have the {MINTER} role\n */\n function addTier(Tier memory newTier) external override onlyMinter {\n Tier storage tier = _tiers[_tierCounter.current()];\n\n tier.baseLoanSize = newTier.baseLoanSize;\n tier.hashes = newTier.hashes;\n tier.contributionAsset = newTier.contributionAsset;\n tier.contributionSize = newTier.contributionSize;\n tier.contributionMultiplier = newTier.contributionMultiplier;\n\n _tierCounter.increment();\n }\n\n /**\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\n * @param minter the address of the minter\n */\n function removeMinter(address minter) external onlyMinter {\n revokeRole(MINTER, minter);\n }\n\n /**\n * @notice it adds the minter to the rule\n * @param minter the address of the minter to add to the role of MINTER\n */\n function addMinter(address minter) public onlyMinter {\n _setupRole(MINTER, minter);\n }\n\n /**\n * @notice Sets the contract level metadata URI hash.\n * @param contractURIHash The hash to the initial contract level metadata.\n */\n function setContractURIHash(string memory contractURIHash)\n external\n override\n onlyAdmin\n {\n _contractURIHash = contractURIHash;\n }\n\n /**\n * @notice Initializes the TellerNFT.\n * @param minters The addresses that should allowed to mint tokens.\n */\n function initialize(address[] calldata minters)\n external\n override\n initializer\n {\n __ERC721_init(\"Teller NFT\", \"TNFT\");\n __AccessControl_init();\n\n for (uint256 i; i < minters.length; i++) {\n _setupRole(MINTER, minters[i]);\n }\n\n _metadataBaseURI = \"https://gateway.pinata.cloud/ipfs/\";\n _contractURIHash = \"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\";\n }\n\n /**\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\n * @param interfaceId the identifier of the interface\n * @return bool stating whether or not our interface is supported\n */\n function supportsInterface(bytes4 interfaceId)\n public\n view\n override(AccessControlUpgradeable, ERC721Upgradeable)\n returns (bool)\n {\n return\n interfaceId == type(ITellerNFT).interfaceId ||\n ERC721Upgradeable.supportsInterface(interfaceId) ||\n AccessControlUpgradeable.supportsInterface(interfaceId);\n }\n\n /**\n * @notice It returns the hash to use for the token URI.\n * @param tokenId the tokenId to get the tokenURI hash\n * @return the tokenURIHash of our NFT\n */\n function _tokenURIHash(uint256 tokenId)\n internal\n view\n returns (string memory)\n {\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\n }\n\n /**\n * @notice The base URI path where the token media is hosted.\n * @dev Base URI for computing {tokenURI}\n * @return our metadata URI\n */\n function _baseURI() internal view override returns (string memory) {\n return _metadataBaseURI;\n }\n\n /**\n * @notice Moves token to new owner set and then transfers.\n * @param from address to transfer from\n * @param to address to transfer to\n * @param tokenId tokenID to transfer\n */\n function _transfer(\n address from,\n address to,\n uint256 tokenId\n ) internal override {\n _setOwner(to, tokenId);\n super._transfer(from, to, tokenId);\n }\n\n /**\n * @notice It removes the token from the current owner set and adds to new owner.\n * @param newOwner the new owner of the tokenID\n * @param tokenId the ID of the NFT\n */\n function _setOwner(address newOwner, uint256 tokenId) internal {\n address currentOwner = ownerOf(tokenId);\n if (currentOwner != address(0)) {\n _ownerTokenIDs[currentOwner].remove(tokenId);\n }\n _ownerTokenIDs[newOwner].add(tokenId);\n }\n\n function _msgData() internal pure override returns (bytes calldata) {\n return msg.data;\n }\n}\n" + }, + "contracts/contexts2/access-control/roles/RolesMods.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { RolesLib } from \"./RolesLib.sol\";\n\nabstract contract RolesMods {\n /**\n * @notice Requires that the {account} has {role}\n * @param role Encoding of the role to check.\n * @param account Address to check the {role} for.\n */\n modifier authorized(bytes32 role, address account) {\n require(\n RolesLib.hasRole(role, account),\n \"AccessControl: not authorized\"\n );\n _;\n }\n}\n" + }, + "contracts/shared/roles.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/**\n * @dev the roles for the user to assign, revoke and check in functions\n */\nbytes32 constant ADMIN = keccak256(\"ADMIN\");\nbytes32 constant PAUSER = keccak256(\"PAUSER\");\nbytes32 constant AUTHORIZED = keccak256(\"AUTHORIZED\");\n" + }, + "@openzeppelin/contracts/utils/structs/EnumerableSet.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for managing\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\n * types.\n *\n * Sets have the following properties:\n *\n * - Elements are added, removed, and checked for existence in constant time\n * (O(1)).\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\n *\n * ```\n * contract Example {\n * // Add the library methods\n * using EnumerableSet for EnumerableSet.AddressSet;\n *\n * // Declare a set state variable\n * EnumerableSet.AddressSet private mySet;\n * }\n * ```\n *\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\n * and `uint256` (`UintSet`) are supported.\n */\nlibrary EnumerableSet {\n // To implement this library for multiple types with as little code\n // repetition as possible, we write it in terms of a generic Set type with\n // bytes32 values.\n // The Set implementation uses private functions, and user-facing\n // implementations (such as AddressSet) are just wrappers around the\n // underlying Set.\n // This means that we can only create new EnumerableSets for types that fit\n // in bytes32.\n\n struct Set {\n // Storage of set values\n bytes32[] _values;\n\n // Position of the value in the `values` array, plus 1 because index 0\n // means a value is not in the set.\n mapping (bytes32 => uint256) _indexes;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function _add(Set storage set, bytes32 value) private returns (bool) {\n if (!_contains(set, value)) {\n set._values.push(value);\n // The value is stored at length-1, but we add 1 to all indexes\n // and use 0 as a sentinel value\n set._indexes[value] = set._values.length;\n return true;\n } else {\n return false;\n }\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function _remove(Set storage set, bytes32 value) private returns (bool) {\n // We read and store the value's index to prevent multiple reads from the same storage slot\n uint256 valueIndex = set._indexes[value];\n\n if (valueIndex != 0) { // Equivalent to contains(set, value)\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\n // the array, and then remove the last element (sometimes called as 'swap and pop').\n // This modifies the order of the array, as noted in {at}.\n\n uint256 toDeleteIndex = valueIndex - 1;\n uint256 lastIndex = set._values.length - 1;\n\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\n\n bytes32 lastvalue = set._values[lastIndex];\n\n // Move the last value to the index where the value to delete is\n set._values[toDeleteIndex] = lastvalue;\n // Update the index for the moved value\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\n\n // Delete the slot where the moved value was stored\n set._values.pop();\n\n // Delete the index for the deleted slot\n delete set._indexes[value];\n\n return true;\n } else {\n return false;\n }\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\n return set._indexes[value] != 0;\n }\n\n /**\n * @dev Returns the number of values on the set. O(1).\n */\n function _length(Set storage set) private view returns (uint256) {\n return set._values.length;\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\n require(set._values.length > index, \"EnumerableSet: index out of bounds\");\n return set._values[index];\n }\n\n // Bytes32Set\n\n struct Bytes32Set {\n Set _inner;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\n return _add(set._inner, value);\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\n return _remove(set._inner, value);\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\n return _contains(set._inner, value);\n }\n\n /**\n * @dev Returns the number of values in the set. O(1).\n */\n function length(Bytes32Set storage set) internal view returns (uint256) {\n return _length(set._inner);\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\n return _at(set._inner, index);\n }\n\n // AddressSet\n\n struct AddressSet {\n Set _inner;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function add(AddressSet storage set, address value) internal returns (bool) {\n return _add(set._inner, bytes32(uint256(uint160(value))));\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function remove(AddressSet storage set, address value) internal returns (bool) {\n return _remove(set._inner, bytes32(uint256(uint160(value))));\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function contains(AddressSet storage set, address value) internal view returns (bool) {\n return _contains(set._inner, bytes32(uint256(uint160(value))));\n }\n\n /**\n * @dev Returns the number of values in the set. O(1).\n */\n function length(AddressSet storage set) internal view returns (uint256) {\n return _length(set._inner);\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\n return address(uint160(uint256(_at(set._inner, index))));\n }\n\n\n // UintSet\n\n struct UintSet {\n Set _inner;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function add(UintSet storage set, uint256 value) internal returns (bool) {\n return _add(set._inner, bytes32(value));\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\n return _remove(set._inner, bytes32(value));\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\n return _contains(set._inner, bytes32(value));\n }\n\n /**\n * @dev Returns the number of values on the set. O(1).\n */\n function length(UintSet storage set) internal view returns (uint256) {\n return _length(set._inner);\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\n return uint256(_at(set._inner, index));\n }\n}\n" + }, + "contracts/nft/libraries/NFTLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { TellerNFT } from \"../TellerNFT.sol\";\n\n// Libraries\nimport {\n MerkleProof\n} from \"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\n// Storage\nimport { AppStorageLib, AppStorage } from \"../../storage/app.sol\";\nimport { NFTStorageLib, NFTStorage } from \"../../storage/nft.sol\";\n\nlibrary NFTLib {\n function s() internal pure returns (NFTStorage storage s_) {\n s_ = NFTStorageLib.store();\n }\n\n function nft() internal view returns (TellerNFT nft_) {\n nft_ = AppStorageLib.store().nft;\n }\n\n /**s\n * @notice it transfers the NFT from the sender to the diamond to stake then adds the NFTID to the list of the owner's stakedNFTs\n * @param nftID the ID of the NFT to stake\n * @param owner the owner of the NFT who will stake the NFT\n */\n function stake(uint256 nftID, address owner) internal {\n // Transfer to diamond\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\n // Add NFT ID to user set\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\n }\n\n /**\n * @notice it unstakes the NFT by removing the NFT ID from the list of the user's staked NFTs\n * @param nftID the ID of the NFT to remove from the list of the user's staked NFTs\n * @return success_ the boolean value telling us if the user has unsuccessfully unstaked the NFT\n */\n function unstake(uint256 nftID) internal returns (bool success_) {\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\n }\n\n /**\n * @notice it gets the list of staked NFTs from the owner\n * @param nftOwner the owner of the staked NFTs to pull from\n * @return staked_ the array of the staked NFTs owned by the user\n */\n function stakedNFTs(address nftOwner)\n internal\n view\n returns (uint256[] memory staked_)\n {\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\n staked_ = new uint256[](EnumerableSet.length(nfts));\n for (uint256 i; i < staked_.length; i++) {\n staked_[i] = EnumerableSet.at(nfts, i);\n }\n }\n\n /**\n * @notice if the user fails to pay his loan, then we liquidate the all the NFTs associated with the loan\n * @param loanID the identifier of the loan to liquidate the NFTs from\n */\n function liquidateNFT(uint256 loanID) internal {\n // Check if NFTs are linked\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\n NFTLib.nft().transferFrom(\n address(this),\n AppStorageLib.store().nftLiquidationController,\n EnumerableSet.at(nfts, i)\n );\n }\n }\n\n /**\n * @notice it unstakes an NFT and verifies the proof in order to apply the proof to a loan\n * @param loanID the identifier of the loan\n * @param nftID the NFT ID to apply to the loan\n */\n function applyToLoan(uint256 loanID, uint256 nftID) internal {\n // NFT must be currently staked\n // Remove NFT from being staked - returns bool\n require(unstake(nftID), \"Teller: borrower nft not staked\");\n\n // Apply NFT to loan\n EnumerableSet.add(s().loanNFTs[loanID], nftID);\n }\n\n /**\n * @notice it finds the loan's NFTs and adds them back to the owner's list of staked NFTs\n * @param loanID the identifier of the respective loan to add the NFTs back to the user's staked NFTs\n * @param owner the owner to add the unstaked NFTs back to the staked pile\n */\n function restakeLinked(uint256 loanID, address owner) internal {\n // Get linked NFT\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\n // Restake the NFT\n EnumerableSet.add(s().stakedNFTs[owner], EnumerableSet.at(nfts, i));\n }\n }\n}\n" + }, + "contracts/contexts2/access-control/roles/RolesLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlStorageLib, AccessControlStorage } from \"../storage.sol\";\n\nlibrary RolesLib {\n function s() private pure returns (AccessControlStorage storage) {\n return AccessControlStorageLib.store();\n }\n\n /**\n * @dev Emitted when `account` is granted `role`.\n */\n event RoleGranted(\n bytes32 indexed role,\n address indexed account,\n address indexed sender\n );\n\n /**\n * @dev Emitted when `account` is revoked `role`.\n */\n event RoleRevoked(\n bytes32 indexed role,\n address indexed account,\n address indexed sender\n );\n\n /**\n * @notice Checks if an account has a specific role.\n */\n function hasRole(bytes32 role, address account)\n internal\n view\n returns (bool)\n {\n return s().roles[role][account];\n }\n\n /**\n * @dev Gives an account a new role.\n * @dev Should only use when circumventing admin checking.\n * @dev If account already has the role, no event is emitted.\n * @param role Encoding of the role to give.\n * @param account Address to give the {role} to.\n */\n function grantRole(bytes32 role, address account) internal {\n if (hasRole(role, account)) return;\n s().roles[role][account] = true;\n emit RoleGranted(role, account, msg.sender);\n }\n\n /**\n * @dev Removes a role from an account.\n * @dev Should only use when circumventing admin checking.\n * @dev If account does not already have the role, no event is emitted.\n * @param role Encoding of the role to remove.\n * @param account Address to remove the {role} from.\n */\n function revokeRole(bytes32 role, address account) internal {\n if (!hasRole(role, account)) return;\n s().roles[role][account] = false;\n emit RoleRevoked(role, account, msg.sender);\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IERC721Upgradeable.sol\";\nimport \"./IERC721ReceiverUpgradeable.sol\";\nimport \"./extensions/IERC721MetadataUpgradeable.sol\";\nimport \"../../utils/AddressUpgradeable.sol\";\nimport \"../../utils/ContextUpgradeable.sol\";\nimport \"../../utils/StringsUpgradeable.sol\";\nimport \"../../utils/introspection/ERC165Upgradeable.sol\";\nimport \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\n * {ERC721Enumerable}.\n */\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\n using AddressUpgradeable for address;\n using StringsUpgradeable for uint256;\n\n // Token name\n string private _name;\n\n // Token symbol\n string private _symbol;\n\n // Mapping from token ID to owner address\n mapping (uint256 => address) private _owners;\n\n // Mapping owner address to token count\n mapping (address => uint256) private _balances;\n\n // Mapping from token ID to approved address\n mapping (uint256 => address) private _tokenApprovals;\n\n // Mapping from owner to operator approvals\n mapping (address => mapping (address => bool)) private _operatorApprovals;\n\n /**\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\n */\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\n __Context_init_unchained();\n __ERC165_init_unchained();\n __ERC721_init_unchained(name_, symbol_);\n }\n\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\n _name = name_;\n _symbol = symbol_;\n }\n\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\n return interfaceId == type(IERC721Upgradeable).interfaceId\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\n || super.supportsInterface(interfaceId);\n }\n\n /**\n * @dev See {IERC721-balanceOf}.\n */\n function balanceOf(address owner) public view virtual override returns (uint256) {\n require(owner != address(0), \"ERC721: balance query for the zero address\");\n return _balances[owner];\n }\n\n /**\n * @dev See {IERC721-ownerOf}.\n */\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\n address owner = _owners[tokenId];\n require(owner != address(0), \"ERC721: owner query for nonexistent token\");\n return owner;\n }\n\n /**\n * @dev See {IERC721Metadata-name}.\n */\n function name() public view virtual override returns (string memory) {\n return _name;\n }\n\n /**\n * @dev See {IERC721Metadata-symbol}.\n */\n function symbol() public view virtual override returns (string memory) {\n return _symbol;\n }\n\n /**\n * @dev See {IERC721Metadata-tokenURI}.\n */\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\n require(_exists(tokenId), \"ERC721Metadata: URI query for nonexistent token\");\n\n string memory baseURI = _baseURI();\n return bytes(baseURI).length > 0\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\n : '';\n }\n\n /**\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\n * in child contracts.\n */\n function _baseURI() internal view virtual returns (string memory) {\n return \"\";\n }\n\n /**\n * @dev See {IERC721-approve}.\n */\n function approve(address to, uint256 tokenId) public virtual override {\n address owner = ERC721Upgradeable.ownerOf(tokenId);\n require(to != owner, \"ERC721: approval to current owner\");\n\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\n \"ERC721: approve caller is not owner nor approved for all\"\n );\n\n _approve(to, tokenId);\n }\n\n /**\n * @dev See {IERC721-getApproved}.\n */\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\n require(_exists(tokenId), \"ERC721: approved query for nonexistent token\");\n\n return _tokenApprovals[tokenId];\n }\n\n /**\n * @dev See {IERC721-setApprovalForAll}.\n */\n function setApprovalForAll(address operator, bool approved) public virtual override {\n require(operator != _msgSender(), \"ERC721: approve to caller\");\n\n _operatorApprovals[_msgSender()][operator] = approved;\n emit ApprovalForAll(_msgSender(), operator, approved);\n }\n\n /**\n * @dev See {IERC721-isApprovedForAll}.\n */\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\n return _operatorApprovals[owner][operator];\n }\n\n /**\n * @dev See {IERC721-transferFrom}.\n */\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\n //solhint-disable-next-line max-line-length\n require(_isApprovedOrOwner(_msgSender(), tokenId), \"ERC721: transfer caller is not owner nor approved\");\n\n _transfer(from, to, tokenId);\n }\n\n /**\n * @dev See {IERC721-safeTransferFrom}.\n */\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\n safeTransferFrom(from, to, tokenId, \"\");\n }\n\n /**\n * @dev See {IERC721-safeTransferFrom}.\n */\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\n require(_isApprovedOrOwner(_msgSender(), tokenId), \"ERC721: transfer caller is not owner nor approved\");\n _safeTransfer(from, to, tokenId, _data);\n }\n\n /**\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\n *\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\n *\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\n * implement alternative mechanisms to perform token transfer, such as signature-based.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must exist and be owned by `from`.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n *\n * Emits a {Transfer} event.\n */\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\n _transfer(from, to, tokenId);\n require(_checkOnERC721Received(from, to, tokenId, _data), \"ERC721: transfer to non ERC721Receiver implementer\");\n }\n\n /**\n * @dev Returns whether `tokenId` exists.\n *\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\n *\n * Tokens start existing when they are minted (`_mint`),\n * and stop existing when they are burned (`_burn`).\n */\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\n return _owners[tokenId] != address(0);\n }\n\n /**\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\n *\n * Requirements:\n *\n * - `tokenId` must exist.\n */\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\n require(_exists(tokenId), \"ERC721: operator query for nonexistent token\");\n address owner = ERC721Upgradeable.ownerOf(tokenId);\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\n }\n\n /**\n * @dev Safely mints `tokenId` and transfers it to `to`.\n *\n * Requirements:\n *\n * - `tokenId` must not exist.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n *\n * Emits a {Transfer} event.\n */\n function _safeMint(address to, uint256 tokenId) internal virtual {\n _safeMint(to, tokenId, \"\");\n }\n\n /**\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\n */\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\n _mint(to, tokenId);\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \"ERC721: transfer to non ERC721Receiver implementer\");\n }\n\n /**\n * @dev Mints `tokenId` and transfers it to `to`.\n *\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\n *\n * Requirements:\n *\n * - `tokenId` must not exist.\n * - `to` cannot be the zero address.\n *\n * Emits a {Transfer} event.\n */\n function _mint(address to, uint256 tokenId) internal virtual {\n require(to != address(0), \"ERC721: mint to the zero address\");\n require(!_exists(tokenId), \"ERC721: token already minted\");\n\n _beforeTokenTransfer(address(0), to, tokenId);\n\n _balances[to] += 1;\n _owners[tokenId] = to;\n\n emit Transfer(address(0), to, tokenId);\n }\n\n /**\n * @dev Destroys `tokenId`.\n * The approval is cleared when the token is burned.\n *\n * Requirements:\n *\n * - `tokenId` must exist.\n *\n * Emits a {Transfer} event.\n */\n function _burn(uint256 tokenId) internal virtual {\n address owner = ERC721Upgradeable.ownerOf(tokenId);\n\n _beforeTokenTransfer(owner, address(0), tokenId);\n\n // Clear approvals\n _approve(address(0), tokenId);\n\n _balances[owner] -= 1;\n delete _owners[tokenId];\n\n emit Transfer(owner, address(0), tokenId);\n }\n\n /**\n * @dev Transfers `tokenId` from `from` to `to`.\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\n *\n * Requirements:\n *\n * - `to` cannot be the zero address.\n * - `tokenId` token must be owned by `from`.\n *\n * Emits a {Transfer} event.\n */\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \"ERC721: transfer of token that is not own\");\n require(to != address(0), \"ERC721: transfer to the zero address\");\n\n _beforeTokenTransfer(from, to, tokenId);\n\n // Clear approvals from the previous owner\n _approve(address(0), tokenId);\n\n _balances[from] -= 1;\n _balances[to] += 1;\n _owners[tokenId] = to;\n\n emit Transfer(from, to, tokenId);\n }\n\n /**\n * @dev Approve `to` to operate on `tokenId`\n *\n * Emits a {Approval} event.\n */\n function _approve(address to, uint256 tokenId) internal virtual {\n _tokenApprovals[tokenId] = to;\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\n }\n\n /**\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\n * The call is not executed if the target address is not a contract.\n *\n * @param from address representing the previous owner of the given token ID\n * @param to target address that will receive the tokens\n * @param tokenId uint256 ID of the token to be transferred\n * @param _data bytes optional data to send along with the call\n * @return bool whether the call correctly returned the expected magic value\n */\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\n private returns (bool)\n {\n if (to.isContract()) {\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\n } catch (bytes memory reason) {\n if (reason.length == 0) {\n revert(\"ERC721: transfer to non ERC721Receiver implementer\");\n } else {\n // solhint-disable-next-line no-inline-assembly\n assembly {\n revert(add(32, reason), mload(reason))\n }\n }\n }\n } else {\n return true;\n }\n }\n\n /**\n * @dev Hook that is called before any token transfer. This includes minting\n * and burning.\n *\n * Calling conditions:\n *\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\n * transferred to `to`.\n * - When `from` is zero, `tokenId` will be minted for `to`.\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n *\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n */\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\n uint256[44] private __gap;\n}\n" + }, + "@openzeppelin/contracts/utils/Counters.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @title Counters\n * @author Matt Condon (@shrugs)\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\n *\n * Include with `using Counters for Counters.Counter;`\n */\nlibrary Counters {\n struct Counter {\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\n // this feature: see https://github.com/ethereum/solidity/issues/4637\n uint256 _value; // default: 0\n }\n\n function current(Counter storage counter) internal view returns (uint256) {\n return counter._value;\n }\n\n function increment(Counter storage counter) internal {\n unchecked {\n counter._value += 1;\n }\n }\n\n function decrement(Counter storage counter) internal {\n uint256 value = counter._value;\n require(value > 0, \"Counter: decrement overflow\");\n unchecked {\n counter._value = value - 1;\n }\n }\n}\n" + }, + "@openzeppelin/contracts/utils/math/SafeMath.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n// CAUTION\n// This version of SafeMath should only be used with Solidity 0.8 or later,\n// because it relies on the compiler's built in overflow checks.\n\n/**\n * @dev Wrappers over Solidity's arithmetic operations.\n *\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\n * now has built in overflow checking.\n */\nlibrary SafeMath {\n /**\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\n *\n * _Available since v3.4._\n */\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n uint256 c = a + b;\n if (c < a) return (false, 0);\n return (true, c);\n }\n }\n\n /**\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\n *\n * _Available since v3.4._\n */\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b > a) return (false, 0);\n return (true, a - b);\n }\n }\n\n /**\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\n *\n * _Available since v3.4._\n */\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n // benefit is lost if 'b' is also tested.\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n if (a == 0) return (true, 0);\n uint256 c = a * b;\n if (c / a != b) return (false, 0);\n return (true, c);\n }\n }\n\n /**\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\n *\n * _Available since v3.4._\n */\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b == 0) return (false, 0);\n return (true, a / b);\n }\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\n *\n * _Available since v3.4._\n */\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b == 0) return (false, 0);\n return (true, a % b);\n }\n }\n\n /**\n * @dev Returns the addition of two unsigned integers, reverting on\n * overflow.\n *\n * Counterpart to Solidity's `+` operator.\n *\n * Requirements:\n *\n * - Addition cannot overflow.\n */\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\n return a + b;\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, reverting on\n * overflow (when the result is negative).\n *\n * Counterpart to Solidity's `-` operator.\n *\n * Requirements:\n *\n * - Subtraction cannot overflow.\n */\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n return a - b;\n }\n\n /**\n * @dev Returns the multiplication of two unsigned integers, reverting on\n * overflow.\n *\n * Counterpart to Solidity's `*` operator.\n *\n * Requirements:\n *\n * - Multiplication cannot overflow.\n */\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n return a * b;\n }\n\n /**\n * @dev Returns the integer division of two unsigned integers, reverting on\n * division by zero. The result is rounded towards zero.\n *\n * Counterpart to Solidity's `/` operator.\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\n return a / b;\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n * reverting when dividing by zero.\n *\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n return a % b;\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n * overflow (when the result is negative).\n *\n * CAUTION: This function is deprecated because it requires allocating memory for the error\n * message unnecessarily. For custom revert reasons use {trySub}.\n *\n * Counterpart to Solidity's `-` operator.\n *\n * Requirements:\n *\n * - Subtraction cannot overflow.\n */\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n unchecked {\n require(b <= a, errorMessage);\n return a - b;\n }\n }\n\n /**\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\n * division by zero. The result is rounded towards zero.\n *\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Counterpart to Solidity's `/` operator. Note: this function uses a\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\n * uses an invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n unchecked {\n require(b > 0, errorMessage);\n return a / b;\n }\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n * reverting with custom message when dividing by zero.\n *\n * CAUTION: This function is deprecated because it requires allocating memory for the error\n * message unnecessarily. For custom revert reasons use {tryMod}.\n *\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n unchecked {\n require(b > 0, errorMessage);\n return a % b;\n }\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../../utils/introspection/IERC165Upgradeable.sol\";\n\n/**\n * @dev Required interface of an ERC721 compliant contract.\n */\ninterface IERC721Upgradeable is IERC165Upgradeable {\n /**\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\n */\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n\n /**\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\n */\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n\n /**\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\n */\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n /**\n * @dev Returns the number of tokens in ``owner``'s account.\n */\n function balanceOf(address owner) external view returns (uint256 balance);\n\n /**\n * @dev Returns the owner of the `tokenId` token.\n *\n * Requirements:\n *\n * - `tokenId` must exist.\n */\n function ownerOf(uint256 tokenId) external view returns (address owner);\n\n /**\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must exist and be owned by `from`.\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n *\n * Emits a {Transfer} event.\n */\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\n\n /**\n * @dev Transfers `tokenId` token from `from` to `to`.\n *\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must be owned by `from`.\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address from, address to, uint256 tokenId) external;\n\n /**\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\n * The approval is cleared when the token is transferred.\n *\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\n *\n * Requirements:\n *\n * - The caller must own the token or be an approved operator.\n * - `tokenId` must exist.\n *\n * Emits an {Approval} event.\n */\n function approve(address to, uint256 tokenId) external;\n\n /**\n * @dev Returns the account approved for `tokenId` token.\n *\n * Requirements:\n *\n * - `tokenId` must exist.\n */\n function getApproved(uint256 tokenId) external view returns (address operator);\n\n /**\n * @dev Approve or remove `operator` as an operator for the caller.\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\n *\n * Requirements:\n *\n * - The `operator` cannot be the caller.\n *\n * Emits an {ApprovalForAll} event.\n */\n function setApprovalForAll(address operator, bool _approved) external;\n\n /**\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\n *\n * See {setApprovalForAll}\n */\n function isApprovedForAll(address owner, address operator) external view returns (bool);\n\n /**\n * @dev Safely transfers `tokenId` token from `from` to `to`.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must exist and be owned by `from`.\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n *\n * Emits a {Transfer} event.\n */\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @title ERC721 token receiver interface\n * @dev Interface for any contract that wants to support safeTransfers\n * from ERC721 asset contracts.\n */\ninterface IERC721ReceiverUpgradeable {\n /**\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\n * by `operator` from `from`, this function is called.\n *\n * It must return its Solidity selector to confirm the token transfer.\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\n *\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\n */\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC721Upgradeable.sol\";\n\n/**\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\n * @dev See https://eips.ethereum.org/EIPS/eip-721\n */\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\n\n /**\n * @dev Returns the token collection name.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the token collection symbol.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\n */\n function tokenURI(uint256 tokenId) external view returns (string memory);\n}\n" + }, + "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary AddressUpgradeable {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize, which returns 0 for contracts in\n // construction, since the code is only stored at the end of the\n // constructor execution.\n\n uint256 size;\n // solhint-disable-next-line no-inline-assembly\n assembly { size := extcodesize(account) }\n return size > 0;\n }\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\n (bool success, ) = recipient.call{ value: amount }(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain`call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCall(target, data, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n require(isContract(target), \"Address: call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\n return _verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\n require(isContract(target), \"Address: static call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.staticcall(data);\n return _verifyCallResult(success, returndata, errorMessage);\n }\n\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\n if (success) {\n return returndata;\n } else {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n }\n}\n" + }, + "contracts/contexts2/access-control/storage.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nstruct AccessControlStorage {\n mapping(bytes32 => mapping(address => bool)) roles;\n mapping(address => address) owners;\n mapping(bytes32 => bool) entered;\n}\n\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\n \"teller.access_control.storage\"\n);\n\nlibrary AccessControlStorageLib {\n function store() internal pure returns (AccessControlStorage storage s) {\n bytes32 pos = ACCESS_CONTROL_POS;\n assembly {\n s.slot := pos\n }\n }\n}\n" + }, + "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev These functions deal with verification of Merkle Trees proofs.\n *\n * The proofs can be generated using the JavaScript library\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\n *\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\n */\nlibrary MerkleProof {\n /**\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\n * defined by `root`. For this, a `proof` must be provided, containing\n * sibling hashes on the branch from the leaf to the root of the tree. Each\n * pair of leaves and each pair of pre-images are assumed to be sorted.\n */\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\n bytes32 computedHash = leaf;\n\n for (uint256 i = 0; i < proof.length; i++) {\n bytes32 proofElement = proof[i];\n\n if (computedHash <= proofElement) {\n // Hash(current computed hash + current element of the proof)\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\n } else {\n // Hash(current element of the proof + current computed hash)\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\n }\n }\n\n // Check if the computed hash (root) is equal to the provided root\n return computedHash == root;\n }\n}\n" + }, + "contracts/storage/app.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { TellerNFT } from \"../nft/TellerNFT.sol\";\n\n// Interfaces\n\n// Libraries\nimport {\n PlatformSetting\n} from \"../settings/platform/libraries/PlatformSettingsLib.sol\";\nimport { Cache } from \"../shared/libraries/CacheLib.sol\";\nimport {\n UpgradeableBeaconFactory\n} from \"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\";\n\nstruct AppStorage {\n // is it initialized\n bool initialized;\n // is it platform restricted\n bool platformRestricted;\n // mapping between contract IDs and if they're paused\n mapping(bytes32 => bool) paused;\n //p\n mapping(bytes32 => PlatformSetting) platformSettings;\n mapping(address => Cache) assetSettings;\n mapping(string => address) assetAddresses;\n mapping(address => bool) cTokenRegistry;\n TellerNFT nft;\n UpgradeableBeaconFactory loansEscrowBeacon;\n UpgradeableBeaconFactory collateralEscrowBeacon;\n address nftLiquidationController;\n UpgradeableBeaconFactory tTokenBeacon;\n}\n\nlibrary AppStorageLib {\n function store() internal pure returns (AppStorage storage s) {\n assembly {\n s.slot := 0\n }\n }\n}\n" + }, + "contracts/storage/nft.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../nft/TellerNFTDictionary.sol\";\n\n// Utils\nimport \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\nstruct NFTStorage {\n // Maps NFT owner to set of token IDs owned\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\n // Maps loanID to NFT IDs indicating NFT being used for the loan\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\n // Merkle root used for verifying nft IDs to base loan size\n TellerNFTDictionary nftDictionary;\n}\n\nbytes32 constant NFT_STORAGE_POS = keccak256(\"teller.staking.storage\");\n\nlibrary NFTStorageLib {\n function store() internal pure returns (NFTStorage storage s) {\n bytes32 pos = NFT_STORAGE_POS;\n assembly {\n s.slot := pos\n }\n }\n}\n" + }, + "contracts/settings/platform/libraries/PlatformSettingsLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AppStorageLib } from \"../../../storage/app.sol\";\nimport \"../names.sol\" as NAMES;\nimport {\n RolesMods\n} from \"../../../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN, AUTHORIZED } from \"../../../shared/roles.sol\";\nimport { RolesLib } from \"../../../contexts2/access-control/roles/RolesLib.sol\";\n\n// It defines a platform settings. It includes: value, min, and max values.\nstruct PlatformSetting {\n uint256 value;\n uint256 min;\n uint256 max;\n bool exists;\n}\n\n/**\n * @notice Utility library of inline functions on the PlatformSetting struct.\n *\n * @author develop@teller.finance\n */\nlibrary PlatformSettingsLib {\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\n return AppStorageLib.store().platformSettings[name];\n }\n\n /**\n * @notice It gets the current \"NFTInterestRate\" setting's value\n * @return value_ the current value.\n */\n function getNFTInterestRate() internal view returns (uint16 value_) {\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\n }\n\n /**\n * @notice It gets the current \"RequiredSubmissionsPercentage\" setting's value\n * @return value_ the current value.\n */\n function getRequiredSubmissionsPercentageValue()\n internal\n view\n returns (uint256 value_)\n {\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\n }\n\n /**\n * @notice It gets the current \"MaximumTolerance\" setting's value\n * @return value_ the current value.\n */\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\n }\n\n /**\n * @notice It gets the current \"ResponseExpiryLength\" setting's value\n * @return value_ the current value.\n */\n function getResponseExpiryLengthValue()\n internal\n view\n returns (uint256 value_)\n {\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\n }\n\n /**\n * @notice It gets the current \"SafetyInterval\" setting's value\n * @return value_ the current value.\n */\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\n value_ = s(NAMES.SAFETY_INTERVAL).value;\n }\n\n /**\n * @notice It gets the current \"TermsExpiryTime\" setting's value\n * @return value_ the current value.\n */\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\n }\n\n /**\n * @notice It gets the current \"LiquidateRewardPercent\" setting's value\n * @return value_ the current value.\n */\n function getLiquidateRewardPercent()\n internal\n view\n returns (uint256 value_)\n {\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\n }\n\n /**\n * @notice It gets the current \"MaximumLoanDuration\" setting's value\n * @return value_ the current value.\n */\n function getMaximumLoanDurationValue()\n internal\n view\n returns (uint256 value_)\n {\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\n }\n\n /**\n * @notice It gets the current \"RequestLoanTermsRateLimit\" setting's value\n * @return value_ the current value.\n */\n function getRequestLoanTermsRateLimitValue()\n internal\n view\n returns (uint256 value_)\n {\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\n }\n\n /**\n * @notice It gets the current \"CollateralBuffer\" setting's value\n * @return value_ the current value.\n */\n function getCollateralBufferValue() internal view returns (uint256 value_) {\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\n }\n\n /**\n * @notice It gets the current \"OverCollateralizedBuffer\" setting's value\n * @return value_ the current value.\n */\n function getOverCollateralizedBufferValue()\n internal\n view\n returns (uint256 value_)\n {\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\n }\n}\n" + }, + "contracts/shared/libraries/CacheLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nenum CacheType { Address, Uint, Int, Byte, Bool }\n\n/**\n * @notice This struct manages the cache of the library instance.\n * @param addresses A mapping of address values mapped to cache keys in bytes.\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\n * @param ints A mapping of int values mapped to cache keys names in bytes.\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\n */\nstruct Cache {\n // Mapping of cache keys names to address values.\n mapping(bytes32 => address) addresses;\n // Mapping of cache keys names to uint256 values.\n mapping(bytes32 => uint256) uints;\n // Mapping of cache keys names to int256 values.\n mapping(bytes32 => int256) ints;\n // Mapping of cache keys names to bytes32 values.\n mapping(bytes32 => bytes32) bites;\n // Mapping of cache keys names to bool values.\n mapping(bytes32 => bool) bools;\n}\n\nlibrary CacheLib {\n // The constant for the initialization check\n bytes32 private constant INITIALIZED = keccak256(\"Initialized\");\n\n /**\n * @notice Initializes the cache instance.\n * @param cache The current cache\n */\n function initialize(Cache storage cache) internal {\n requireNotExists(cache);\n cache.bools[INITIALIZED] = true;\n }\n\n /**\n * @notice Checks whether the current cache does not, throwing an error if it does.\n * @param cache The current cache\n */\n function requireNotExists(Cache storage cache) internal view {\n require(!exists(cache), \"CACHE_ALREADY_EXISTS\");\n }\n\n /**\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\n * @param cache The current cache\n */\n function requireExists(Cache storage cache) internal view {\n require(exists(cache), \"CACHE_DOES_NOT_EXIST\");\n }\n\n /**\n * @notice Tests whether the current cache exists or not.\n * @param cache The current cache.\n * @return bool True if the cache exists.\n */\n function exists(Cache storage cache) internal view returns (bool) {\n return cache.bools[INITIALIZED];\n }\n\n /**\n * @notice it updates the cache with a key, value and cache type\n * @param cache cache to update\n * @param key the memory reference to the value in bytes32\n * @param value the value to update at the key\n * @param cacheType the enum type of cache to update\n */\n function update(\n Cache storage cache,\n bytes32 key,\n bytes32 value,\n CacheType cacheType\n ) internal {\n requireExists(cache);\n\n assembly {\n mstore(0, value)\n }\n if (cacheType == CacheType.Address) {\n address addr;\n assembly {\n addr := mload(0)\n }\n cache.addresses[key] = addr;\n } else if (cacheType == CacheType.Uint) {\n uint256 ui;\n assembly {\n ui := mload(0)\n }\n cache.uints[key] = ui;\n } else if (cacheType == CacheType.Int) {\n int256 i;\n assembly {\n i := mload(0)\n }\n cache.ints[key] = i;\n } else if (cacheType == CacheType.Byte) {\n cache.bites[key] = value;\n } else if (cacheType == CacheType.Bool) {\n bool b;\n assembly {\n b := mload(0)\n }\n cache.bools[key] = b;\n }\n }\n\n /**\n * @notice it deletes the cache values at the specified key\n * @param cache the cache to delete keys from\n * @param keysToClear the keys to delete\n * @param keyTypes the types of keys to target different parts of the cache\n */\n function clearCache(\n Cache storage cache,\n bytes32[5] memory keysToClear,\n CacheType[5] memory keyTypes\n ) internal {\n requireExists(cache);\n require(\n keysToClear.length == keyTypes.length,\n \"ARRAY_LENGTHS_MISMATCH\"\n );\n for (uint256 i; i <= keysToClear.length; i++) {\n if (keyTypes[i] == CacheType.Address) {\n delete cache.addresses[keysToClear[i]];\n } else if (keyTypes[i] == CacheType.Uint) {\n delete cache.uints[keysToClear[i]];\n } else if (keyTypes[i] == CacheType.Int) {\n delete cache.ints[keysToClear[i]];\n } else if (keyTypes[i] == CacheType.Byte) {\n delete cache.bites[keysToClear[i]];\n } else if (keyTypes[i] == CacheType.Bool) {\n delete cache.bools[keysToClear[i]];\n }\n }\n }\n}\n" + }, + "contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/proxy/Clones.sol\";\nimport \"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\";\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\nimport \"@openzeppelin/contracts/utils/Address.sol\";\nimport \"./InitializeableBeaconProxy.sol\";\n\n/**\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\n * implementation contract, which is where they will delegate all function calls.\n *\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\n */\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\n address private _implementation;\n InitializeableBeaconProxy public proxyAddress;\n\n /**\n * @dev Emitted when the implementation returned by the beacon is changed.\n */\n event Upgraded(address indexed implementation);\n\n /**\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\n * beacon.\n */\n constructor(address payable proxyAddress_, address implementation_) {\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\n _setImplementation(implementation_);\n }\n\n /**\n * @dev Returns the current implementation address.\n */\n function implementation() public view virtual override returns (address) {\n return _implementation;\n }\n\n /**\n * @notice it clones the proxy contract at an address\n * @param initData the data to initialize after the proxy is cloned\n * @return proxy_ the cloned proxy\n */\n function cloneProxy(bytes memory initData)\n external\n returns (address payable proxy_)\n {\n proxy_ = payable(Clones.clone(address(proxyAddress)));\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\n }\n\n /**\n * @dev Upgrades the beacon to a new implementation.\n *\n * Emits an {Upgraded} event.\n *\n * Requirements:\n *\n * - msg.sender must be the owner of the contract.\n * - `newImplementation` must be a contract.\n */\n function upgradeTo(address newImplementation) public virtual onlyOwner {\n _setImplementation(newImplementation);\n emit Upgraded(newImplementation);\n }\n\n /**\n * @dev Sets the implementation contract address for this beacon\n *\n * Requirements:\n *\n * - `newImplementation` must be a contract.\n */\n function _setImplementation(address newImplementation) private {\n require(\n Address.isContract(newImplementation),\n \"UpgradeableBeacon: implementation is not a contract\"\n );\n _implementation = newImplementation;\n }\n}\n" + }, + "contracts/settings/platform/names.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/**\n @dev The setting name for loans taken out with an NFT.\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\n */\nbytes32 constant NFT_INTEREST_RATE = keccak256(\"NFTInterestRate\");\n\n/**\n @dev The setting name for the required subsmission settings.\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\n */\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\n \"RequiredSubmissionsPercentage\"\n);\n\n/**\n @dev The setting name for the maximum tolerance settings.\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\n @dev This is a percentage value with 2 decimal places.\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\n @dev The max value is 100% => 10000\n */\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\"MaximumTolerance\");\n/**\n @dev The setting name for the response expiry length settings.\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\n */\n\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\"ResponseExpiryLength\");\n\n/**\n @dev The setting name for the safety interval settings.\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\n */\nbytes32 constant SAFETY_INTERVAL = keccak256(\"SafetyInterval\");\n\n/**\n @dev The setting name for the term expiry time settings.\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\n */\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\"TermsExpiryTime\");\n\n/**\n @dev The setting name for the liquidation reward percent setting.\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\n i.e. an ETH liquidation price at 5% is stored as 500\n */\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\"LiquidateRewardPercent\");\n\n/**\n @dev The setting name for the maximum loan duration settings.\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\n */\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\"MaximumLoanDuration\");\n\n/**\n @dev The setting name for the request loan terms rate limit settings.\n @dev The request loan terms rate limit setting is defined in seconds.\n */\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\n \"RequestLoanTermsRateLimit\"\n);\n\n/**\n @dev The setting name for the collateral buffer.\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\n e.g.: collateral buffer at 100% is stored as 10000.\n */\nbytes32 constant COLLATERAL_BUFFER = keccak256(\"CollateralBuffer\");\n\n/**\n @dev The setting name for the over collateralized buffer.\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\n e.g.: over collateralized buffer at 130% is stored as 13000.\n */\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\n \"OverCollateralizedBuffer\"\n);\n" + }, + "@openzeppelin/contracts/proxy/Clones.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\n * deploying minimal proxy contracts, also known as \"clones\".\n *\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\n *\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\n * deterministic method.\n *\n * _Available since v3.4._\n */\nlibrary Clones {\n /**\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\n *\n * This function uses the create opcode, which should never revert.\n */\n function clone(address implementation) internal returns (address instance) {\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let ptr := mload(0x40)\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\n mstore(add(ptr, 0x14), shl(0x60, implementation))\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\n instance := create(0, ptr, 0x37)\n }\n require(instance != address(0), \"ERC1167: create failed\");\n }\n\n /**\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\n *\n * This function uses the create2 opcode and a `salt` to deterministically deploy\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\n * the clones cannot be deployed twice at the same address.\n */\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let ptr := mload(0x40)\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\n mstore(add(ptr, 0x14), shl(0x60, implementation))\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\n instance := create2(0, ptr, 0x37, salt)\n }\n require(instance != address(0), \"ERC1167: create2 failed\");\n }\n\n /**\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\n */\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let ptr := mload(0x40)\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\n mstore(add(ptr, 0x14), shl(0x60, implementation))\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\n mstore(add(ptr, 0x38), shl(0x60, deployer))\n mstore(add(ptr, 0x4c), salt)\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\n predicted := keccak256(add(ptr, 0x37), 0x55)\n }\n }\n\n /**\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\n */\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\n return predictDeterministicAddress(implementation, salt, address(this));\n }\n}\n" + }, + "@openzeppelin/contracts/proxy/beacon/IBeacon.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\n */\ninterface IBeacon {\n /**\n * @dev Must return an address that can be used as a delegate call target.\n *\n * {BeaconProxy} will check that this address is a contract.\n */\n function implementation() external view returns (address);\n}\n" + }, + "@openzeppelin/contracts/access/Ownable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n address private _owner;\n\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Initializes the contract setting the deployer as the initial owner.\n */\n constructor () {\n address msgSender = _msgSender();\n _owner = msgSender;\n emit OwnershipTransferred(address(0), msgSender);\n }\n\n /**\n * @dev Returns the address of the current owner.\n */\n function owner() public view virtual returns (address) {\n return _owner;\n }\n\n /**\n * @dev Throws if called by any account other than the owner.\n */\n modifier onlyOwner() {\n require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n _;\n }\n\n /**\n * @dev Leaves the contract without owner. It will not be possible to call\n * `onlyOwner` functions anymore. Can only be called by the current owner.\n *\n * NOTE: Renouncing ownership will leave the contract without an owner,\n * thereby removing any functionality that is only available to the owner.\n */\n function renounceOwnership() public virtual onlyOwner {\n emit OwnershipTransferred(_owner, address(0));\n _owner = address(0);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) public virtual onlyOwner {\n require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n emit OwnershipTransferred(_owner, newOwner);\n _owner = newOwner;\n }\n}\n" + }, + "@openzeppelin/contracts/utils/Address.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize, which returns 0 for contracts in\n // construction, since the code is only stored at the end of the\n // constructor execution.\n\n uint256 size;\n // solhint-disable-next-line no-inline-assembly\n assembly { size := extcodesize(account) }\n return size > 0;\n }\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\n (bool success, ) = recipient.call{ value: amount }(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain`call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCall(target, data, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n require(isContract(target), \"Address: call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\n return _verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\n require(isContract(target), \"Address: static call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.staticcall(data);\n return _verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\n require(isContract(target), \"Address: delegate call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return _verifyCallResult(success, returndata, errorMessage);\n }\n\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\n if (success) {\n return returndata;\n } else {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n }\n}\n" + }, + "contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\";\nimport \"@openzeppelin/contracts/proxy/Proxy.sol\";\nimport \"@openzeppelin/contracts/utils/Address.sol\";\n\n/**\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\n *\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\n * conflict with the storage layout of the implementation behind the proxy.\n *\n * _Available since v3.4._\n */\ncontract InitializeableBeaconProxy is Proxy {\n /**\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\n */\n bytes32 private constant _BEACON_SLOT =\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\n\n /**\n * @dev Initializes the proxy with `beacon`.\n *\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\n * constructor.\n *\n * Requirements:\n *\n * - `beacon` must be a contract with the interface {IBeacon}.\n */\n function initialize(address beacon, bytes memory data) external payable {\n assert(\n _BEACON_SLOT ==\n bytes32(uint256(keccak256(\"eip1967.proxy.beacon\")) - 1)\n );\n require(_beacon() == address(0), \"Beacon: already initialized\");\n\n _setBeacon(beacon, data);\n }\n\n /**\n * @dev Returns the current beacon address.\n */\n function _beacon() internal view virtual returns (address beacon) {\n bytes32 slot = _BEACON_SLOT;\n // solhint-disable-next-line no-inline-assembly\n assembly {\n beacon := sload(slot)\n }\n }\n\n /**\n * @dev Returns the current implementation address of the associated beacon.\n */\n function _implementation()\n internal\n view\n virtual\n override\n returns (address)\n {\n return IBeacon(_beacon()).implementation();\n }\n\n /**\n * @dev Changes the proxy to use a new beacon.\n *\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\n *\n * Requirements:\n *\n * - `beacon` must be a contract.\n * - The implementation returned by `beacon` must be a contract.\n */\n function _setBeacon(address beacon, bytes memory data) internal virtual {\n bytes32 slot = _BEACON_SLOT;\n\n // solhint-disable-next-line no-inline-assembly\n assembly {\n sstore(slot, beacon)\n }\n\n if (data.length > 0) {\n Address.functionDelegateCall(\n _implementation(),\n data,\n \"BeaconProxy: function call failed\"\n );\n }\n }\n\n receive() external payable override {\n // Needed to receive ETH without data\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\n }\n}\n" + }, + "@openzeppelin/contracts/utils/Context.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/*\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\n return msg.data;\n }\n}\n" + }, + "@openzeppelin/contracts/proxy/Proxy.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\n * be specified by overriding the virtual {_implementation} function.\n *\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\n * different contract through the {_delegate} function.\n *\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\n */\nabstract contract Proxy {\n /**\n * @dev Delegates the current call to `implementation`.\n *\n * This function does not return to its internall call site, it will return directly to the external caller.\n */\n function _delegate(address implementation) internal virtual {\n // solhint-disable-next-line no-inline-assembly\n assembly {\n // Copy msg.data. We take full control of memory in this inline assembly\n // block because it will not return to Solidity code. We overwrite the\n // Solidity scratch pad at memory position 0.\n calldatacopy(0, 0, calldatasize())\n\n // Call the implementation.\n // out and outsize are 0 because we don't know the size yet.\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\n\n // Copy the returned data.\n returndatacopy(0, 0, returndatasize())\n\n switch result\n // delegatecall returns 0 on error.\n case 0 { revert(0, returndatasize()) }\n default { return(0, returndatasize()) }\n }\n }\n\n /**\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\n * and {_fallback} should delegate.\n */\n function _implementation() internal view virtual returns (address);\n\n /**\n * @dev Delegates the current call to the address returned by `_implementation()`.\n *\n * This function does not return to its internall call site, it will return directly to the external caller.\n */\n function _fallback() internal virtual {\n _beforeFallback();\n _delegate(_implementation());\n }\n\n /**\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\n * function in the contract matches the call data.\n */\n fallback () external payable virtual {\n _fallback();\n }\n\n /**\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\n * is empty.\n */\n receive () external payable virtual {\n _fallback();\n }\n\n /**\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\n * call, or as part of the Solidity `fallback` or `receive` functions.\n *\n * If overriden should call `super._beforeFallback()`.\n */\n function _beforeFallback() internal virtual {\n }\n}\n" + }, + "contracts/shared/interfaces/ITellerDiamond.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { IDiamondCut } from \"./IDiamondCut.sol\";\nimport { IDiamondLoupe } from \"./IDiamondLoupe.sol\";\n\nimport { SettingsFacet } from \"../../settings/SettingsFacet.sol\";\nimport {\n PlatformSettingsFacet\n} from \"../../settings/platform/PlatformSettingsFacet.sol\";\nimport {\n AssetSettingsDataFacet\n} from \"../../settings/asset/AssetSettingsDataFacet.sol\";\nimport {\n AssetSettingsFacet\n} from \"../../settings/asset/AssetSettingsFacet.sol\";\nimport { PausableFacet } from \"../../settings/pausable/PausableFacet.sol\";\nimport { PriceAggFacet } from \"../../price-aggregator/PriceAggFacet.sol\";\nimport {\n ChainlinkAggFacet\n} from \"../../price-aggregator/chainlink/ChainlinkAggFacet.sol\";\nimport { LendingFacet } from \"../../lending/LendingFacet.sol\";\nimport { CreateLoanFacet } from \"../../market/CreateLoanFacet.sol\";\nimport { LoanDataFacet } from \"../../market/LoanDataFacet.sol\";\nimport { RepayFacet } from \"../../market/RepayFacet.sol\";\nimport { SignersFacet } from \"../../market/SignersFacet.sol\";\nimport { NFTFacet } from \"../../nft/NFTFacet.sol\";\nimport { CollateralFacet } from \"../../market/CollateralFacet.sol\";\nimport { CompoundFacet } from \"../../escrow/dapps/CompoundFacet.sol\";\nimport { UniswapFacet } from \"../../escrow/dapps/UniswapFacet.sol\";\n\nabstract contract ITellerDiamond is\n SettingsFacet,\n PlatformSettingsFacet,\n AssetSettingsDataFacet,\n AssetSettingsFacet,\n PausableFacet,\n PriceAggFacet,\n ChainlinkAggFacet,\n LendingFacet,\n CollateralFacet,\n CreateLoanFacet,\n LoanDataFacet,\n RepayFacet,\n SignersFacet,\n NFTFacet,\n CompoundFacet,\n UniswapFacet,\n IDiamondCut,\n IDiamondLoupe\n{}\n" + }, + "contracts/shared/interfaces/IDiamondCut.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/******************************************************************************\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\n/******************************************************************************/\n\ninterface IDiamondCut {\n enum FacetCutAction { Add, Replace, Remove }\n\n struct FacetCut {\n address facetAddress;\n FacetCutAction action;\n bytes4[] functionSelectors;\n }\n\n /// @notice Add/replace/remove any number of functions and optionally execute\n /// a function with delegatecall\n /// @param _diamondCut Contains the facet addresses and function selectors\n /// @param _init The address of the contract or facet to execute _calldata\n /// @param _calldata A function call, including function selector and arguments\n /// _calldata is executed with delegatecall on _init\n function diamondCut(\n FacetCut[] calldata _diamondCut,\n address _init,\n bytes calldata _calldata\n ) external;\n\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\n}\n" + }, + "contracts/shared/interfaces/IDiamondLoupe.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// A loupe is a small magnifying glass used to look at diamonds.\n// These functions look at diamonds\ninterface IDiamondLoupe {\n /// These functions are expected to be called frequently\n /// by tools.\n\n struct Facet {\n address facetAddress;\n bytes4[] functionSelectors;\n }\n\n /// @notice Gets all facet addresses and their four byte function selectors.\n /// @return facets_ Facet\n function facets() external view returns (Facet[] memory facets_);\n\n /// @notice Gets all the function selectors supported by a specific facet.\n /// @param _facet The facet address.\n /// @return facetFunctionSelectors_\n function facetFunctionSelectors(address _facet)\n external\n view\n returns (bytes4[] memory facetFunctionSelectors_);\n\n /// @notice Get all the facet addresses used by a diamond.\n /// @return facetAddresses_\n function facetAddresses()\n external\n view\n returns (address[] memory facetAddresses_);\n\n /// @notice Gets the facet that supports the given selector.\n /// @dev If facet is not found return address(0).\n /// @param _functionSelector The function selector.\n /// @return facetAddress_ The facet address.\n function facetAddress(bytes4 _functionSelector)\n external\n view\n returns (address facetAddress_);\n}\n" + }, + "contracts/settings/SettingsFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN, PAUSER, AUTHORIZED } from \"../shared/roles.sol\";\nimport {\n UpgradeableBeaconFactory\n} from \"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\";\nimport { TellerNFT } from \"../nft/TellerNFT.sol\";\n\n// Interfaces\nimport { IUniswapV2Router } from \"../shared/interfaces/IUniswapV2Router.sol\";\n\n// Libraries\nimport { RolesLib } from \"../contexts2/access-control/roles/RolesLib.sol\";\n\n// Storage\nimport { AppStorageLib, AppStorage } from \"../storage/app.sol\";\n\nstruct InitAssets {\n string sym;\n address addr;\n}\n\nstruct InitArgs {\n address admin;\n InitAssets[] assets;\n address[] cTokens;\n address tellerNFT;\n address loansEscrowBeacon;\n address collateralEscrowBeacon;\n address tTokenBeacon;\n address nftLiquidationController;\n}\n\ncontract SettingsFacet is RolesMods {\n /**\n * @notice This event is emitted when the platform restriction is switched\n * @param restriction Boolean representing the state of the restriction\n * @param pauser address of the pauser flipping the switch\n */\n event PlatformRestricted(bool restriction, address indexed pauser);\n\n /**\n * @notice Restricts the use of the Teller protocol to authorized wallet addresses only\n * @param restriction Bool turning the resitriction on or off\n */\n function restrictPlatform(bool restriction)\n internal\n authorized(ADMIN, msg.sender)\n {\n AppStorageLib.store().platformRestricted = restriction;\n emit PlatformRestricted(restriction, msg.sender);\n }\n\n /**\n * @notice Adds a wallet address to the list of authorized wallets\n * @param account The wallet address of the user being authorized\n */\n function addAuthorizedAddress(address account)\n external\n authorized(ADMIN, msg.sender)\n {\n RolesLib.grantRole(AUTHORIZED, account);\n }\n\n /**\n * @notice Adds a list of wallet addresses to the list of authorized wallets\n * @param addressesToAdd The list of wallet addresses being authorized\n */\n function addAuthorizedAddressList(address[] calldata addressesToAdd)\n external\n authorized(ADMIN, msg.sender)\n {\n for (uint256 i; i < addressesToAdd.length; i++) {\n RolesLib.grantRole(AUTHORIZED, addressesToAdd[i]);\n }\n }\n\n /**\n * @notice Removes a wallet address from the list of authorized wallets\n * @param account The wallet address of the user being unauthorized\n */\n function removeAuthorizedAddress(address account)\n external\n authorized(ADMIN, msg.sender)\n {\n RolesLib.revokeRole(AUTHORIZED, account);\n }\n\n /**\n * @notice Tests whether an account has authorization\n * @param account The account address to check for\n * @return True if account has authorization, false if it does not\n */\n function hasAuthorization(address account) external view returns (bool) {\n return RolesLib.hasRole(AUTHORIZED, account);\n }\n\n /**\n * @notice Sets a new address to which NFTs should be sent when used for taking out a loan and gets liquidated.\n * @param newController The address where NFTs should be transferred.\n */\n function setNFTLiquidationController(address newController)\n external\n authorized(ADMIN, msg.sender)\n {\n AppStorageLib.store().nftLiquidationController = newController;\n }\n\n /**\n * @notice Gets the new address where NFTs are sent when used for taking out a loan and gets liquidated.\n * @return controller_ The address where NFTs are be transferred.\n */\n function getNFTLiquidationController()\n external\n returns (address controller_)\n {\n controller_ = AppStorageLib.store().nftLiquidationController;\n }\n\n /**\n * @notice it stores multiple parameters in the AppStorageLib\n * @param _args multiple arguments that are stored in the AppStorageLibrary\n */\n function init(InitArgs calldata _args) external {\n AppStorage storage s = AppStorageLib.store();\n\n if (s.initialized) return;\n s.initialized = true;\n\n RolesLib.grantRole(ADMIN, _args.admin);\n RolesLib.grantRole(PAUSER, _args.admin);\n\n for (uint256 i; i < _args.assets.length; i++) {\n s.assetAddresses[_args.assets[i].sym] = _args.assets[i].addr;\n }\n for (uint256 i; i < _args.cTokens.length; i++) {\n s.cTokenRegistry[_args.cTokens[i]] = true;\n }\n\n s.nft = TellerNFT(_args.tellerNFT);\n s.loansEscrowBeacon = UpgradeableBeaconFactory(_args.loansEscrowBeacon);\n s.collateralEscrowBeacon = UpgradeableBeaconFactory(\n _args.collateralEscrowBeacon\n );\n s.tTokenBeacon = UpgradeableBeaconFactory(_args.tTokenBeacon);\n s.nftLiquidationController = _args.nftLiquidationController;\n }\n}\n" + }, + "contracts/settings/platform/PlatformSettingsFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN, AUTHORIZED } from \"../../shared/roles.sol\";\n\n// Libraries\nimport {\n PlatformSettingsLib,\n PlatformSetting\n} from \"./libraries/PlatformSettingsLib.sol\";\nimport { AppStorageLib } from \"../../storage/app.sol\";\n\n// Storage\nimport { AppStorageLib, AppStorage } from \"../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions on the PlatformSetting struct.\n *\n * @author develop@teller.finance\n */\ncontract PlatformSettingsFacet is RolesMods {\n /**\n * @notice This event is emitted when a new platform setting is created.\n * @param settingName New setting name.\n * @param sender Address that created it.\n * @param value Value for the new setting.\n * @param minValue Minimum boundary for the new setting.\n * @param maxValue Maximum boundary for the new setting.\n */\n event PlatformSettingCreated(\n bytes32 indexed settingName,\n address indexed sender,\n uint256 value,\n uint256 minValue,\n uint256 maxValue\n );\n\n /**\n * @notice This event is emitted when a platform setting is updated.\n * @param settingName Keccak'ed settings name.\n * @param sender Address that updated it.\n * @param oldValue Previous value for the setting.\n * @param newValue New value for the setting.\n */\n event PlatformSettingUpdated(\n bytes32 indexed settingName,\n address indexed sender,\n uint256 oldValue,\n uint256 newValue\n );\n\n /**\n * @notice This event is emitted when a current platform setting is removed.\n * @param settingName setting name removed.\n * @param sender address that removed it.\n * @param oldMin Previous minimum boundary.\n * @param oldMax Previous minimum boundary.\n * @param newMin New minimum boundary.\n * @param newMax New maximum boundary.\n */\n event PlatformSettingBoundariesUpdated(\n bytes32 indexed settingName,\n address indexed sender,\n uint256 oldMin,\n uint256 oldMax,\n uint256 newMin,\n uint256 newMax\n );\n\n /**\n * @notice Gets the values for a platform setting name.\n * @param name The keccak'ed name for a setting.\n * @return setting_ Values for the setting {name}\n */\n function getPlatformSetting(bytes32 name)\n external\n view\n returns (PlatformSetting memory setting_)\n {\n setting_ = PlatformSettingsLib.s(name);\n }\n\n /**\n * @notice It creates a new platform setting given a name, min and max values.\n * @param name Keccak'ed name for the setting.\n * @param value Initial value for the setting.\n * @param min Minimum value allowed for the setting.\n * @param max Maximum value allowed for the setting.\n */\n function createPlatformSetting(\n bytes32 name,\n uint256 value,\n uint256 min,\n uint256 max\n ) external authorized(ADMIN, msg.sender) {\n require(\n !PlatformSettingsLib.s(name).exists,\n \"Teller: platform setting already exists\"\n );\n require(value >= min, \"Teller: platform setting value less than min\");\n require(\n value <= max,\n \"Teller: platform setting value greater than max\"\n );\n\n PlatformSettingsLib.s(name).value = value;\n PlatformSettingsLib.s(name).min = min;\n PlatformSettingsLib.s(name).max = max;\n PlatformSettingsLib.s(name).exists = true;\n\n emit PlatformSettingCreated(name, msg.sender, value, min, max);\n }\n\n /**\n * @notice It updates a current platform setting.\n * @param name Keccak'ed name for the setting.\n * @param newValue the new value to set in the platform setting.\n *\n * Requirements:\n * - New value is equal to the current value.\n * - New value is grater than the max value.\n * - New value is less than the min value\n */\n function updatePlatformSetting(bytes32 name, uint256 newValue)\n external\n authorized(ADMIN, msg.sender)\n returns (uint256 oldValue)\n {\n require(\n PlatformSettingsLib.s(name).exists,\n \"Teller: platform setting not exists\"\n );\n require(\n PlatformSettingsLib.s(name).value != newValue,\n \"Teller: new platform setting not different\"\n );\n require(\n newValue >= PlatformSettingsLib.s(name).min,\n \"Teller: new platform setting less than min\"\n );\n require(\n newValue <= PlatformSettingsLib.s(name).max,\n \"Teller: new platform setting greater than max\"\n );\n\n oldValue = PlatformSettingsLib.s(name).value;\n PlatformSettingsLib.s(name).value = newValue;\n\n emit PlatformSettingUpdated(name, msg.sender, oldValue, newValue);\n }\n\n /**\n * @notice Updates the boundary (min & max) values for a platform setting.\n * @param name Keccak'ed name for the setting.\n * @param min New minimum boundary for the setting.\n * @param max New maximum boundary for the setting.\n */\n function updatePlatformSettingBoundaries(\n bytes32 name,\n uint256 min,\n uint256 max\n ) external authorized(ADMIN, msg.sender) {\n require(\n PlatformSettingsLib.s(name).exists,\n \"Teller: platform setting not exists\"\n );\n\n emit PlatformSettingBoundariesUpdated(\n name,\n msg.sender,\n PlatformSettingsLib.s(name).min,\n PlatformSettingsLib.s(name).max,\n min,\n max\n );\n\n PlatformSettingsLib.s(name).min = min;\n PlatformSettingsLib.s(name).max = max;\n }\n}\n" + }, + "contracts/settings/asset/AssetSettingsDataFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN, AUTHORIZED } from \"../../shared/roles.sol\";\n\n// Interfaces\nimport { ICErc20 } from \"../../shared/interfaces/ICErc20.sol\";\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../shared/libraries/CacheLib.sol\";\nimport { AssetCTokenLib } from \"./libraries/AssetCTokenLib.sol\";\nimport { MaxLoanAmountLib } from \"./libraries/MaxLoanAmountLib.sol\";\nimport { MaxTVLLib } from \"./libraries/MaxTVLLib.sol\";\n\n// Storage\nimport { AppStorageLib, AppStorage } from \"../../storage/app.sol\";\n\n/**\n * @notice View function to get asset setting values.\n *\n * @author develop@teller.finance\n */\ncontract AssetSettingsDataFacet {\n /**\n * @notice it gets the asset's max loan amount\n * @param asset the address of the asset\n * @return the max loan amount\n */\n function getAssetMaxLoanAmount(address asset)\n external\n view\n returns (uint256)\n {\n return MaxLoanAmountLib.get(asset);\n }\n\n /**\n * @notice it gets the maxTVL of an asset\n * @param asset the address of the asset\n * @return it returns the maxTVL\n */\n function getAssetMaxTVL(address asset) external view returns (uint256) {\n return MaxTVLLib.get(asset);\n }\n\n /**\n * @notice it returns the asset's cToken\n * @param asset the address of the asset\n * @return the cToken of an asset\n */\n function getAssetCToken(address asset) external view returns (ICErc20) {\n return AssetCTokenLib.get(asset);\n }\n}\n" + }, + "contracts/settings/asset/AssetSettingsFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN, AUTHORIZED } from \"../../shared/roles.sol\";\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../shared/libraries/CacheLib.sol\";\nimport { MaxTVLLib } from \"./libraries/MaxTVLLib.sol\";\n\n// Storage\nimport { AppStorageLib, AppStorage } from \"../../storage/app.sol\";\n\nstruct AssetSettingRequest {\n bytes32 key;\n bytes32 value;\n CacheType cacheType;\n}\n\ncontract AssetSettingsFacet is RolesMods {\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n event AssetSettingsCreated(\n address indexed asset,\n bytes32 indexed key,\n bytes32 value,\n CacheType cacheType\n );\n\n event AssetSettingsUpdated(\n address indexed asset,\n bytes32 indexed key,\n bytes32 value,\n CacheType cacheType\n );\n\n /**\n * @notice it checks if the settings of an asset is initialized\n * @param asset the address of the asset\n * @return bool to check if settings of an asset exists\n */\n function isAssetSettingInitialized(address asset)\n external\n view\n returns (bool)\n {\n return CacheLib.exists(s(asset));\n }\n\n /**\n * @notice it gets the MaxTVL amount of an asset\n * @param asset the address of the asset\n * @return the max TVL amount\n */\n function getMaxTVLAmount(address asset) external view returns (uint256) {\n return MaxTVLLib.get(asset);\n }\n\n /**\n * @notice It creates an asset settings with the given parameters.\n * @param asset the address to create settings for\n * @param requests the multiple settings to update the asset with \n */\n function createAssetSetting(\n address asset,\n AssetSettingRequest[] calldata requests\n ) external authorized(ADMIN, msg.sender) {\n require(asset != address(0), \"Teller: asset address required\");\n\n CacheLib.initialize(s(asset));\n\n for (uint256 i; i < requests.length; i++) {\n CacheLib.update(\n s(asset),\n requests[i].key,\n requests[i].value,\n requests[i].cacheType\n );\n\n emit AssetSettingsCreated(\n asset,\n requests[i].key,\n requests[i].value,\n requests[i].cacheType\n );\n }\n }\n\n /**\n * @notice It updates an asset with the given parameter\n * @param asset the address of the asset to update\n * @param request the setting to update the asset with\n */\n function updateAssetSetting(\n address asset,\n AssetSettingRequest calldata request\n ) external authorized(ADMIN, msg.sender) {\n require(\n CacheLib.exists(s(asset)),\n \"Teller: asset setting does not exists\"\n );\n\n CacheLib.update(\n s(asset),\n request.key,\n request.value,\n request.cacheType\n );\n\n emit AssetSettingsUpdated(\n asset,\n request.key,\n request.value,\n request.cacheType\n );\n }\n}\n" + }, + "contracts/settings/pausable/PausableFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../../contexts2/access-control/roles/RolesMods.sol\";\nimport { PAUSER } from \"../../shared/roles.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../storage/app.sol\";\n\ncontract PausableFacet is RolesMods {\n /**\n * @dev Emitted when an {id} is paused by {sender}.\n */\n event Paused(bytes32 indexed id, address sender);\n\n /**\n * @dev Emitted when an {id} is unpaused by {sender}.\n */\n event UnPaused(bytes32 indexed id, address sender);\n\n /**\n * @notice Puts an id in the given state.\n * @dev A blank id (\"\") is equivalent to the whole protocol. If a specific facet should be paused, pass its encoded id.\n * @param id Encoded id of a facet to {pause}.\n * @param state The new state that {id} should be in.\n *\n * Requirements:\n * - Sender must have the PAUSER role.\n */\n function pause(bytes32 id, bool state)\n external\n authorized(PAUSER, msg.sender)\n {\n if (isPaused(id) == state) return;\n AppStorageLib.store().paused[id] = state;\n if (state) {\n emit Paused(id, msg.sender);\n } else {\n emit UnPaused(id, msg.sender);\n }\n }\n\n /**\n * @notice Checks if an id is paused.\n * @dev A blank id (\"\") is equivalent to the whole protocol. If a specific facet should be paused, pass its encoded id.\n * @param id Encoded id of a facet to {pause}.\n * @return The state that {id} is in.\n */\n function isPaused(bytes32 id) public view returns (bool) {\n return AppStorageLib.store().paused[id];\n }\n}\n" + }, + "contracts/price-aggregator/PriceAggFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport { SafeCast } from \"@openzeppelin/contracts/utils/math/SafeCast.sol\";\nimport { ChainlinkLib } from \"./chainlink/ChainlinkLib.sol\";\nimport { CompoundLib } from \"../shared/libraries/CompoundLib.sol\";\n\n// Interfaces\nimport {\n AggregatorV2V3Interface\n} from \"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\";\nimport { ERC20 } from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../storage/app.sol\";\n\ncontract PriceAggFacet {\n uint256 internal constant TEN = 10;\n\n /**\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\n * @param src Source token address.\n * @param dst Destination token address.\n * @return int256 The latest answer as given from Chainlink.\n */\n function getPriceFor(address src, address dst)\n external\n view\n returns (int256)\n {\n return _priceFor(src, dst);\n }\n\n /**\n * @notice It calculates the value of a token amount into another.\n * @param src Source token address.\n * @param dst Destination token address.\n * @param srcAmount Amount of the source token to convert into the destination token.\n * @return uint256 Value of the source token amount in destination tokens.\n */\n function getValueFor(\n address src,\n address dst,\n uint256 srcAmount\n ) external view returns (uint256) {\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\n }\n\n function _valueFor(\n address src,\n uint256 amount,\n uint256 exchangeRate\n ) internal view returns (uint256) {\n return (amount * exchangeRate) / _oneToken(src);\n }\n\n /**\n * @notice it returns 10^{numberOfDecimals} for a token\n * @param token the address to calculate the decimals for\n * @return 10^number of decimals used to calculate the price and value of different token pairs\n */\n function _oneToken(address token) internal view returns (uint256) {\n return TEN**_decimalsFor(token);\n }\n\n /**\n * @notice It gets the number of decimals for a given token.\n * @param addr Token address to get decimals for.\n * @return uint8 Number of decimals the given token.\n */\n function _decimalsFor(address addr) internal view returns (uint8) {\n return ERC20(addr).decimals();\n }\n\n /**\n * @notice it tries to calculate a price from Compound and Chainlink.\n * @dev if no price is found on compound, then calculate it on chainlink\n * @param src the token address to calculate the price for in dst\n * @param dst the token address to retrieve the price of src\n * @return price_ the price of src in dst\n */\n function _priceFor(address src, address dst)\n private\n view\n returns (int256 price_)\n {\n // If no Compound route, try Chainlink directly.\n price_ = int256(_compoundPriceFor(src, dst));\n if (price_ == 0) {\n price_ = _chainlinkPriceFor(src, dst);\n if (price_ == 0) {\n revert(\"Teller: cannot calc price\");\n }\n }\n }\n\n /**\n * @notice Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\n * @param src the address of the src token\n * @param dst the address of the dst token\n * @return the price of the src token in dst token\n\n */\n function _compoundPriceFor(address src, address dst)\n private\n view\n returns (uint256)\n {\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\n if (isSrcCompound) {\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\n if (srcUnderlying == dst) {\n return cRate;\n } else {\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\n }\n } else {\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\n if (isDstCompound) {\n uint256 cRate =\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\n if (dstUnderlying == src) {\n return cRate;\n } else {\n return\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\n }\n }\n }\n\n return 0;\n }\n\n /**\n * @notice Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\n * @param src the source token to calculate price for with chainlink\n * @param dst the destination token to calculate price for with chainlink\n * @param cRate the compound rate to multiply with the price of the dst token\n * @return the price of src in dst after scaling the difference in decimal values\n */\n function _calcPriceFromCompoundRate(\n address src,\n address dst,\n uint256 cRate\n ) private view returns (uint256) {\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\n uint256 value = (cRate * _oneToken(dst)) / rate;\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\n }\n\n /**\n * @notice Scales the {value} by the difference in decimal values.\n * @param value the the value of the src in dst\n * @param srcDecimals src token decimals\n * @param dstDecimals dst token decimals\n * @return the price of src in dst after scaling the difference in decimal values\n */\n function _scale(\n uint256 value,\n uint256 srcDecimals,\n uint256 dstDecimals\n ) internal pure returns (uint256) {\n if (dstDecimals > srcDecimals) {\n return value * (TEN**(dstDecimals - srcDecimals));\n } else {\n return value / (TEN**(srcDecimals - dstDecimals));\n }\n }\n\n /**\n * @notice it tries to calculate the price of {src} in {dst}\n * @param src address of source token\n * @param dst address of destination token\n * @return the price of src token in dst\n */\n function _chainlinkPriceFor(address src, address dst)\n private\n view\n returns (int256)\n {\n (address agg, bool foundAgg, bool inverse) =\n ChainlinkLib.aggregatorFor(src, dst);\n if (foundAgg) {\n uint256 price =\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\n if (inverse) {\n price = (TEN**(resDecimals + resDecimals)) / price;\n }\n return\n SafeCast.toInt256(\n (_scale(price, resDecimals, _decimalsFor(dst)))\n );\n } else {\n address WETH = AppStorageLib.store().assetAddresses[\"WETH\"];\n if (dst != WETH) {\n int256 price1 = _priceFor(src, WETH);\n if (price1 > 0) {\n int256 price2 = _priceFor(dst, WETH);\n if (price2 > 0) {\n uint256 dstFactor = TEN**_decimalsFor(dst);\n return (price1 * int256(dstFactor)) / price2;\n }\n }\n }\n }\n\n return 0;\n }\n\n /**\n * @notice it checks if a token is a cToken. If it is, then get the underlying address\n * @param token address of the token\n * @return isCToken boolean whether it's a cToken\n * @return underlying the address of the cToken\n */\n function _isCToken(address token)\n private\n view\n returns (bool isCToken, address underlying)\n {\n isCToken = CompoundLib.isCompoundToken(token);\n if (isCToken) {\n underlying = CompoundLib.getUnderlying(token);\n }\n }\n}\n" + }, + "contracts/price-aggregator/chainlink/ChainlinkAggFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN } from \"../../shared/roles.sol\";\n\n// Libraries\nimport { Address } from \"@openzeppelin/contracts/utils/Address.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\nimport { ChainlinkLib } from \"./ChainlinkLib.sol\";\n\n// Storage\nimport {\n PriceAggStorageLib,\n PriceAggStorage\n} from \"../../storage/price-aggregator.sol\";\n\ncontract ChainlinkAggFacet is RolesMods {\n /**\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\n * @param src Source token address.\n * @param dst Destination token address.\n * @return agg The Chainlink Aggregator address.\n * @return found whether or not the ChainlinkAggregator exists.\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\n */\n function getChainlinkAggregatorFor(address src, address dst)\n external\n view\n returns (\n address agg,\n bool found,\n bool inverse\n )\n {\n (agg, found, inverse) = ChainlinkLib.aggregatorFor(src, dst);\n }\n\n /**\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\n * @param token Token address to check if is supported.\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\n */\n function isChainlinkTokenSupported(address token)\n external\n view\n returns (bool)\n {\n return ChainlinkLib.isTokenSupported(token);\n }\n\n /**\n * @notice It allows for additional Chainlink Aggregators to be supported.\n * @param src Source token address.\n * @param dst Destination token address.\n * @param aggregator Price aggregator address.\n */\n function addChainlinkAggregator(\n address src,\n address dst,\n address aggregator\n ) external authorized(ADMIN, msg.sender) {\n (, bool found, ) = ChainlinkLib.aggregatorFor(src, dst);\n require(!found, \"Teller: chainlink aggregator already exists\");\n require(Address.isContract(src), \"Teller: source token not contract\");\n require(\n Address.isContract(dst),\n \"Teller: destination token not contract\"\n );\n require(\n Address.isContract(aggregator),\n \"Teller: chainlink aggregator not contract\"\n );\n\n // Store now aggregator\n ChainlinkLib.s().aggregators[src][dst] = aggregator;\n // Make sure token addresses are known to be supported\n EnumerableSet.add(ChainlinkLib.s().supportedTokens, src);\n EnumerableSet.add(ChainlinkLib.s().supportedTokens, dst);\n // Increment token pair counts\n ChainlinkLib.s().pairCount[src]++;\n ChainlinkLib.s().pairCount[dst]++;\n }\n\n /**\n * @notice It removes support for a Chainlink Aggregator pair.\n * @param src Source token address.\n * @param dst Destination token address.\n */\n function removeChainlinkAggregator(address src, address dst)\n external\n authorized(ADMIN, msg.sender)\n {\n (, bool found, ) = ChainlinkLib.aggregatorFor(src, dst);\n if (!found) {\n return;\n }\n\n // Delete aggregator storage\n delete ChainlinkLib.s().aggregators[src][dst];\n // Decrement token pair counts\n ChainlinkLib.s().pairCount[src]--;\n ChainlinkLib.s().pairCount[dst]--;\n // Remove token support if token pair length is 0\n if (ChainlinkLib.s().pairCount[src] == 0) {\n EnumerableSet.remove(ChainlinkLib.s().supportedTokens, src);\n }\n if (ChainlinkLib.s().pairCount[dst] == 0) {\n EnumerableSet.remove(ChainlinkLib.s().supportedTokens, dst);\n }\n }\n}\n" + }, + "contracts/lending/LendingFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { PausableMods } from \"../settings/pausable/PausableMods.sol\";\nimport {\n ReentryMods\n} from \"../contexts2/access-control/reentry/ReentryMods.sol\";\nimport { RolesMods } from \"../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN, AUTHORIZED } from \"../shared/roles.sol\";\n\n// Interfaces\nimport { ITToken } from \"./ttoken/ITToken.sol\";\n\n// Libraries\nimport {\n IERC20,\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport {\n SafeERC20Upgradeable\n} from \"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\";\nimport { MaxTVLLib } from \"../settings/asset/libraries/MaxTVLLib.sol\";\nimport { LendingLib } from \"./libraries/LendingLib.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../storage/app.sol\";\n\ncontract LendingFacet is RolesMods, ReentryMods, PausableMods {\n /**\n * @notice This event is emitted when a new lending pool is initialized.\n * @param sender address.\n * @param asset Token address the pool was initialized for.\n */\n event LendingPoolInitialized(address indexed sender, address asset);\n\n /**\n * @notice Get the Teller Token address for an underlying asset.\n * @param asset Address to get a Teller Token for.\n */\n function getTTokenFor(address asset)\n external\n view\n returns (address tToken_)\n {\n tToken_ = address(LendingLib.tToken(asset));\n }\n\n /**\n * @notice It allows users to deposit tokens into the pool.\n * @dev the user must call ERC20.approve function previously.\n * @dev If the cToken is available (not 0x0), it deposits the lending asset amount into Compound directly.\n * @param asset Token address to deposit into the lending pool.\n * @param amount Amount of {asset} to deposit in the pool.\n */\n function lendingPoolDeposit(address asset, uint256 amount)\n external\n paused(LendingLib.ID, false)\n authorized(AUTHORIZED, msg.sender)\n nonReentry(LendingLib.ID)\n {\n ITToken tToken = LendingLib.tToken(asset);\n require(\n address(tToken) != address(0),\n \"Teller: lending pool not initialized\"\n );\n\n require(\n tToken.currentTVL() + amount <= MaxTVLLib.get(asset),\n \"Teller: deposit TVL exceeded\"\n );\n\n // Transfer tokens from lender\n SafeERC20.safeTransferFrom(\n IERC20(asset),\n msg.sender,\n address(this),\n amount\n );\n // Set allowance for Teller token to pull funds to mint\n SafeERC20.safeIncreaseAllowance(IERC20(asset), address(tToken), amount);\n // Mint Teller tokens, then transfer to lender\n SafeERC20Upgradeable.safeTransfer(\n tToken,\n msg.sender,\n // Minting returns the amount of Teller tokens minted\n tToken.mint(amount)\n );\n }\n\n /**\n * @notice It initializes a new lending pool for the respective token\n * @param asset Token address to initialize the lending pool for.\n */\n function initLendingPool(address asset)\n external\n authorized(ADMIN, msg.sender)\n {\n require(\n address(LendingLib.tToken(asset)) == address(0),\n \"Teller: lending pool already initialized\"\n );\n\n // Create a new Teller Token\n address tToken = AppStorageLib.store().tTokenBeacon.cloneProxy(\"\");\n // Set the Teller Token to the asset mapping\n LendingLib.s().tTokens[asset] = ITToken(tToken);\n // Initialize the Teller Token\n LendingLib.s().tTokens[asset].initialize(msg.sender, asset);\n\n // Emit event\n emit LendingPoolInitialized(msg.sender, asset);\n }\n}\n" + }, + "contracts/market/CreateLoanFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { PausableMods } from \"../settings/pausable/PausableMods.sol\";\nimport {\n ReentryMods\n} from \"../contexts2/access-control/reentry/ReentryMods.sol\";\nimport { RolesMods } from \"../contexts2/access-control/roles/RolesMods.sol\";\nimport { AUTHORIZED } from \"../shared/roles.sol\";\nimport { ERC20 } from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\n\n// Libraries\nimport { LibLoans } from \"./libraries/LibLoans.sol\";\nimport { LibCollateral } from \"./libraries/LibCollateral.sol\";\nimport { LibConsensus } from \"./libraries/LibConsensus.sol\";\nimport { LendingLib } from \"../lending/libraries/LendingLib.sol\";\nimport {\n PlatformSettingsLib\n} from \"../settings/platform/libraries/PlatformSettingsLib.sol\";\nimport {\n MaxDebtRatioLib\n} from \"../settings/asset/libraries/MaxDebtRatioLib.sol\";\nimport {\n MaxLoanAmountLib\n} from \"../settings/asset/libraries/MaxLoanAmountLib.sol\";\nimport { Counters } from \"@openzeppelin/contracts/utils/Counters.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\nimport { NumbersLib } from \"../shared/libraries/NumbersLib.sol\";\nimport { NFTLib } from \"../nft/libraries/NFTLib.sol\";\n\n// Interfaces\nimport { ILoansEscrow } from \"../escrow/escrow/ILoansEscrow.sol\";\nimport { ITToken } from \"../lending/ttoken/ITToken.sol\";\n\n// Proxy\nimport {\n BeaconProxy\n} from \"@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol\";\nimport { Clones } from \"@openzeppelin/contracts/proxy/Clones.sol\";\n\n// Storage\nimport {\n LoanRequest,\n LoanStatus,\n LoanTerms,\n Loan,\n MarketStorageLib\n} from \"../storage/market.sol\";\nimport { AppStorageLib } from \"../storage/app.sol\";\n\ncontract CreateLoanFacet is RolesMods, ReentryMods, PausableMods {\n /**\n * @notice This event is emitted when a loan has been successfully taken out\n * @param loanID ID of loan from which collateral was withdrawn\n * @param borrower Account address of the borrower\n * @param amountBorrowed Total amount taken out in the loan\n * @param withNFT Boolean indicating if the loan was taken out using NFTs\n */\n event LoanTakenOut(\n uint256 indexed loanID,\n address indexed borrower,\n uint256 amountBorrowed,\n bool withNFT\n );\n\n /**\n * @notice Creates the loan from requests and validator responses then calling the main function.\n * @param request Struct of the protocol loan request\n */\n modifier __createLoan(LoanRequest calldata request, bool withNFT) {\n Loan storage loan = CreateLoanLib.createLoan(request, withNFT);\n\n _;\n\n loan.status = LoanStatus.Active;\n loan.loanStartTime = uint32(block.timestamp);\n loan.duration = request.request.duration;\n }\n\n /**\n * @notice Creates a loan with the loan request and NFTs without any collateral\n * @param request Struct of the protocol loan request\n * @param nftIDs IDs of TellerNFTs to use for the loan\n */\n function takeOutLoanWithNFTs(\n LoanRequest calldata request,\n uint16[] calldata nftIDs\n ) external paused(LibLoans.ID, false) __createLoan(request, true) {\n // Get the ID of the newly created loan\n uint256 loanID = CreateLoanLib.currentID() - 1;\n uint256 amount = LibLoans.loan(loanID).borrowedAmount;\n uint8 lendingDecimals = ERC20(request.request.assetAddress).decimals();\n\n uint256 allowedBaseLoanSize;\n for (uint256 i; i < nftIDs.length; i++) {\n NFTLib.applyToLoan(loanID, nftIDs[i]);\n\n allowedBaseLoanSize += NFTLib.s().nftDictionary.tokenBaseLoanSize(\n nftIDs[i]\n );\n }\n require(\n amount <= allowedBaseLoanSize * (10**lendingDecimals),\n \"Teller: insufficient NFT loan size\"\n );\n\n // Pull funds from Teller Token LP and transfer to the new loan escrow\n LendingLib.tToken(LibLoans.loan(loanID).lendingToken).fundLoan(\n CreateLoanLib.createEscrow(loanID),\n amount\n );\n\n emit LoanTakenOut(\n loanID,\n msg.sender,\n LibLoans.loan(loanID).borrowedAmount,\n true\n );\n }\n\n /**\n * @notice Take out a loan\n *\n * @dev collateral ratio is a percentage of the loan amount that's required in collateral\n * @dev the percentage will be *(10**2). I.e. collateralRatio of 5244 means 52.44% collateral\n * @dev is required in the loan. Interest rate is also a percentage with 2 decimal points.\n *\n * @param request Struct of the protocol loan request\n * @param collateralToken Token address to use as collateral for the new loan\n * @param collateralAmount Amount of collateral required for the loan\n */\n function takeOutLoan(\n LoanRequest calldata request,\n address collateralToken,\n uint256 collateralAmount\n )\n external\n payable\n paused(LibLoans.ID, false)\n nonReentry(\"\")\n authorized(AUTHORIZED, msg.sender)\n __createLoan(request, false)\n {\n // Check if collateral token is zero\n require(\n collateralToken != address(0x0),\n \"Teller: token addr can't be 0\"\n );\n\n // Verify collateral token is acceptable\n require(\n EnumerableSet.contains(\n MarketStorageLib.store().collateralTokens[\n request.request.assetAddress\n ],\n collateralToken\n ),\n \"Teller: collateral token not allowed\"\n );\n\n // Get the ID of the newly created loan\n Loan storage loan = LibLoans.loan(CreateLoanLib.currentID() - 1);\n\n // Save collateral token to loan\n loan.collateralToken = collateralToken;\n\n // Pay in collateral\n if (collateralAmount > 0) {\n LibCollateral.deposit(loan.id, collateralAmount);\n }\n\n // Check that enough collateral has been provided for this loan\n require(\n LibLoans.getCollateralNeeded(loan.id) <=\n LibCollateral.e(loan.id).loanSupply(loan.id),\n \"Teller: more collateral required\"\n );\n // Pull funds from Teller token LP and and transfer to the recipient\n ITToken tToken = LendingLib.tToken(request.request.assetAddress);\n\n tToken.fundLoan(\n LibLoans.canGoToEOAWithCollateralRatio(loan.collateralRatio)\n ? loan.borrower\n : CreateLoanLib.createEscrow(loan.id),\n loan.borrowedAmount\n );\n\n emit LoanTakenOut(loan.id, msg.sender, loan.borrowedAmount, false);\n }\n}\n\nlibrary CreateLoanLib {\n function createLoan(LoanRequest calldata request, bool withNFT)\n internal\n returns (Loan storage loan)\n {\n // Perform loan request checks\n require(\n msg.sender == request.request.borrower,\n \"Teller: not loan requester\"\n );\n require(\n PlatformSettingsLib.getMaximumLoanDurationValue() >=\n request.request.duration,\n \"Teller: max loan duration exceeded\"\n );\n\n // Get consensus values from request\n (uint16 interestRate, uint16 collateralRatio, uint256 maxLoanAmount) =\n LibConsensus.processLoanTerms(request);\n\n // Perform loan value checks\n require(\n MaxLoanAmountLib.get(request.request.assetAddress) > maxLoanAmount,\n \"Teller: asset max loan amount exceeded\"\n );\n require(\n LendingLib.tToken(request.request.assetAddress).debtRatioFor(\n maxLoanAmount\n ) <= MaxDebtRatioLib.get(request.request.assetAddress),\n \"Teller: max supply-to-debt ratio exceeded\"\n );\n\n // Get and increment new loan ID\n uint256 loanID = CreateLoanLib.newID();\n // Set loan data based on terms\n loan = LibLoans.loan(loanID);\n loan.id = uint128(loanID);\n loan.status = LoanStatus.TermsSet;\n loan.lendingToken = request.request.assetAddress;\n loan.borrower = request.request.borrower;\n loan.borrowedAmount = maxLoanAmount;\n if (withNFT) {\n loan.interestRate = PlatformSettingsLib.getNFTInterestRate();\n } else {\n loan.interestRate = interestRate;\n loan.collateralRatio = collateralRatio;\n }\n\n // Set loan debt\n LibLoans.debt(loanID).principalOwed = maxLoanAmount;\n LibLoans.debt(loanID).interestOwed = LibLoans.getInterestOwedFor(\n uint256(loanID),\n maxLoanAmount\n );\n\n // Add loanID to borrower list\n MarketStorageLib.store().borrowerLoans[loan.borrower].push(\n uint128(loanID)\n );\n }\n\n /**\n * @notice increments the loanIDCounter\n * @return id_ the new ID requested, which stores it in the loan data\n */\n function newID() internal returns (uint256 id_) {\n Counters.Counter storage counter =\n MarketStorageLib.store().loanIDCounter;\n id_ = Counters.current(counter);\n Counters.increment(counter);\n }\n\n function currentID() internal view returns (uint256 id_) {\n Counters.Counter storage counter =\n MarketStorageLib.store().loanIDCounter;\n id_ = Counters.current(counter);\n }\n\n /**\n * @notice it creates a new loan escrow contract\n * @param loanID the ID that identifies the loan\n * @return escrow_ the loanEscrow that gets created\n */\n function createEscrow(uint256 loanID) internal returns (address escrow_) {\n // Create escrow\n escrow_ = AppStorageLib.store().loansEscrowBeacon.cloneProxy(\"\");\n ILoansEscrow(escrow_).init();\n // Save escrow address for loan\n MarketStorageLib.store().loanEscrows[loanID] = ILoansEscrow(escrow_);\n }\n}\n" + }, + "contracts/market/LoanDataFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport { LibLoans } from \"./libraries/LibLoans.sol\";\nimport { LibEscrow } from \"../escrow/libraries/LibEscrow.sol\";\n\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\n// Storage\nimport { Loan, LoanDebt, LoanTerms } from \"../storage/market.sol\";\n\ncontract LoanDataFacet {\n /**\n * @notice Returns the information about the given {loanID}.\n * @param loanID The loan ID to get information for.\n * @return loan_ The loan data.\n */\n function getLoan(uint256 loanID) external view returns (Loan memory loan_) {\n loan_ = LibLoans.s().loans[loanID];\n }\n\n /**\n * @notice DEPRECATED\n * @notice Returns the terms for a specified loan.\n * @param loanID The loan ID to get the total amount owed.\n * @return LoanTerms The terms that the loan weer created with.\n */\n function getLoanTerms(uint256 loanID)\n external\n view\n returns (LoanTerms memory)\n {\n return LibLoans.terms(loanID);\n }\n\n /**\n * @notice Returns the loan IDs created by the {borrower} account.\n * @param borrower The account to get loan IDs for.\n * @return loanIDs The IDs for loans created by the {borrower}\n */\n function getBorrowerLoans(address borrower)\n external\n view\n returns (uint128[] memory loanIDs)\n {\n return LibLoans.s().borrowerLoans[borrower];\n }\n\n /**\n * @notice Returns the debt owed for a specified loan.\n * @param loanID The loan ID to get the total amount owed.\n * @return LoanDebt The principal and interest owed amount.\n */\n function getDebtOwed(uint256 loanID)\n external\n view\n returns (LoanDebt memory)\n {\n return LibLoans.debt(loanID);\n }\n\n /**\n * @notice Returns the total amount owed for a specified loan.\n * @param loanID The loan ID to get the total amount owed.\n * @return uint256 The total owed amount.\n */\n function getTotalOwed(uint256 loanID) external view returns (uint256) {\n return LibLoans.getTotalOwed(loanID);\n }\n\n /**\n * @notice Returns the amount of interest owed for a given loan and loan amount.\n * @param loanID The loan ID to get the owed interest.\n * @param amountBorrow The principal of the loan to take out.\n * @return uint256 The interest owed.\n */\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\n external\n view\n returns (uint256)\n {\n return LibLoans.getInterestOwedFor(loanID, amountBorrow);\n }\n\n /**\n * @notice it returns the collateral needed for a loan\n * @param loanID the identifier of the loan ID to retrieve collateral from\n * @return neededInLendingTokens total collateral needed in lending tokens\n * @return neededInCollateralTokens total collateral needed in collateral tokens\n * @return escrowLoanValue total collateral needed in loan value\n */\n function getCollateralNeededInfo(uint256 loanID)\n external\n view\n returns (\n uint256 neededInLendingTokens,\n uint256 neededInCollateralTokens,\n uint256 escrowLoanValue\n )\n {\n return LibLoans.getCollateralNeededInfo(loanID);\n }\n\n /**\n * @notice it returns the typed address of a loan escrow\n * @param loanID the identifier of the respective escrow's loan\n * @return escrow_ the typed address of the returned ILoanEscrow\n */\n function getLoanEscrow(uint256 loanID)\n external\n view\n returns (address escrow_)\n {\n escrow_ = address(LibLoans.s().loanEscrows[loanID]);\n }\n\n /**\n * @notice it returns the escrow's total value by calculating the value all the escrow tokens\n * @param loanID the identifier of the respective escrow's loan\n * @return the total value of the loan escrow\n */\n function getLoanEscrowValue(uint256 loanID)\n external\n view\n returns (uint256)\n {\n return LibEscrow.calculateTotalValue(loanID);\n }\n\n /**\n * @notice it returns the total escrow tokens held by an escrow\n * @param loanID the identifier of the respective escrow's loan\n * @return tokens_ the tokens held at the escrow loan \n */\n function getEscrowTokens(uint256 loanID)\n external\n view\n returns (address[] memory tokens_)\n {\n EnumerableSet.AddressSet storage escrowTokens =\n LibEscrow.getEscrowTokens(loanID);\n tokens_ = new address[](EnumerableSet.length(escrowTokens));\n for (uint256 i; i < tokens_.length; i++) {\n tokens_[i] = EnumerableSet.at(escrowTokens, i);\n }\n }\n}\n" + }, + "contracts/market/RepayFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../contexts2/access-control/roles/RolesMods.sol\";\nimport { PausableMods } from \"../settings/pausable/PausableMods.sol\";\nimport {\n ReentryMods\n} from \"../contexts2/access-control/reentry/ReentryMods.sol\";\nimport { AUTHORIZED } from \"../shared/roles.sol\";\nimport { LoanDataFacet } from \"./LoanDataFacet.sol\";\nimport { EscrowClaimTokens } from \"../escrow/EscrowClaimTokens.sol\";\n\n// Libraries\nimport {\n IERC20,\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\nimport { LibLoans } from \"./libraries/LibLoans.sol\";\nimport { LibCollateral } from \"./libraries/LibCollateral.sol\";\nimport { LibDapps } from \"../escrow/dapps/libraries/LibDapps.sol\";\nimport { LibEscrow } from \"../escrow/libraries/LibEscrow.sol\";\nimport {\n PlatformSettingsLib\n} from \"../settings/platform/libraries/PlatformSettingsLib.sol\";\nimport { NumbersLib } from \"../shared/libraries/NumbersLib.sol\";\nimport { PriceAggLib } from \"../price-aggregator/PriceAggLib.sol\";\nimport { NFTLib } from \"../nft/libraries/NFTLib.sol\";\n\n// Interfaces\nimport { ITToken } from \"../lending/ttoken/ITToken.sol\";\nimport { ILoansEscrow } from \"../escrow/escrow/ILoansEscrow.sol\";\n\n// Storage\nimport {\n MarketStorageLib,\n MarketStorage,\n Loan,\n LoanStatus\n} from \"../storage/market.sol\";\n\ncontract RepayFacet is RolesMods, ReentryMods, PausableMods, EscrowClaimTokens {\n /**\n @notice This event is emitted when a loan has been successfully repaid\n @param loanID ID of loan from which collateral was withdrawn\n @param borrower Account address of the borrower\n @param amountPaid Amount of the loan paid back\n @param payer Account address of the payer\n @param totalOwed Total amount of the loan to be repaid\n */\n event LoanRepaid(\n uint256 indexed loanID,\n address indexed borrower,\n uint256 amountPaid,\n address payer,\n uint256 totalOwed\n );\n\n /**\n * @notice This event is emitted when a loan has been successfully liquidated\n * @param loanID ID of loan from which collateral was withdrawn\n * @param borrower Account address of the borrower\n * @param liquidator Account address of the liquidator\n * @param reward Value in lending token paid out to liquidator\n * @param tokensIn Percentage of the collateral price paid by the liquidator to the lending pool\n */\n event LoanLiquidated(\n uint256 indexed loanID,\n address indexed borrower,\n address liquidator,\n uint256 reward,\n uint256 tokensIn\n );\n\n /**\n * @notice Repay this Escrow's loan.\n * @dev If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.\n * @dev Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\n * @param loanID The id of the loan being used.\n * @param amount The amount being repaid.\n */\n function escrowRepay(uint256 loanID, uint256 amount)\n external\n paused(\"\", false)\n authorized(AUTHORIZED, msg.sender)\n nonReentry(\"\")\n {\n uint256 balance =\n LibEscrow.balanceOf(loanID, LibLoans.loan(loanID).lendingToken);\n uint256 totalOwed = LibLoans.getTotalOwed(loanID);\n // if there isn't enough balance in the escrow, then transfer amount needed to the escrow\n if (balance < totalOwed && amount > balance) {\n uint256 amountNeeded =\n amount > totalOwed ? totalOwed - (balance) : amount - (balance);\n\n SafeERC20.safeTransferFrom(\n IERC20(LibLoans.loan(loanID).lendingToken),\n msg.sender,\n address(LibEscrow.e(loanID)),\n amountNeeded\n );\n }\n\n __repayLoan(loanID, amount, address(LibEscrow.e(loanID)), false);\n }\n\n /**\n * @notice Make a payment to a loan\n * @param loanID The ID of the loan the payment is for\n * @param amount The amount of tokens to pay back to the loan\n */\n function repayLoan(uint256 loanID, uint256 amount)\n external\n nonReentry(\"\")\n paused(\"\", false)\n authorized(AUTHORIZED, msg.sender)\n {\n __repayLoan(loanID, amount, msg.sender, false);\n }\n\n /**\n * @notice it repays the loan, either from an escrow or from a regular address\n * @param loanID the identifier of the loan to repay\n * @param amount the amount to repay the loan\n * @param sender the address of the sender that wants to pay, can also be a loan escrow\n * @param isLiquidation is this loan being liquidated?\n * @return leftToPay_ the amount left to pay for the loan\n */\n function __repayLoan(\n uint256 loanID,\n uint256 amount,\n address sender,\n bool isLiquidation\n ) private returns (uint256 leftToPay_) {\n require(amount > 0, \"Teller: zero repay\");\n\n // calculate the actual amount to repay\n leftToPay_ =\n LibLoans.debt(loanID).principalOwed +\n LibLoans.debt(loanID).interestOwed;\n if (leftToPay_ < amount) {\n amount = leftToPay_;\n leftToPay_ = 0;\n } else {\n leftToPay_ -= amount;\n }\n\n // Get the Teller token for the loan\n ITToken tToken =\n MarketStorageLib.store().tTokens[\n LibLoans.loan(loanID).lendingToken\n ];\n // Transfer funds from an escrow if an escrow is calling it\n // Otherwise, transfer funds from an account\n if (address(LibEscrow.e(loanID)) == sender) {\n LibEscrow.e(loanID).claimToken(\n LibLoans.loan(loanID).lendingToken,\n address(tToken),\n amount\n );\n } else {\n SafeERC20.safeTransferFrom(\n IERC20(LibLoans.loan(loanID).lendingToken),\n sender,\n address(tToken),\n amount\n );\n }\n\n // Deduct the interest and principal owed\n uint256 principalPaid;\n uint256 interestPaid;\n if (amount < LibLoans.debt(loanID).interestOwed) {\n interestPaid = amount;\n LibLoans.debt(loanID).interestOwed -= amount;\n } else {\n if (LibLoans.debt(loanID).interestOwed > 0) {\n interestPaid = LibLoans.debt(loanID).interestOwed;\n amount -= interestPaid;\n LibLoans.debt(loanID).interestOwed = 0;\n }\n\n if (amount > 0) {\n principalPaid = amount;\n LibLoans.debt(loanID).principalOwed -= amount;\n }\n }\n\n // Tell the Teller Token value has been deposited back into the pool.\n tToken.repayLoan(principalPaid, interestPaid);\n\n if (isLiquidation) {\n // Make sure there is nothing left to repay on the loan\n require(leftToPay_ == 0, \"Teller: liquidate partial repay\");\n\n // Set loan status\n LibLoans.loan(loanID).status = LoanStatus.Liquidated;\n\n // Transfer NFT if linked\n NFTLib.liquidateNFT(loanID);\n } else {\n // if the loan is now fully paid, close it and withdraw borrower collateral\n if (leftToPay_ == 0) {\n LibLoans.loan(loanID).status = LoanStatus.Closed;\n\n // Check if the loan has a collateral token\n if (LibLoans.loan(loanID).collateralToken != address(0)) {\n LibCollateral.withdrawAll(\n loanID,\n LibLoans.loan(loanID).borrower\n );\n }\n\n // Claim tokens in the escrow for the loan if any\n __claimEscrowTokens(loanID);\n\n // Restake any NFTs linked to loan for borrower\n NFTLib.restakeLinked(loanID, LibLoans.loan(loanID).borrower);\n }\n\n emit LoanRepaid(\n loanID,\n LibLoans.loan(loanID).borrower,\n amount,\n msg.sender,\n leftToPay_\n );\n }\n }\n\n /**\n * @notice Liquidate a loan if it is expired or under collateralized\n * @param loanID The ID of the loan to be liquidated\n */\n function liquidateLoan(uint256 loanID)\n external\n nonReentry(\"\")\n paused(\"\", false)\n authorized(AUTHORIZED, msg.sender)\n {\n Loan storage loan = LibLoans.loan(loanID);\n uint256 collateralAmount = LibCollateral.e(loanID).loanSupply(loanID);\n require(\n RepayLib.isLiquidable(loanID, collateralAmount),\n \"Teller: does not need liquidation\"\n );\n\n // Calculate the reward before repaying the loan\n (uint256 rewardInLending, uint256 collateralInLending) =\n RepayLib.getLiquidationReward(loanID, collateralAmount);\n\n // The liquidator pays the amount still owed on the loan\n uint256 amountToLiquidate =\n LibLoans.debt(loanID).principalOwed +\n LibLoans.debt(loanID).interestOwed;\n\n __repayLoan(loanID, amountToLiquidate, msg.sender, true);\n\n // Payout the liquidator reward owed\n if (rewardInLending > 0) {\n RepayLib.payOutLiquidator(\n loanID,\n rewardInLending,\n collateralInLending,\n collateralAmount,\n payable(msg.sender)\n );\n }\n\n emit LoanLiquidated(\n loanID,\n loan.borrower,\n msg.sender,\n rewardInLending,\n amountToLiquidate\n );\n }\n\n /**\n * @notice It gets the current liquidation reward for a given loan.\n * @param loanID The loan ID to get the info.\n * @return inLending_ The value the liquidator will receive denoted in lending tokens.\n * @return inCollateral_ The value the liquidator will receive denoted in collateral tokens.\n */\n function getLiquidationReward(uint256 loanID)\n external\n view\n returns (uint256 inLending_, uint256 inCollateral_)\n {\n (inLending_, ) = RepayLib.getLiquidationReward(\n loanID,\n LibCollateral.e(loanID).loanSupply(loanID)\n );\n inCollateral_ = PriceAggLib.valueFor(\n LibLoans.loan(loanID).lendingToken,\n LibLoans.loan(loanID).collateralToken,\n inLending_\n );\n }\n}\n\nlibrary RepayLib {\n /**\n * @notice It checks if a loan can be liquidated.\n * @param loanID The loan ID to check.\n * @return true if the loan is liquidable.\n */\n function isLiquidable(uint256 loanID, uint256 collateralAmount)\n internal\n view\n returns (bool)\n {\n Loan storage loan = LibLoans.loan(loanID);\n // Check if loan can be liquidated\n if (loan.status != LoanStatus.Active) {\n return false;\n }\n\n if (loan.collateralRatio > 0) {\n // If loan has a collateral ratio, check how much is needed\n (, uint256 neededInCollateral, ) =\n LoanDataFacet(address(this)).getCollateralNeededInfo(loanID);\n if (neededInCollateral > collateralAmount) {\n return true;\n }\n }\n\n // Otherwise, check if the loan has expired\n return block.timestamp >= loan.loanStartTime + loan.duration;\n }\n\n /**\n * @notice It gets the current liquidation reward for a given loan.\n * @param loanID The loan ID to get the info.\n * @param collateralAmount The amount of collateral for the {loanID}. Passed in to save gas calling the collateral escrow multiple times.\n * @return reward_ The value the liquidator will receive denoted in lending tokens.\n */\n function getLiquidationReward(uint256 loanID, uint256 collateralAmount)\n internal\n view\n returns (uint256 reward_, uint256 collateralValue_)\n {\n uint256 amountToLiquidate =\n LibLoans.debt(loanID).principalOwed +\n LibLoans.debt(loanID).interestOwed;\n\n // Max reward is amount repaid on loan plus extra percentage\n uint256 maxReward =\n amountToLiquidate +\n NumbersLib.percent(\n amountToLiquidate,\n uint16(PlatformSettingsLib.getLiquidateRewardPercent())\n );\n\n // Calculate available collateral for reward\n if (collateralAmount > 0) {\n collateralValue_ = PriceAggLib.valueFor(\n LibLoans.loan(loanID).collateralToken,\n LibLoans.loan(loanID).lendingToken,\n collateralAmount\n );\n reward_ += collateralValue_;\n }\n\n // Calculate loan escrow value if collateral not enough to cover reward\n if (reward_ < maxReward) {\n reward_ += LibEscrow.calculateTotalValue(loanID);\n }\n\n // Cap the reward to max\n if (reward_ > maxReward) {\n reward_ = maxReward;\n }\n }\n\n /**\n * @notice Checks if the loan has an Escrow and claims any tokens then pays out the loan collateral.\n * @dev See Escrow.claimTokens for more info.\n * @param loanID The loan ID which is being liquidated\n * @param rewardInLending The total amount of reward based in the lending token to pay the liquidator\n * @param collateralInLending The amount of collateral that is available for the loan denoted in lending tokens\n * @param collateralAmount The amount of collateral that is available for the loan\n * @param liquidator The address of the liquidator where the liquidation reward will be sent to\n */\n function payOutLiquidator(\n uint256 loanID,\n uint256 rewardInLending,\n uint256 collateralInLending,\n uint256 collateralAmount,\n address payable liquidator\n ) internal {\n // check if loan is liquidated\n require(\n LibLoans.loan(loanID).status == LoanStatus.Liquidated,\n \"Teller: loan not liquidated\"\n );\n\n // if the lending reward is less than the collateral lending tokens, then aggregate\n // the value for the lending token with the collateral token and send it to the liquidator\n if (rewardInLending <= collateralInLending) {\n uint256 rewardInCollateral =\n PriceAggLib.valueFor(\n LibLoans.loan(loanID).lendingToken,\n LibLoans.loan(loanID).collateralToken,\n rewardInLending\n );\n\n LibCollateral.withdraw(loanID, rewardInCollateral, liquidator);\n } else {\n // Payout whats available in the collateral token\n LibCollateral.withdraw(loanID, collateralAmount, liquidator);\n\n // Claim remaining reward value from the loan escrow\n claimEscrowTokensByValue(\n loanID,\n liquidator,\n rewardInLending - collateralInLending\n );\n }\n }\n\n /**\n * @dev Send the equivalent of tokens owned by the loan escrow (in lending value) to the recipient,\n * @param loanID The loan ID to clam tokens from\n * @param recipient address to send the tokens to\n * @param value The value of escrow held tokens to be claimed based in lending value\n */\n function claimEscrowTokensByValue(\n uint256 loanID,\n address recipient,\n uint256 value\n ) private {\n EnumerableSet.AddressSet storage tokens =\n MarketStorageLib.store().escrowTokens[loanID];\n uint256 valueLeftToTransfer = value;\n\n // Start with the lending token\n valueLeftToTransfer = claimEscrowToken(\n loanID,\n LibLoans.loan(loanID).lendingToken,\n recipient,\n valueLeftToTransfer\n );\n\n // Cycle through remaining tokens\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\n if (valueLeftToTransfer == 0) {\n return;\n }\n\n valueLeftToTransfer = claimEscrowToken(\n loanID,\n EnumerableSet.at(tokens, i),\n recipient,\n valueLeftToTransfer\n );\n }\n }\n\n /**\n * @notice it claims the escrow tokens for the liquidator\n * @notice it keeps claiming escrow tokens until there aren't anymore tokens or the valueLeftToTransfer is zero\n * @param loanID the identifier of the escrow loan to claim tokens from\n * @param token the address of the token asset to claim\n * @param recipient the address of the recipient to transfer the tokens to\n * @param valueLeftToTransfer the value left to transfer to the liquidator that is returned back\n * @return the value left to transfer\n */\n function claimEscrowToken(\n uint256 loanID,\n address token,\n address recipient,\n uint256 valueLeftToTransfer\n ) private returns (uint256) {\n uint256 balance = LibEscrow.balanceOf(loanID, token);\n // get value of token balance in lending value\n if (balance > 0) {\n // If token not the lending token, get value of token\n uint256 balanceInLending;\n if (token == LibLoans.loan(loanID).lendingToken) {\n balanceInLending = balance;\n } else {\n balanceInLending = PriceAggLib.valueFor(\n token,\n LibLoans.loan(loanID).lendingToken,\n balance\n );\n }\n\n if (balanceInLending <= valueLeftToTransfer) {\n LibEscrow.e(loanID).claimToken(token, recipient, balance);\n valueLeftToTransfer -= balanceInLending;\n } else {\n // Token balance is more than enough so calculate ratio of balance to transfer\n uint256 valueToTransfer;\n if (token == LibLoans.loan(loanID).lendingToken) {\n valueToTransfer = valueLeftToTransfer;\n } else {\n valueToTransfer = NumbersLib.percent(\n balance,\n NumbersLib.ratioOf(\n valueLeftToTransfer,\n balanceInLending\n )\n );\n }\n\n LibEscrow.e(loanID).claimToken(\n token,\n recipient,\n valueToTransfer\n );\n valueLeftToTransfer = 0;\n }\n }\n return valueLeftToTransfer;\n }\n}\n" + }, + "contracts/market/SignersFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Storage\nimport { MarketStorageLib } from \"../storage/market.sol\";\n\n// Libraries\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\ncontract SignersFacet {\n /**\n * @notice It adds a new account as a signer.\n * @param asset Token address to add signers for.\n * @param account address to add.\n * @dev The sender must be the owner.\n * @dev It throws a require error if the sender is not the owner.\n */\n function addSigner(address asset, address account) external {\n _addSigner(asset, account);\n }\n\n /**\n * @notice It adds a list of account as signers.\n * @param asset Token address to add signers for.\n * @param accounts addresses to add.\n * @dev The sender must be the owner.\n * @dev It throws a require error if the sender is not the owner.\n */\n function addSigners(address asset, address[] calldata accounts) external {\n for (uint256 i; i < accounts.length; i++) {\n _addSigner(asset, accounts[i]);\n }\n }\n\n /**\n * @notice it adds an account to a list of signers for an asset\n * @param asset is the token address to check for signers\n * @param account is the account address of the signer\n */\n function _addSigner(address asset, address account) internal {\n if (!isSigner(asset, account)) {\n EnumerableSet.add(MarketStorageLib.store().signers[asset], account);\n }\n }\n\n /**\n * @notice it checks if an account is already in the list of the asset's signers\n * @param asset the asset to check for if the signer exists\n * @param account the account to check in the list of the asset's signers\n */\n function isSigner(address asset, address account)\n public\n view\n returns (bool isSigner_)\n {\n isSigner_ = EnumerableSet.contains(\n MarketStorageLib.store().signers[asset],\n account\n );\n }\n}\n" + }, + "contracts/market/CollateralFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../contexts2/access-control/roles/RolesMods.sol\";\nimport {\n ReentryMods\n} from \"../contexts2/access-control/reentry/ReentryMods.sol\";\nimport { PausableMods } from \"../settings/pausable/PausableMods.sol\";\nimport { ADMIN, AUTHORIZED } from \"../shared/roles.sol\";\n\n// Libraries\nimport { LibLoans } from \"./libraries/LibLoans.sol\";\nimport { LibCollateral } from \"./libraries/LibCollateral.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\n// Storage\nimport {\n MarketStorageLib,\n MarketStorage,\n LoanStatus,\n Loan\n} from \"../storage/market.sol\";\n\ncontract CollateralFacet is RolesMods, ReentryMods, PausableMods {\n /**\n * @notice Deposit collateral tokens into a loan.\n * @param loanID The ID of the loan the collateral is for\n * @param amount The amount to deposit as collateral.\n */\n function depositCollateral(uint256 loanID, uint256 amount)\n external\n payable\n paused(\"\", false)\n nonReentry(\"\")\n authorized(AUTHORIZED, msg.sender)\n {\n uint256 status = uint256(LibLoans.loan(loanID).status);\n require(\n status ==\n (uint256(LoanStatus.TermsSet) ^ uint256(LoanStatus.Active)) &\n status,\n \"Teller: loan not active or set\"\n );\n\n // Transfer tokens to the collateral escrow\n LibCollateral.deposit(loanID, amount);\n }\n\n /**\n * @notice it withdraws collateral tokens from a loan\n * @param amount to wtihdraw from the loan\n * @param loanID identifier of our loan\n */\n function withdrawCollateral(uint256 amount, uint256 loanID)\n external\n paused(\"\", false)\n nonReentry(\"\")\n authorized(AUTHORIZED, msg.sender)\n {\n // check if caller is borrower\n require(\n msg.sender == LibLoans.loan(loanID).borrower,\n \"Teller: not borrower\"\n );\n\n // check if amount required to withdraw is more than zero\n require(amount > 0, \"Teller: zero withdraw\");\n\n // here, we check if the loan supply minus the needed collateral tokens is still\n // greater than the amount we want to withdraw\n if (LibLoans.loan(loanID).status == LoanStatus.Active) {\n (, uint256 needed, ) = LibLoans.getCollateralNeededInfo(loanID);\n if (needed > 0) {\n require(\n LibCollateral.e(loanID).loanSupply(loanID) - needed >=\n amount,\n \"Teller: collateral withdraw amount over limit\"\n );\n }\n }\n\n // Withdraw collateral and send to loan borrower\n LibCollateral.withdraw(loanID, amount, LibLoans.loan(loanID).borrower);\n }\n\n /**\n * @notice Adds tokens allowed to be used as collateral for {asset} loans.\n * @notice it creates an escrow for each collateral token address\n * @param asset Token address to add allowed collateral tokens.\n * @param collateralTokens List of allowed collateral token addresses.\n *\n * Requirements:\n * - Sender must be admin\n */\n function addCollateralTokens(\n address asset,\n address[] calldata collateralTokens\n ) external authorized(ADMIN, msg.sender) {\n for (uint256 i; i < collateralTokens.length; i++) {\n EnumerableSet.add(\n MarketStorageLib.store().collateralTokens[asset],\n collateralTokens[i]\n );\n LibCollateral.createEscrow(collateralTokens[i]);\n }\n }\n\n /**\n * @notice get list of collateral tokens that is allowed to be used on an {asset} loan\n * @param asset token address to get allowed collateral tokens\n * @return tokens_ collateral tokens that are accepted\n */\n function getCollateralTokens(address asset)\n external\n view\n returns (address[] memory tokens_)\n {\n EnumerableSet.AddressSet storage collateralTokens =\n MarketStorageLib.store().collateralTokens[asset];\n tokens_ = new address[](EnumerableSet.length(collateralTokens));\n for (uint256 i; i < EnumerableSet.length(collateralTokens); i++) {\n tokens_[i] = EnumerableSet.at(collateralTokens, i);\n }\n }\n\n /**\n * @notice get the total collateral tokens in a respective loan\n * @param loanID the identifier of the respective loan\n * @return supply_ the total amount of supply in collateral of the loan\n */\n function getLoanCollateral(uint256 loanID)\n external\n view\n returns (uint256 supply_)\n {\n supply_ = LibCollateral.e(loanID).loanSupply(loanID);\n }\n}\n" + }, + "contracts/escrow/dapps/CompoundFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { DappMods } from \"./DappMods.sol\";\nimport { PausableMods } from \"../../settings/pausable/PausableMods.sol\";\n\n// Libraries\nimport { LibCompound } from \"./libraries/LibCompound.sol\";\nimport { LibDapps } from \"./libraries/LibDapps.sol\";\nimport { LibEscrow } from \"../libraries/LibEscrow.sol\";\nimport {\n AssetCTokenLib\n} from \"../../settings/asset/libraries/AssetCTokenLib.sol\";\n\n// Interfaces\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { ICErc20 } from \"../../shared/interfaces/ICErc20.sol\";\n\ncontract CompoundFacet is PausableMods, DappMods {\n /**\n * @notice This event is emitted every time Compound lend is invoked successfully.\n * @param tokenAddress address of the underlying token.\n * @param cTokenAddress compound token address.\n * @param amount amount of tokens to Lend.\n */\n event CompoundLended(\n address indexed tokenAddress,\n address indexed cTokenAddress,\n uint256 amount\n );\n\n /**\n * @notice This event is emitted every time Compound redeem is invoked successfully.\n * @param tokenAddress address of the underlying token.\n * @param cTokenAddress compound token address.\n * @param amount amount of tokens to Redeem.\n */\n event CompoundRedeemed(\n address indexed tokenAddress,\n address indexed cTokenAddress,\n uint256 amount\n );\n\n /**\n * @notice To lend we first have to approve the cToken to access the token balance then mint.\n * @param loanID id of the loan being used in the dapp\n * @param tokenAddress address of the token.\n * @param amount amount of tokens to mint.\n */\n function compoundLend(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n ICErc20 cToken = AssetCTokenLib.get(tokenAddress);\n\n LibEscrow.e(loanID).setTokenAllowance(tokenAddress, address(cToken));\n\n bytes memory result =\n LibEscrow.e(loanID).callDapp(\n address(cToken),\n abi.encodeWithSelector(ICErc20.mint.selector, amount)\n );\n\n require(\n abi.decode(result, (uint256)) == LibCompound.NO_ERROR,\n \"Teller: compound deposit error\"\n );\n\n LibEscrow.tokenUpdated(loanID, address(cToken));\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n\n emit CompoundLended(tokenAddress, address(cToken), amount);\n }\n\n /**\n * @notice This function redeems the user's cTokens for a specific amount of the underlying token.\n * @param loanID id of the loan being used in the dapp\n * @param tokenAddress address of the token.\n * @param amount amount of underlying tokens to redeem.\n */\n function compoundRedeem(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n ICErc20 cToken = AssetCTokenLib.get(tokenAddress);\n __compoundRedeem(\n loanID,\n address(cToken),\n tokenAddress,\n abi.encodeWithSelector(ICErc20.redeemUnderlying.selector, amount)\n );\n\n emit CompoundRedeemed(tokenAddress, address(cToken), amount);\n }\n\n /**\n * @notice This function redeems the complete cToken balance.\n * @param loanID id of the loan being used in the dapp\n * @param tokenAddress address of the token.\n */\n function compoundRedeemAll(uint256 loanID, address tokenAddress)\n public\n paused(\"\", false)\n onlyBorrower(loanID)\n {\n ICErc20 cToken = AssetCTokenLib.get(tokenAddress);\n __compoundRedeem(\n loanID,\n address(cToken),\n tokenAddress,\n abi.encodeWithSelector(\n ICErc20.redeem.selector,\n cToken.balanceOf(address(LibEscrow.e(loanID)))\n )\n );\n\n emit CompoundRedeemed(\n tokenAddress,\n address(cToken),\n IERC20(tokenAddress).balanceOf(address(LibEscrow.e(loanID)))\n );\n }\n\n /**\n * @notice This function calls on Compound cToken to redeem an amount of the underlying token.\n * @param loanID ID of the loan being used for the dapp.\n * @param cTokenAddress Compound token address.\n * @param tokenAddress Underlying Compound token address.\n * @param callData Encoded data to send to the escrow to call.\n */\n function __compoundRedeem(\n uint256 loanID,\n address cTokenAddress,\n address tokenAddress,\n bytes memory callData\n ) private {\n bytes memory result =\n LibEscrow.e(loanID).callDapp(cTokenAddress, callData);\n\n require(\n abi.decode(result, (uint256)) !=\n LibCompound.TOKEN_INSUFFICIENT_BALANCE,\n \"Teller: compound dapp insufficient balance\"\n );\n require(\n abi.decode(result, (uint256)) == LibCompound.NO_ERROR,\n \"Teller: compound dapp withdrawal error\"\n );\n\n LibEscrow.tokenUpdated(loanID, cTokenAddress);\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n }\n}\n" + }, + "contracts/escrow/dapps/UniswapFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { DappMods } from \"./DappMods.sol\";\nimport { PausableMods } from \"../../settings/pausable/PausableMods.sol\";\n\n// Libraries\nimport { LibEscrow } from \"../libraries/LibEscrow.sol\";\nimport { LibUniswap } from \"./libraries/LibUniswap.sol\";\nimport {\n ChainlinkLib\n} from \"../../price-aggregator/chainlink/ChainlinkLib.sol\";\n\n// Interfaces\nimport { IUniswapV2Router } from \"../../shared/interfaces/IUniswapV2Router.sol\";\n\ncontract UniswapFacet is PausableMods, DappMods {\n /**\n * @notice Event emitted every time a successful swap has taken place.\n * @param sourceToken source token address.\n * @param destinationToken destination address.\n * @param sourceAmount source amount sent.\n * @param destinationAmount destination amount received.\n */\n event UniswapSwapped(\n address indexed sourceToken,\n address indexed destinationToken,\n uint256 sourceAmount,\n uint256 destinationAmount\n );\n\n /**\n * @notice Swaps tokens for tokens on Uniswap.\n * @dev {path} must have at least 2 token addresses\n * @param path An array of token addresses.\n * @param sourceAmount amount of source token to swap.\n * @param minDestination The minimum amount of output tokens that must be received for the transaction not to revert.\n */\n function uniswapSwap(\n uint256 loanID,\n address[] memory path,\n uint256 sourceAmount,\n uint256 minDestination\n ) external paused(\"\", false) onlySecured(loanID) onlyBorrower(loanID) {\n address src = path[0];\n address dst = path[path.length - 1];\n require(\n ChainlinkLib.isTokenSupported(src),\n \"Teller: uniswap src not supported\"\n );\n require(\n ChainlinkLib.isTokenSupported(dst),\n \"Teller: uniswap dst not supported\"\n );\n\n // Set allowance on source token to Uniswap Router\n LibEscrow.e(loanID).setTokenAllowance(src, address(LibUniswap.ROUTER));\n\n // Encode data for LoansEscrow to call\n bytes memory callData =\n abi.encodeWithSelector(\n IUniswapV2Router.swapExactTokensForTokens.selector,\n sourceAmount,\n minDestination,\n path,\n address(LibEscrow.e(loanID)),\n block.timestamp\n );\n // Call Escrow to do swap get the response amounts\n uint256[] memory amounts =\n abi.decode(\n LibEscrow.e(loanID).callDapp(\n address(LibUniswap.ROUTER),\n callData\n ),\n (uint256[])\n );\n uint256 destinationAmount = amounts[amounts.length - 1];\n\n LibEscrow.tokenUpdated(loanID, src);\n LibEscrow.tokenUpdated(loanID, dst);\n\n emit UniswapSwapped(src, dst, sourceAmount, destinationAmount);\n }\n}\n" + }, + "contracts/shared/interfaces/IUniswapV2Router.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/**\n @notice This interface defines the different functions available for a UniswapV2Router.\n @author develop@teller.finance\n */\ninterface IUniswapV2Router {\n function factory() external pure returns (address);\n \n function addLiquidity(\n address tokenA,\n address tokenB,\n uint256 amountADesired,\n uint256 amountBDesired,\n uint256 amountAMin,\n uint256 amountBMin,\n address to,\n uint256 deadline\n )\n external\n returns (\n uint256 amountA,\n uint256 amountB,\n uint256 liquidity\n );\n\n function addLiquidityETH(\n address token,\n uint256 amountTokenDesired,\n uint256 amountTokenMin,\n uint256 amountETHMin,\n address to,\n uint256 deadline\n )\n external\n payable\n returns (\n uint256 amountToken,\n uint256 amountETH,\n uint256 liquidity\n );\n\n function removeLiquidity(\n address tokenA,\n address tokenB,\n uint256 liquidity,\n uint256 amountAMin,\n uint256 amountBMin,\n address to,\n uint256 deadline\n ) external returns (uint256 amountA, uint256 amountB);\n\n function removeLiquidityETH(\n address token,\n uint256 liquidity,\n uint256 amountTokenMin,\n uint256 amountETHMin,\n address to,\n uint256 deadline\n ) external returns (uint256 amountToken, uint256 amountETH);\n\n function removeLiquidityWithPermit(\n address tokenA,\n address tokenB,\n uint256 liquidity,\n uint256 amountAMin,\n uint256 amountBMin,\n address to,\n uint256 deadline,\n bool approveMax,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external returns (uint256 amountA, uint256 amountB);\n\n function removeLiquidityETHWithPermit(\n address token,\n uint256 liquidity,\n uint256 amountTokenMin,\n uint256 amountETHMin,\n address to,\n uint256 deadline,\n bool approveMax,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external returns (uint256 amountToken, uint256 amountETH);\n\n function quote(\n uint256 amountA,\n uint256 reserveA,\n uint256 reserveB\n ) external pure returns (uint256 amountB);\n\n function getAmountOut(\n uint256 amountIn,\n uint256 reserveIn,\n uint256 reserveOut\n ) external pure returns (uint256 amountOut);\n\n function getAmountIn(\n uint256 amountOut,\n uint256 reserveIn,\n uint256 reserveOut\n ) external pure returns (uint256 amountIn);\n\n function getAmountsOut(uint256 amountIn, address[] calldata path)\n external\n view\n returns (uint256[] memory amounts);\n\n function getAmountsIn(uint256 amountOut, address[] calldata path)\n external\n view\n returns (uint256[] memory amounts);\n\n /**\n @notice It returns the address of the canonical WETH address;\n */\n function WETH() external pure returns (address);\n\n /**\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\n @param amountIn The amount of input tokens to send.\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\n @param to Recipient of the output tokens.\n @param deadline Unix timestamp after which the transaction will revert.\n @return amounts The input token amount and all subsequent output token amounts.\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\n */\n function swapExactTokensForTokens(\n uint256 amountIn,\n uint256 amountOutMin,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external returns (uint256[] memory amounts);\n\n /**\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\n @param amountIn The amount of input tokens to send.\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\n @param to Recipient of the ETH.\n @param deadline Unix timestamp after which the transaction will revert.\n @return amounts The input token amount and all subsequent output token amounts.\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\n */\n function swapExactTokensForETH(\n uint256 amountIn,\n uint256 amountOutMin,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external returns (uint256[] memory amounts);\n\n /**\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\n @param to Recipient of the output tokens.\n @param deadline Unix timestamp after which the transaction will revert.\n @return amounts The input token amount and all subsequent output token amounts.\n */\n function swapExactETHForTokens(\n uint256 amountOutMin,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external payable returns (uint256[] memory amounts);\n\n function swapTokensForExactTokens(\n uint256 amountOut,\n uint256 amountInMax,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external returns (uint256[] memory amounts);\n\n function swapTokensForExactETH(\n uint256 amountOut,\n uint256 amountInMax,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external returns (uint256[] memory amounts);\n\n function swapETHForExactTokens(\n uint256 amountOut,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external payable returns (uint256[] memory amounts);\n}\n" + }, + "contracts/shared/interfaces/ICErc20.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./IComptroller.sol\";\n\ninterface ICErc20 {\n /*** User Interface ***/\n\n /**\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\n @return 0 on success, otherwise an Error code\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\n */\n function mint(uint256 mintAmount) external returns (uint256);\n\n /**\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\n @param redeemTokens The number of cTokens to be redeemed.\n @return 0 on success, otherwise an Error code\n @dev msg.sender The account to which redeemed funds shall be transferred.\n */\n function redeem(uint256 redeemTokens) external returns (uint256);\n\n /**\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\n @param redeemAmount The amount of underlying to be redeemed.\n @return 0 on success, otherwise an Error code\n @dev msg.sender The account to which redeemed funds shall be transferred.\n */\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\n\n /**\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\n @param borrowAmount The amount of the underlying asset to be borrowed.\n @return 0 on success, otherwise an Error code\n @dev msg.sender The account to which borrowed funds shall be transferred.\n */\n function borrow(uint256 borrowAmount) external returns (uint256);\n\n /**\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\n @return 0 on success, otherwise an Error code\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\n */\n function repayBorrow(uint256 repayAmount) external returns (uint256);\n\n /**\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\n @param borrower The account which borrowed the asset to be repaid.\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\n @return 0 on success, otherwise an Error code\n @dev msg.sender The account which shall repay the borrow.\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\n */\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\n external\n returns (uint256);\n\n /*** Admin Functions ***/\n\n function _addReserves(uint256 addAmount) external returns (uint256);\n\n /** End Admin Functions */\n\n function underlying() external view returns (address);\n\n /**\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\n */\n function exchangeRateCurrent() external returns (uint256);\n\n function exchangeRateStored() external view returns (uint256);\n\n /**\n * @notice Applies accrued interest to total borrows and reserves\n * @dev This calculates interest accrued from the last checkpointed block\n * up to the current block and writes new checkpoint to storage.\n */\n function accrueInterest() external;\n\n function decimals() external view returns (uint8);\n\n function balanceOf(address account) external view returns (uint256);\n\n /**\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\n @param account The account to get the underlying balance of.\n @return The amount of underlying currently owned by the account.\n */\n function balanceOfUnderlying(address account) external returns (uint256);\n\n function comptroller() external view returns (IComptroller);\n}\n" + }, + "contracts/settings/asset/libraries/AssetCTokenLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../../shared/libraries/CacheLib.sol\";\nimport { ICErc20 } from \"../../../shared/interfaces/ICErc20.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions for Compound asset setting.\n *\n * @author develop@teller.finance\n */\nlibrary AssetCTokenLib {\n bytes32 private constant NAME = keccak256(\"cToken\");\n\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n function get(address asset) internal view returns (ICErc20) {\n return ICErc20(s(asset).addresses[NAME]);\n }\n\n function set(address asset, address newValue) internal {\n s(asset).addresses[NAME] = newValue;\n }\n}\n" + }, + "contracts/settings/asset/libraries/MaxLoanAmountLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../../shared/libraries/CacheLib.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions for MaxLoanAmount asset setting.\n *\n * @author develop@teller.finance\n */\nlibrary MaxLoanAmountLib {\n bytes32 private constant NAME = keccak256(\"MaxLoanAmount\");\n\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n function get(address asset) internal view returns (uint256) {\n return s(asset).uints[NAME];\n }\n\n function set(address asset, uint256 newValue) internal {\n s(asset).uints[NAME] = newValue;\n }\n}\n" + }, + "contracts/settings/asset/libraries/MaxTVLLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../../shared/libraries/CacheLib.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions for MaxDebtRatio asset setting.\n *\n * @author develop@teller.finance\n */\nlibrary MaxTVLLib {\n bytes32 private constant NAME = keccak256(\"MaxTVL\");\n\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n function get(address asset) internal view returns (uint256) {\n return s(asset).uints[NAME];\n }\n\n function set(address asset, uint256 newValue) internal {\n s(asset).uints[NAME] = newValue;\n }\n}\n" + }, + "contracts/shared/interfaces/IComptroller.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IComptroller {\n /*** Assets You Are In ***/\n\n function enterMarkets(address[] calldata cTokens)\n external\n returns (uint256[] memory);\n\n function exitMarket(address cToken) external returns (uint256);\n\n /*** Policy Hooks ***/\n\n /**\n * @notice Checks if the account should be allowed to mint tokens in the given market\n * @param cToken The market to verify the mint against\n * @param minter The account which would get the minted tokens\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\n */\n function mintAllowed(\n address cToken,\n address minter,\n uint256 mintAmount\n ) external returns (uint256);\n\n /**\n * @notice Validates mint and reverts on rejection. May emit logs.\n * @param cToken Asset being minted\n * @param minter The address minting the tokens\n * @param mintAmount The amount of the underlying asset being minted\n * @param mintTokens The number of tokens being minted\n */\n function mintVerify(\n address cToken,\n address minter,\n uint256 mintAmount,\n uint256 mintTokens\n ) external;\n\n /**\n * @notice Checks if the account should be allowed to redeem tokens in the given market\n * @param cToken The market to verify the redeem against\n * @param redeemer The account which would redeem the tokens\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\n */\n function redeemAllowed(\n address cToken,\n address redeemer,\n uint256 redeemTokens\n ) external returns (uint256);\n\n /**\n * @notice Validates redeem and reverts on rejection. May emit logs.\n * @param cToken Asset being redeemed\n * @param redeemer The address redeeming the tokens\n * @param redeemAmount The amount of the underlying asset being redeemed\n * @param redeemTokens The number of tokens being redeemed\n */\n function redeemVerify(\n address cToken,\n address redeemer,\n uint256 redeemAmount,\n uint256 redeemTokens\n ) external;\n\n /**\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\n * @param cToken The market to verify the borrow against\n * @param borrower The account which would borrow the asset\n * @param borrowAmount The amount of underlying the account would borrow\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\n */\n function borrowAllowed(\n address cToken,\n address borrower,\n uint256 borrowAmount\n ) external returns (uint256);\n\n /**\n * @notice Validates borrow and reverts on rejection. May emit logs.\n * @param cToken Asset whose underlying is being borrowed\n * @param borrower The address borrowing the underlying\n * @param borrowAmount The amount of the underlying asset requested to borrow\n */\n function borrowVerify(\n address cToken,\n address borrower,\n uint256 borrowAmount\n ) external;\n\n /**\n * @notice Checks if the account should be allowed to repay a borrow in the given market\n * @param cToken The market to verify the repay against\n * @param payer The account which would repay the asset\n * @param borrower The account which would borrowed the asset\n * @param repayAmount The amount of the underlying asset the account would repay\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\n */\n function repayBorrowAllowed(\n address cToken,\n address payer,\n address borrower,\n uint256 repayAmount\n ) external returns (uint256);\n\n /**\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\n * @param cToken Asset being repaid\n * @param payer The address repaying the borrow\n * @param borrower The address of the borrower\n * @param repayAmount The amount of underlying being repaid\n * @param borrowerIndex the index of the borrower\n */\n function repayBorrowVerify(\n address cToken,\n address payer,\n address borrower,\n uint256 repayAmount,\n uint256 borrowerIndex\n ) external;\n\n /**\n * @notice Checks if the liquidation should be allowed to occur\n * @param cTokenBorrowed Asset which was borrowed by the borrower\n * @param cTokenCollateral Asset which was used as collateral and will be seized\n * @param liquidator The address repaying the borrow and seizing the collateral\n * @param borrower The address of the borrower\n * @param repayAmount The amount of underlying being repaid\n */\n function liquidateBorrowAllowed(\n address cTokenBorrowed,\n address cTokenCollateral,\n address liquidator,\n address borrower,\n uint256 repayAmount\n ) external returns (uint256);\n\n /**\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\n * @param cTokenBorrowed Asset which was borrowed by the borrower\n * @param cTokenCollateral Asset which was used as collateral and will be seized\n * @param liquidator The address repaying the borrow and seizing the collateral\n * @param borrower The address of the borrower\n * @param repayAmount The amount of underlying being repaid\n * @param seizeTokens The number of collateral tokens to seize\n */\n function liquidateBorrowVerify(\n address cTokenBorrowed,\n address cTokenCollateral,\n address liquidator,\n address borrower,\n uint256 repayAmount,\n uint256 seizeTokens\n ) external;\n\n /**\n * @notice Checks if the seizing of assets should be allowed to occur\n * @param cTokenCollateral Asset which was used as collateral and will be seized\n * @param cTokenBorrowed Asset which was borrowed by the borrower\n * @param liquidator The address repaying the borrow and seizing the collateral\n * @param borrower The address of the borrower\n * @param seizeTokens The number of collateral tokens to seize\n */\n function seizeAllowed(\n address cTokenCollateral,\n address cTokenBorrowed,\n address liquidator,\n address borrower,\n uint256 seizeTokens\n ) external returns (uint256);\n\n /**\n * @notice Validates seize and reverts on rejection. May emit logs.\n * @param cTokenCollateral Asset which was used as collateral and will be seized\n * @param cTokenBorrowed Asset which was borrowed by the borrower\n * @param liquidator The address repaying the borrow and seizing the collateral\n * @param borrower The address of the borrower\n * @param seizeTokens The number of collateral tokens to seize\n */\n function seizeVerify(\n address cTokenCollateral,\n address cTokenBorrowed,\n address liquidator,\n address borrower,\n uint256 seizeTokens\n ) external;\n\n /**\n * @notice Checks if the account should be allowed to transfer tokens in the given market\n * @param cToken The market to verify the transfer against\n * @param src The account which sources the tokens\n * @param dst The account which receives the tokens\n * @param transferTokens The number of cTokens to transfer\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\n */\n function transferAllowed(\n address cToken,\n address src,\n address dst,\n uint256 transferTokens\n ) external returns (uint256);\n\n /**\n * @notice Validates transfer and reverts on rejection. May emit logs.\n * @param cToken Asset being transferred\n * @param src The account which sources the tokens\n * @param dst The account which receives the tokens\n * @param transferTokens The number of cTokens to transfer\n */\n function transferVerify(\n address cToken,\n address src,\n address dst,\n uint256 transferTokens\n ) external;\n\n /**\n * @notice Claim all the comp accrued by holder in all markets\n * @param holder The address to claim COMP for\n */\n function claimComp(address holder) external;\n\n /**\n * @notice Claim all the comp accrued by holder in the specified markets\n * @param holder The address to claim COMP for\n * @param cTokens The list of markets to claim COMP in\n */\n function claimComp(address holder, address[] calldata cTokens) external;\n\n /**\n * @notice Claim all comp accrued by the holders\n * @param holders The addresses to claim COMP for\n * @param cTokens The list of markets to claim COMP in\n * @param borrowers Whether or not to claim COMP earned by borrowing\n * @param suppliers Whether or not to claim COMP earned by supplying\n */\n function claimComp(\n address[] calldata holders,\n address[] calldata cTokens,\n bool borrowers,\n bool suppliers\n ) external;\n\n /*** Liquidity/Liquidation Calculations ***/\n /**\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\n * @param cTokenBorrowed The address of the borrowed cToken\n * @param cTokenCollateral The address of the collateral cToken\n * @param repayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\n */\n function liquidateCalculateSeizeTokens(\n address cTokenBorrowed,\n address cTokenCollateral,\n uint256 repayAmount\n ) external view returns (uint256, uint256);\n\n /**\n * @notice Return the address of the COMP token\n * @return The address of COMP\n */\n function getCompAddress() external view returns (address);\n}\n" + }, + "@openzeppelin/contracts/utils/math/SafeCast.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\n * checks.\n *\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\n * easily result in undesired exploitation or bugs, since developers usually\n * assume that overflows raise errors. `SafeCast` restores this intuition by\n * reverting the transaction when such an operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n *\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\n * all math on `uint256` and `int256` and then downcasting.\n */\nlibrary SafeCast {\n /**\n * @dev Returns the downcasted uint128 from uint256, reverting on\n * overflow (when the input is greater than largest uint128).\n *\n * Counterpart to Solidity's `uint128` operator.\n *\n * Requirements:\n *\n * - input must fit into 128 bits\n */\n function toUint128(uint256 value) internal pure returns (uint128) {\n require(value < 2**128, \"SafeCast: value doesn\\'t fit in 128 bits\");\n return uint128(value);\n }\n\n /**\n * @dev Returns the downcasted uint64 from uint256, reverting on\n * overflow (when the input is greater than largest uint64).\n *\n * Counterpart to Solidity's `uint64` operator.\n *\n * Requirements:\n *\n * - input must fit into 64 bits\n */\n function toUint64(uint256 value) internal pure returns (uint64) {\n require(value < 2**64, \"SafeCast: value doesn\\'t fit in 64 bits\");\n return uint64(value);\n }\n\n /**\n * @dev Returns the downcasted uint32 from uint256, reverting on\n * overflow (when the input is greater than largest uint32).\n *\n * Counterpart to Solidity's `uint32` operator.\n *\n * Requirements:\n *\n * - input must fit into 32 bits\n */\n function toUint32(uint256 value) internal pure returns (uint32) {\n require(value < 2**32, \"SafeCast: value doesn\\'t fit in 32 bits\");\n return uint32(value);\n }\n\n /**\n * @dev Returns the downcasted uint16 from uint256, reverting on\n * overflow (when the input is greater than largest uint16).\n *\n * Counterpart to Solidity's `uint16` operator.\n *\n * Requirements:\n *\n * - input must fit into 16 bits\n */\n function toUint16(uint256 value) internal pure returns (uint16) {\n require(value < 2**16, \"SafeCast: value doesn\\'t fit in 16 bits\");\n return uint16(value);\n }\n\n /**\n * @dev Returns the downcasted uint8 from uint256, reverting on\n * overflow (when the input is greater than largest uint8).\n *\n * Counterpart to Solidity's `uint8` operator.\n *\n * Requirements:\n *\n * - input must fit into 8 bits.\n */\n function toUint8(uint256 value) internal pure returns (uint8) {\n require(value < 2**8, \"SafeCast: value doesn\\'t fit in 8 bits\");\n return uint8(value);\n }\n\n /**\n * @dev Converts a signed int256 into an unsigned uint256.\n *\n * Requirements:\n *\n * - input must be greater than or equal to 0.\n */\n function toUint256(int256 value) internal pure returns (uint256) {\n require(value >= 0, \"SafeCast: value must be positive\");\n return uint256(value);\n }\n\n /**\n * @dev Returns the downcasted int128 from int256, reverting on\n * overflow (when the input is less than smallest int128 or\n * greater than largest int128).\n *\n * Counterpart to Solidity's `int128` operator.\n *\n * Requirements:\n *\n * - input must fit into 128 bits\n *\n * _Available since v3.1._\n */\n function toInt128(int256 value) internal pure returns (int128) {\n require(value >= -2**127 && value < 2**127, \"SafeCast: value doesn\\'t fit in 128 bits\");\n return int128(value);\n }\n\n /**\n * @dev Returns the downcasted int64 from int256, reverting on\n * overflow (when the input is less than smallest int64 or\n * greater than largest int64).\n *\n * Counterpart to Solidity's `int64` operator.\n *\n * Requirements:\n *\n * - input must fit into 64 bits\n *\n * _Available since v3.1._\n */\n function toInt64(int256 value) internal pure returns (int64) {\n require(value >= -2**63 && value < 2**63, \"SafeCast: value doesn\\'t fit in 64 bits\");\n return int64(value);\n }\n\n /**\n * @dev Returns the downcasted int32 from int256, reverting on\n * overflow (when the input is less than smallest int32 or\n * greater than largest int32).\n *\n * Counterpart to Solidity's `int32` operator.\n *\n * Requirements:\n *\n * - input must fit into 32 bits\n *\n * _Available since v3.1._\n */\n function toInt32(int256 value) internal pure returns (int32) {\n require(value >= -2**31 && value < 2**31, \"SafeCast: value doesn\\'t fit in 32 bits\");\n return int32(value);\n }\n\n /**\n * @dev Returns the downcasted int16 from int256, reverting on\n * overflow (when the input is less than smallest int16 or\n * greater than largest int16).\n *\n * Counterpart to Solidity's `int16` operator.\n *\n * Requirements:\n *\n * - input must fit into 16 bits\n *\n * _Available since v3.1._\n */\n function toInt16(int256 value) internal pure returns (int16) {\n require(value >= -2**15 && value < 2**15, \"SafeCast: value doesn\\'t fit in 16 bits\");\n return int16(value);\n }\n\n /**\n * @dev Returns the downcasted int8 from int256, reverting on\n * overflow (when the input is less than smallest int8 or\n * greater than largest int8).\n *\n * Counterpart to Solidity's `int8` operator.\n *\n * Requirements:\n *\n * - input must fit into 8 bits.\n *\n * _Available since v3.1._\n */\n function toInt8(int256 value) internal pure returns (int8) {\n require(value >= -2**7 && value < 2**7, \"SafeCast: value doesn\\'t fit in 8 bits\");\n return int8(value);\n }\n\n /**\n * @dev Converts an unsigned uint256 into a signed int256.\n *\n * Requirements:\n *\n * - input must be less than or equal to maxInt256.\n */\n function toInt256(uint256 value) internal pure returns (int256) {\n require(value < 2**255, \"SafeCast: value doesn't fit in an int256\");\n return int256(value);\n }\n}\n" + }, + "contracts/price-aggregator/chainlink/ChainlinkLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\n// Storage\nimport {\n PriceAggStorageLib,\n ChainlinkAggStorage\n} from \"../../storage/price-aggregator.sol\";\n\nlibrary ChainlinkLib {\n function s() internal view returns (ChainlinkAggStorage storage) {\n return PriceAggStorageLib.store().chainlink;\n }\n\n /**\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\n * @param src Source token address.\n * @param dst Destination token address.\n * @return aggregator The Chainlink Aggregator address.\n * @return found whether or not the ChainlinkAggregator exists.\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\n */\n function aggregatorFor(address src, address dst)\n internal\n view\n returns (\n address aggregator,\n bool found,\n bool inverse\n )\n {\n aggregator = s().aggregators[src][dst];\n if (aggregator != address(0)) {\n found = true;\n } else {\n aggregator = s().aggregators[dst][src];\n if (aggregator != address(0)) {\n found = true;\n inverse = true;\n }\n }\n }\n\n /**\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\n * @param token Token address to check if is supported.\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\n */\n function isTokenSupported(address token)\n internal\n view\n returns (bool isSupported_)\n {\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\n }\n}\n" + }, + "contracts/shared/libraries/CompoundLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Interfaces\nimport { ICErc20 } from \"../interfaces/ICErc20.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../storage/app.sol\";\n\n/**\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\n *\n * @author develop@teller.finance\n */\nlibrary CompoundLib {\n /**\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\n */\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\n\n function exchangeRate(address cToken) internal view returns (uint256) {\n return ICErc20(cToken).exchangeRateStored();\n }\n\n /**\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\n * @param cToken Address of the Compound token.\n * @param cTokenAmount Amount of the Compound asset.\n * @return value of the Compound token amount in underlying tokens.\n */\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\n internal\n view\n returns (uint256)\n {\n return\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\n EXCHANGE_RATE_SCALE;\n }\n\n /**\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\n * @param cToken Address of the Compound token.\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\n * @return value of the underlying amount in Compound tokens.\n */\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\n internal\n view\n returns (uint256)\n {\n return\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\n ICErc20(cToken).exchangeRateStored();\n }\n\n function isCompoundToken(address token) internal view returns (bool) {\n return AppStorageLib.store().cTokenRegistry[token];\n }\n\n /**\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\n * @dev CETH is the only Compound token that does not support the {underlying} function.\n * @param cToken address of the compound token\n * @return address of the underlying cToken\n */\n function getUnderlying(address cToken) internal view returns (address) {\n (bool success, bytes memory data) =\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\n if (success) {\n return abi.decode(data, (address));\n }\n\n return AppStorageLib.store().assetAddresses[\"WETH\"];\n }\n}\n" + }, + "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./AggregatorInterface.sol\";\nimport \"./AggregatorV3Interface.sol\";\n\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\n{\n}\n" + }, + "@openzeppelin/contracts/token/ERC20/ERC20.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IERC20.sol\";\nimport \"./extensions/IERC20Metadata.sol\";\nimport \"../../utils/Context.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * We have followed general OpenZeppelin guidelines: functions revert instead\n * of returning `false` on failure. This behavior is nonetheless conventional\n * and does not conflict with the expectations of ERC20 applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20 is Context, IERC20, IERC20Metadata {\n mapping (address => uint256) private _balances;\n\n mapping (address => mapping (address => uint256)) private _allowances;\n\n uint256 private _totalSupply;\n\n string private _name;\n string private _symbol;\n\n /**\n * @dev Sets the values for {name} and {symbol}.\n *\n * The defaut value of {decimals} is 18. To select a different value for\n * {decimals} you should overload it.\n *\n * All two of these values are immutable: they can only be set once during\n * construction.\n */\n constructor (string memory name_, string memory symbol_) {\n _name = name_;\n _symbol = symbol_;\n }\n\n /**\n * @dev Returns the name of the token.\n */\n function name() public view virtual override returns (string memory) {\n return _name;\n }\n\n /**\n * @dev Returns the symbol of the token, usually a shorter version of the\n * name.\n */\n function symbol() public view virtual override returns (string memory) {\n return _symbol;\n }\n\n /**\n * @dev Returns the number of decimals used to get its user representation.\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\n *\n * Tokens usually opt for a value of 18, imitating the relationship between\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\n * overridden;\n *\n * NOTE: This information is only used for _display_ purposes: it in\n * no way affects any of the arithmetic of the contract, including\n * {IERC20-balanceOf} and {IERC20-transfer}.\n */\n function decimals() public view virtual override returns (uint8) {\n return 18;\n }\n\n /**\n * @dev See {IERC20-totalSupply}.\n */\n function totalSupply() public view virtual override returns (uint256) {\n return _totalSupply;\n }\n\n /**\n * @dev See {IERC20-balanceOf}.\n */\n function balanceOf(address account) public view virtual override returns (uint256) {\n return _balances[account];\n }\n\n /**\n * @dev See {IERC20-transfer}.\n *\n * Requirements:\n *\n * - `recipient` cannot be the zero address.\n * - the caller must have a balance of at least `amount`.\n */\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\n _transfer(_msgSender(), recipient, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-allowance}.\n */\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\n return _allowances[owner][spender];\n }\n\n /**\n * @dev See {IERC20-approve}.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\n _approve(_msgSender(), spender, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-transferFrom}.\n *\n * Emits an {Approval} event indicating the updated allowance. This is not\n * required by the EIP. See the note at the beginning of {ERC20}.\n *\n * Requirements:\n *\n * - `sender` and `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n * - the caller must have allowance for ``sender``'s tokens of at least\n * `amount`.\n */\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\n _transfer(sender, recipient, amount);\n\n uint256 currentAllowance = _allowances[sender][_msgSender()];\n require(currentAllowance >= amount, \"ERC20: transfer amount exceeds allowance\");\n _approve(sender, _msgSender(), currentAllowance - amount);\n\n return true;\n }\n\n /**\n * @dev Atomically increases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\n return true;\n }\n\n /**\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `spender` must have allowance for the caller of at least\n * `subtractedValue`.\n */\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n uint256 currentAllowance = _allowances[_msgSender()][spender];\n require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\n\n return true;\n }\n\n /**\n * @dev Moves tokens `amount` from `sender` to `recipient`.\n *\n * This is internal function is equivalent to {transfer}, and can be used to\n * e.g. implement automatic token fees, slashing mechanisms, etc.\n *\n * Emits a {Transfer} event.\n *\n * Requirements:\n *\n * - `sender` cannot be the zero address.\n * - `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n */\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\n require(sender != address(0), \"ERC20: transfer from the zero address\");\n require(recipient != address(0), \"ERC20: transfer to the zero address\");\n\n _beforeTokenTransfer(sender, recipient, amount);\n\n uint256 senderBalance = _balances[sender];\n require(senderBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n _balances[sender] = senderBalance - amount;\n _balances[recipient] += amount;\n\n emit Transfer(sender, recipient, amount);\n }\n\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n * the total supply.\n *\n * Emits a {Transfer} event with `from` set to the zero address.\n *\n * Requirements:\n *\n * - `to` cannot be the zero address.\n */\n function _mint(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: mint to the zero address\");\n\n _beforeTokenTransfer(address(0), account, amount);\n\n _totalSupply += amount;\n _balances[account] += amount;\n emit Transfer(address(0), account, amount);\n }\n\n /**\n * @dev Destroys `amount` tokens from `account`, reducing the\n * total supply.\n *\n * Emits a {Transfer} event with `to` set to the zero address.\n *\n * Requirements:\n *\n * - `account` cannot be the zero address.\n * - `account` must have at least `amount` tokens.\n */\n function _burn(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: burn from the zero address\");\n\n _beforeTokenTransfer(account, address(0), amount);\n\n uint256 accountBalance = _balances[account];\n require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n _balances[account] = accountBalance - amount;\n _totalSupply -= amount;\n\n emit Transfer(account, address(0), amount);\n }\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n *\n * This internal function is equivalent to `approve`, and can be used to\n * e.g. set automatic allowances for certain subsystems, etc.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `owner` cannot be the zero address.\n * - `spender` cannot be the zero address.\n */\n function _approve(address owner, address spender, uint256 amount) internal virtual {\n require(owner != address(0), \"ERC20: approve from the zero address\");\n require(spender != address(0), \"ERC20: approve to the zero address\");\n\n _allowances[owner][spender] = amount;\n emit Approval(owner, spender, amount);\n }\n\n /**\n * @dev Hook that is called before any transfer of tokens. This includes\n * minting and burning.\n *\n * Calling conditions:\n *\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n * will be to transferred to `to`.\n * - when `from` is zero, `amount` tokens will be minted for `to`.\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n * - `from` and `to` are never both zero.\n *\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n */\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\n}\n" + }, + "contracts/storage/price-aggregator.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\nstruct ChainlinkAggStorage {\n // Maps source token => destination token => Chainlink Aggregator\n mapping(address => mapping(address => address)) aggregators;\n // Maps token address to number of supported Chainlink pairs\n mapping(address => uint256) pairCount;\n // Stores set of token addresses supported by Chainlink\n EnumerableSet.AddressSet supportedTokens;\n}\n\nstruct PriceAggStorage {\n ChainlinkAggStorage chainlink;\n}\n\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\n \"teller.price.aggregator.storage\"\n);\n\nlibrary PriceAggStorageLib {\n function store() internal pure returns (PriceAggStorage storage s) {\n bytes32 pos = PRICE_AGG_STORAGE_POS;\n assembly {\n s.slot := pos\n }\n }\n}\n" + }, + "@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface AggregatorInterface {\n function latestAnswer()\n external\n view\n returns (\n int256\n );\n \n function latestTimestamp()\n external\n view\n returns (\n uint256\n );\n\n function latestRound()\n external\n view\n returns (\n uint256\n );\n\n function getAnswer(\n uint256 roundId\n )\n external\n view\n returns (\n int256\n );\n\n function getTimestamp(\n uint256 roundId\n )\n external\n view\n returns (\n uint256\n );\n\n event AnswerUpdated(\n int256 indexed current,\n uint256 indexed roundId,\n uint256 updatedAt\n );\n\n event NewRound(\n uint256 indexed roundId,\n address indexed startedBy,\n uint256 startedAt\n );\n}\n" + }, + "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface AggregatorV3Interface {\n\n function decimals()\n external\n view\n returns (\n uint8\n );\n\n function description()\n external\n view\n returns (\n string memory\n );\n\n function version()\n external\n view\n returns (\n uint256\n );\n\n // getRoundData and latestRoundData should both raise \"No data present\"\n // if they do not have data to report, instead of returning unset values\n // which could be misinterpreted as actual reported values.\n function getRoundData(\n uint80 _roundId\n )\n external\n view\n returns (\n uint80 roundId,\n int256 answer,\n uint256 startedAt,\n uint256 updatedAt,\n uint80 answeredInRound\n );\n\n function latestRoundData()\n external\n view\n returns (\n uint80 roundId,\n int256 answer,\n uint256 startedAt,\n uint256 updatedAt,\n uint80 answeredInRound\n );\n\n}\n" + }, + "@openzeppelin/contracts/token/ERC20/IERC20.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address recipient, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\n\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n" + }, + "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n /**\n * @dev Returns the name of the token.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the symbol of the token.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the decimals places of the token.\n */\n function decimals() external view returns (uint8);\n}\n" + }, + "contracts/settings/pausable/PausableMods.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AppStorageLib } from \"../../storage/app.sol\";\n\nabstract contract PausableMods {\n /**\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\n * @param id id of the facet to check if is paused.\n * @param state Boolean that the protocol AND facet should be in.\n */\n modifier paused(bytes32 id, bool state) {\n require(\n __isPaused(\"\") == state && __isPaused(id) == state,\n __pausedMessage(state)\n );\n _;\n }\n\n /**\n * @dev Checks if the given id is paused.\n * @param id Encoded id of the facet to check if is paused.\n * @return the bool to tell us if the facet is paused (true) or not (false)\n */\n function __isPaused(bytes32 id) private view returns (bool) {\n return AppStorageLib.store().paused[id];\n }\n\n /**\n * @dev Gets the message that should be reverted with given a state it should be in.\n * @param state Boolean that an id should be in.\n * @return a message stating whether the facet is paused or not\n */\n function __pausedMessage(bool state) private pure returns (string memory) {\n return state ? \"Pausable: not paused\" : \"Pausable: paused\";\n }\n}\n" + }, + "contracts/contexts2/access-control/reentry/ReentryMods.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlStorageLib, AccessControlStorage } from \"../storage.sol\";\n\nabstract contract ReentryMods {\n modifier nonReentry(bytes32 id) {\n AccessControlStorage storage s = AccessControlStorageLib.store();\n require(!s.entered[id], \"AccessControl: reentered\");\n s.entered[id] = true;\n _;\n s.entered[id] = false;\n }\n}\n" + }, + "contracts/lending/ttoken/ITToken.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport {\n ERC20Upgradeable\n} from \"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\";\nimport { ERC20 } from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\nimport {\n RolesFacet\n} from \"../../contexts2/access-control/roles/RolesFacet.sol\";\n\n/**\n * @notice This contract acts as an interface for the Teller token (TToken).\n *\n * @author develop@teller.finance\n */\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\n /**\n * @notice This event is emitted when a user deposits tokens into the pool.\n */\n event Mint(\n address indexed sender,\n uint256 tTokenAmount,\n uint256 underlyingAmount\n );\n\n /**\n * @notice This event is emitted when a user withdraws tokens from the pool.\n */\n event Redeem(\n address indexed sender,\n uint256 tTokenAmount,\n uint256 underlyingAmount\n );\n\n /**\n * @notice The token that is the underlying assets for this Teller token.\n * @return ERC20 token\n */\n function underlying() external view virtual returns (ERC20);\n\n /**\n * @notice The balance of an {account} denoted in underlying value.\n * @param account Address to calculate the underlying balance.\n * @return balance_ the balance of the account\n */\n function balanceOfUnderlying(address account)\n external\n virtual\n returns (uint256 balance_);\n\n /**\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\n * @return rate_ The current exchange rate.\n */\n function exchangeRate() external virtual returns (uint256 rate_);\n\n /**\n * @notice It calculates the total supply of the underlying asset.\n * @return totalSupply_ the total supply denoted in the underlying asset.\n */\n function totalUnderlyingSupply()\n external\n virtual\n returns (uint256 totalSupply_);\n\n /**\n * @notice It calculates the market state values across a given market.\n * @notice Returns values that represent the global state across the market.\n * @return totalSupplied Total amount of the underlying asset supplied.\n * @return totalBorrowed Total amount borrowed through loans.\n * @return totalRepaid The total amount repaid till the current timestamp.\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\n * @return totalOnLoan Total amount currently deployed in loans.\n */\n function getMarketState()\n external\n virtual\n returns (\n uint256 totalSupplied,\n uint256 totalBorrowed,\n uint256 totalRepaid,\n uint256 totalInterestRepaid,\n uint256 totalOnLoan\n );\n\n /**\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\n * @return tvl_ The value locked in the pool.\n *\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\n */\n function currentTVL() external virtual returns (uint256 tvl_);\n\n /**\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\n * @param newLoanAmount the new loan amount to consider the StD ratio.\n * @return ratio_ Whether debt ratio for lending pool is valid.\n */\n function debtRatioFor(uint256 newLoanAmount)\n external\n virtual\n returns (uint16 ratio_);\n \n\n /**\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\n * @param recipient The account to send the funds to.\n * @param amount Funds requested to fulfill the loan.\n */\n function fundLoan(address recipient, uint256 amount) external virtual;\n\n /**\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\n * @param interestAmount Interest value paid into the pool from a loan.\n */\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\n\n /**\n * @notice Increase account supply of specified token amount.\n * @param amount The amount of underlying tokens to use to mint.\n * @return mintAmount_ the amount minted of the specified token\n */\n function mint(uint256 amount)\n external\n virtual\n returns (uint256 mintAmount_);\n\n /**\n * @notice Redeem supplied Teller token underlying value.\n * @param amount The amount of Teller tokens to redeem.\n */\n function redeem(uint256 amount) external virtual;\n\n /**\n * @notice Redeem supplied underlying value.\n * @param amount The amount of underlying tokens to redeem.\n */\n function redeemUnderlying(uint256 amount) external virtual;\n\n /**\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\n *\n * See {TTokenStrategy}.\n */\n function rebalance() external virtual;\n\n /**\n * @notice Sets a new strategy to use for balancing funds.\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\n * @param initData Optional data to initialize the strategy.\n *\n * Requirements:\n * - Sender must have ADMIN role\n */\n function setStrategy(address strategy, bytes calldata initData)\n external\n virtual;\n\n /**\n * @notice Gets the strategy used for balancing funds.\n * @return address of the strategy contract\n */\n function getStrategy() external view virtual returns (address);\n\n /**\n * @notice Sets the restricted state of the platform.\n * @param state boolean value that resembles the platform's state\n */\n function restrict(bool state) external virtual;\n\n /**\n * @notice it initializes the Teller Token\n * @param admin address of the admin to the respective Teller Token\n * @param underlying address of the ERC20 token\n */\n function initialize(address admin, address underlying) external virtual;\n}\n" + }, + "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\nimport \"../../../utils/Address.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n using Address for address;\n\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n }\n\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\n }\n\n /**\n * @dev Deprecated. This function has issues similar to the ones found in\n * {IERC20-approve}, and its usage is discouraged.\n *\n * Whenever possible, use {safeIncreaseAllowance} and\n * {safeDecreaseAllowance} instead.\n */\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\n // safeApprove should only be called when setting an initial allowance,\n // or when resetting it to zero. To increase and decrease it, use\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\n // solhint-disable-next-line max-line-length\n require((value == 0) || (token.allowance(address(this), spender) == 0),\n \"SafeERC20: approve from non-zero to non-zero allowance\"\n );\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\n }\n\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n uint256 newAllowance = token.allowance(address(this), spender) + value;\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n }\n\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n unchecked {\n uint256 oldAllowance = token.allowance(address(this), spender);\n require(oldAllowance >= value, \"SafeERC20: decreased allowance below zero\");\n uint256 newAllowance = oldAllowance - value;\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n }\n }\n\n /**\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n * on the return value: the return value is optional (but if data is returned, it must not be false).\n * @param token The token targeted by the call.\n * @param data The call data (encoded using abi.encode or one of its variants).\n */\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\n // the target address contains contract code and also asserts for success in the low-level call.\n\n bytes memory returndata = address(token).functionCall(data, \"SafeERC20: low-level call failed\");\n if (returndata.length > 0) { // Return data is optional\n // solhint-disable-next-line max-line-length\n require(abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n }\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20Upgradeable.sol\";\nimport \"../../../utils/AddressUpgradeable.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20Upgradeable {\n using AddressUpgradeable for address;\n\n function safeTransfer(IERC20Upgradeable token, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n }\n\n function safeTransferFrom(IERC20Upgradeable token, address from, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\n }\n\n /**\n * @dev Deprecated. This function has issues similar to the ones found in\n * {IERC20-approve}, and its usage is discouraged.\n *\n * Whenever possible, use {safeIncreaseAllowance} and\n * {safeDecreaseAllowance} instead.\n */\n function safeApprove(IERC20Upgradeable token, address spender, uint256 value) internal {\n // safeApprove should only be called when setting an initial allowance,\n // or when resetting it to zero. To increase and decrease it, use\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\n // solhint-disable-next-line max-line-length\n require((value == 0) || (token.allowance(address(this), spender) == 0),\n \"SafeERC20: approve from non-zero to non-zero allowance\"\n );\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\n }\n\n function safeIncreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\n uint256 newAllowance = token.allowance(address(this), spender) + value;\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n }\n\n function safeDecreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\n unchecked {\n uint256 oldAllowance = token.allowance(address(this), spender);\n require(oldAllowance >= value, \"SafeERC20: decreased allowance below zero\");\n uint256 newAllowance = oldAllowance - value;\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n }\n }\n\n /**\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n * on the return value: the return value is optional (but if data is returned, it must not be false).\n * @param token The token targeted by the call.\n * @param data The call data (encoded using abi.encode or one of its variants).\n */\n function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\n // the target address contains contract code and also asserts for success in the low-level call.\n\n bytes memory returndata = address(token).functionCall(data, \"SafeERC20: low-level call failed\");\n if (returndata.length > 0) { // Return data is optional\n // solhint-disable-next-line max-line-length\n require(abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n }\n }\n}\n" + }, + "contracts/lending/libraries/LendingLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport { NumbersLib } from \"../../shared/libraries/NumbersLib.sol\";\n\n// Interfaces\nimport { ITToken } from \"../ttoken/ITToken.sol\";\n\n// Storage\nimport { MarketStorageLib, MarketStorage } from \"../../storage/market.sol\";\n\nlibrary LendingLib {\n bytes32 internal constant ID = keccak256(\"LENDING\");\n\n function s() internal pure returns (MarketStorage storage) {\n return MarketStorageLib.store();\n }\n\n function tToken(address asset) internal view returns (ITToken tToken_) {\n tToken_ = s().tTokens[asset];\n }\n}" + }, + "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IERC20Upgradeable.sol\";\nimport \"./extensions/IERC20MetadataUpgradeable.sol\";\nimport \"../../utils/ContextUpgradeable.sol\";\nimport \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * We have followed general OpenZeppelin guidelines: functions revert instead\n * of returning `false` on failure. This behavior is nonetheless conventional\n * and does not conflict with the expectations of ERC20 applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\n mapping (address => uint256) private _balances;\n\n mapping (address => mapping (address => uint256)) private _allowances;\n\n uint256 private _totalSupply;\n\n string private _name;\n string private _symbol;\n\n /**\n * @dev Sets the values for {name} and {symbol}.\n *\n * The defaut value of {decimals} is 18. To select a different value for\n * {decimals} you should overload it.\n *\n * All two of these values are immutable: they can only be set once during\n * construction.\n */\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\n __Context_init_unchained();\n __ERC20_init_unchained(name_, symbol_);\n }\n\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\n _name = name_;\n _symbol = symbol_;\n }\n\n /**\n * @dev Returns the name of the token.\n */\n function name() public view virtual override returns (string memory) {\n return _name;\n }\n\n /**\n * @dev Returns the symbol of the token, usually a shorter version of the\n * name.\n */\n function symbol() public view virtual override returns (string memory) {\n return _symbol;\n }\n\n /**\n * @dev Returns the number of decimals used to get its user representation.\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\n *\n * Tokens usually opt for a value of 18, imitating the relationship between\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\n * overridden;\n *\n * NOTE: This information is only used for _display_ purposes: it in\n * no way affects any of the arithmetic of the contract, including\n * {IERC20-balanceOf} and {IERC20-transfer}.\n */\n function decimals() public view virtual override returns (uint8) {\n return 18;\n }\n\n /**\n * @dev See {IERC20-totalSupply}.\n */\n function totalSupply() public view virtual override returns (uint256) {\n return _totalSupply;\n }\n\n /**\n * @dev See {IERC20-balanceOf}.\n */\n function balanceOf(address account) public view virtual override returns (uint256) {\n return _balances[account];\n }\n\n /**\n * @dev See {IERC20-transfer}.\n *\n * Requirements:\n *\n * - `recipient` cannot be the zero address.\n * - the caller must have a balance of at least `amount`.\n */\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\n _transfer(_msgSender(), recipient, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-allowance}.\n */\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\n return _allowances[owner][spender];\n }\n\n /**\n * @dev See {IERC20-approve}.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\n _approve(_msgSender(), spender, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-transferFrom}.\n *\n * Emits an {Approval} event indicating the updated allowance. This is not\n * required by the EIP. See the note at the beginning of {ERC20}.\n *\n * Requirements:\n *\n * - `sender` and `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n * - the caller must have allowance for ``sender``'s tokens of at least\n * `amount`.\n */\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\n _transfer(sender, recipient, amount);\n\n uint256 currentAllowance = _allowances[sender][_msgSender()];\n require(currentAllowance >= amount, \"ERC20: transfer amount exceeds allowance\");\n _approve(sender, _msgSender(), currentAllowance - amount);\n\n return true;\n }\n\n /**\n * @dev Atomically increases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\n return true;\n }\n\n /**\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `spender` must have allowance for the caller of at least\n * `subtractedValue`.\n */\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n uint256 currentAllowance = _allowances[_msgSender()][spender];\n require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\n\n return true;\n }\n\n /**\n * @dev Moves tokens `amount` from `sender` to `recipient`.\n *\n * This is internal function is equivalent to {transfer}, and can be used to\n * e.g. implement automatic token fees, slashing mechanisms, etc.\n *\n * Emits a {Transfer} event.\n *\n * Requirements:\n *\n * - `sender` cannot be the zero address.\n * - `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n */\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\n require(sender != address(0), \"ERC20: transfer from the zero address\");\n require(recipient != address(0), \"ERC20: transfer to the zero address\");\n\n _beforeTokenTransfer(sender, recipient, amount);\n\n uint256 senderBalance = _balances[sender];\n require(senderBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n _balances[sender] = senderBalance - amount;\n _balances[recipient] += amount;\n\n emit Transfer(sender, recipient, amount);\n }\n\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n * the total supply.\n *\n * Emits a {Transfer} event with `from` set to the zero address.\n *\n * Requirements:\n *\n * - `to` cannot be the zero address.\n */\n function _mint(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: mint to the zero address\");\n\n _beforeTokenTransfer(address(0), account, amount);\n\n _totalSupply += amount;\n _balances[account] += amount;\n emit Transfer(address(0), account, amount);\n }\n\n /**\n * @dev Destroys `amount` tokens from `account`, reducing the\n * total supply.\n *\n * Emits a {Transfer} event with `to` set to the zero address.\n *\n * Requirements:\n *\n * - `account` cannot be the zero address.\n * - `account` must have at least `amount` tokens.\n */\n function _burn(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: burn from the zero address\");\n\n _beforeTokenTransfer(account, address(0), amount);\n\n uint256 accountBalance = _balances[account];\n require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n _balances[account] = accountBalance - amount;\n _totalSupply -= amount;\n\n emit Transfer(account, address(0), amount);\n }\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n *\n * This internal function is equivalent to `approve`, and can be used to\n * e.g. set automatic allowances for certain subsystems, etc.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `owner` cannot be the zero address.\n * - `spender` cannot be the zero address.\n */\n function _approve(address owner, address spender, uint256 amount) internal virtual {\n require(owner != address(0), \"ERC20: approve from the zero address\");\n require(spender != address(0), \"ERC20: approve to the zero address\");\n\n _allowances[owner][spender] = amount;\n emit Approval(owner, spender, amount);\n }\n\n /**\n * @dev Hook that is called before any transfer of tokens. This includes\n * minting and burning.\n *\n * Calling conditions:\n *\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n * will be to transferred to `to`.\n * - when `from` is zero, `amount` tokens will be minted for `to`.\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n * - `from` and `to` are never both zero.\n *\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n */\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\n uint256[45] private __gap;\n}\n" + }, + "contracts/contexts2/access-control/roles/RolesFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { RolesMods } from \"./RolesMods.sol\";\nimport { RolesLib } from \"./RolesLib.sol\";\nimport { ADMIN } from \"../../../shared/roles.sol\";\n\ncontract RolesFacet is RolesMods {\n /**\n * @notice Checks if an account has a specific role.\n * @param role Encoding of the role to check.\n * @param account Address to check the {role} for.\n */\n function hasRole(bytes32 role, address account)\n external\n view\n returns (bool)\n {\n return RolesLib.hasRole(role, account);\n }\n\n /**\n * @notice Grants an account a new role.\n * @param role Encoding of the role to give.\n * @param account Address to give the {role} to.\n *\n * Requirements:\n * - Sender must be role admin.\n */\n function grantRole(bytes32 role, address account)\n external\n authorized(ADMIN, msg.sender)\n {\n RolesLib.grantRole(role, account);\n }\n\n /**\n * @notice Removes a role from an account.\n * @param role Encoding of the role to remove.\n * @param account Address to remove the {role} from.\n *\n * Requirements:\n * - Sender must be role admin.\n */\n function revokeRole(bytes32 role, address account)\n external\n authorized(ADMIN, msg.sender)\n {\n RolesLib.revokeRole(role, account);\n }\n\n /**\n * @notice Removes a role from the sender.\n * @param role Encoding of the role to remove.\n */\n function renounceRole(bytes32 role) external {\n RolesLib.revokeRole(role, msg.sender);\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20Upgradeable {\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address recipient, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\n\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20Upgradeable.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\n /**\n * @dev Returns the name of the token.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the symbol of the token.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the decimals places of the token.\n */\n function decimals() external view returns (uint8);\n}\n" + }, + "contracts/shared/libraries/NumbersLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/**\n * @dev Utility library for uint256 numbers\n *\n * @author develop@teller.finance\n */\nlibrary NumbersLib {\n /**\n * @dev It represents 100% with 2 decimal places.\n */\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\n\n /**\n * @notice Returns a percentage value of a number.\n * @param self The number to get a percentage of.\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\n */\n function percent(uint256 self, uint16 percentage)\n internal\n pure\n returns (uint256)\n {\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\n }\n\n function percent(int256 self, uint256 percentage)\n internal\n pure\n returns (int256)\n {\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\n }\n\n /**\n * @notice it returns the absolute number of a specified parameter\n * @param self the number to be returned in it's absolute \n * @return the absolute number\n */\n function abs(int256 self) internal pure returns (uint256) {\n return self >= 0 ? uint256(self) : uint256(-1 * self);\n }\n\n /**\n * @notice Returns a ratio percentage of {num1} to {num2}.\n * @param num1 The number used to get the ratio for.\n * @param num2 The number used to get the ratio from.\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\n */\n function ratioOf(uint256 num1, uint256 num2)\n internal\n pure\n returns (uint16)\n {\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\n }\n}\n" + }, + "contracts/storage/market.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport { Counters } from \"@openzeppelin/contracts/utils/Counters.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\nimport \"../shared/libraries/NumbersList.sol\";\n\n// Interfaces\nimport { ILoansEscrow } from \"../escrow/escrow/ILoansEscrow.sol\";\nimport { ICollateralEscrow } from \"../market/collateral/ICollateralEscrow.sol\";\nimport { ITToken } from \"../lending/ttoken/ITToken.sol\";\n\n// DEPRECATED\nstruct LoanTerms {\n // Max size the loan max be taken out with\n uint256 maxLoanAmount;\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\n uint32 termsExpiry;\n}\n\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\n\nstruct Loan {\n // Account that owns the loan\n address payable borrower;\n // The asset lent out for the loan\n address lendingToken;\n // The token used as collateral for the loan\n address collateralToken;\n // The total amount of the loan size taken out\n uint256 borrowedAmount;\n // The id of the loan for internal tracking\n uint128 id;\n // How long in seconds until the loan must be repaid\n uint32 duration;\n // The timestamp at which the loan became active\n uint32 loanStartTime;\n // The interest rate given for repaying the loan\n uint16 interestRate;\n // Ratio used to determine amount of collateral required based on the collateral asset price\n uint16 collateralRatio;\n // The status of the loan\n LoanStatus status;\n}\n\nstruct LoanDebt {\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\n uint256 principalOwed;\n // The total interest owed by the borrower for the loan, reduces on loan repayments\n uint256 interestOwed;\n}\n\nstruct LoanRequest {\n LoanUserRequest request;\n LoanConsensusResponse[] responses;\n}\n\n/**\n * @notice Borrower request object to take out a loan\n * @param borrower The wallet address of the borrower\n * @param assetAddress The address of the asset for the requested loan\n * @param amount The amount of tokens requested by the borrower for the loan\n * @param requestNonce The nonce of the borrower wallet address required for authentication\n * @param duration The length of time in seconds that the loan has been requested for\n * @param requestTime The timestamp at which the loan was requested\n */\nstruct LoanUserRequest {\n address payable borrower;\n address assetAddress;\n uint256 amount;\n uint32 requestNonce;\n uint32 duration;\n uint32 requestTime;\n}\n\n/**\n * @notice Borrower response object to take out a loan\n * @param signer The wallet address of the signer validating the interest request of the lender\n * @param assetAddress The address of the asset for the requested loan\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\n * @param responseTime The timestamp at which the response was sent\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\n * @param signature The signature generated by the signer in the format of the above Signature struct\n */\nstruct LoanConsensusResponse {\n address signer;\n address assetAddress;\n uint256 maxLoanAmount;\n uint32 responseTime;\n uint16 interestRate;\n uint16 collateralRatio;\n Signature signature;\n}\n\n/**\n * @notice Represents a user signature\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\n */\nstruct Signature {\n uint8 v;\n bytes32 r;\n bytes32 s;\n}\n\nstruct MarketStorage {\n // Holds the index for the next loan ID\n Counters.Counter loanIDCounter;\n // Maps loanIDs to loan data\n mapping(uint256 => Loan) loans;\n // Maps loanID to loan debt (total owed left)\n mapping(uint256 => LoanDebt) loanDebt;\n // Maps loanID to loan terms\n mapping(uint256 => LoanTerms) _loanTerms; // DEPRECATED: DO NOT REMOVE\n // Maps loanIDs to escrow address to list of held tokens\n mapping(uint256 => ILoansEscrow) loanEscrows;\n // Maps loanIDs to list of tokens owned by a loan escrow\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\n mapping(address => ICollateralEscrow) collateralEscrows;\n // Maps accounts to owned loan IDs\n mapping(address => uint128[]) borrowerLoans;\n // Maps lending token to overall amount of interest collected from loans\n mapping(address => ITToken) tTokens;\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\n mapping(address => EnumerableSet.AddressSet) signers;\n // Maps lending token to list of allowed collateral tokens\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\n}\n\nbytes32 constant MARKET_STORAGE_POS = keccak256(\"teller.market.storage\");\n\nlibrary MarketStorageLib {\n function store() internal pure returns (MarketStorage storage s) {\n bytes32 pos = MARKET_STORAGE_POS;\n assembly {\n s.slot := pos\n }\n }\n}\n" + }, + "contracts/shared/libraries/NumbersList.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/utils/math/SafeMath.sol\";\nimport \"./NumbersLib.sol\";\n\n/**\n * @dev Utility library of inline functions on NumbersList.Values\n *\n * @author develop@teller.finance\n */\nlibrary NumbersList {\n using NumbersLib for uint256;\n\n // Holds values to calculate the threshold of a list of numbers\n struct Values {\n uint256 count; // The total number of numbers added\n uint256 max; // The maximum number that was added\n uint256 min; // The minimum number that was added\n uint256 sum; // The total sum of the numbers that were added\n }\n\n /**\n * @dev Add to the sum while keeping track of min and max values\n * @param self The Value this function was called on\n * @param newValue Number to increment sum by\n */\n function addValue(Values memory self, uint256 newValue) internal pure {\n if (self.max < newValue) {\n self.max = newValue;\n }\n if (self.min > newValue || self.count == 0) {\n self.min = newValue;\n }\n self.sum = self.sum + (newValue);\n self.count = self.count + 1;\n }\n\n /**\n * @param self The Value this function was called on\n * @return the number of times the sum has updated\n */\n function valuesCount(Values memory self) internal pure returns (uint256) {\n return self.count;\n }\n\n /**\n * @dev Checks if the sum has been changed\n * @param self The Value this function was called on\n * @return boolean\n */\n function isEmpty(Values memory self) internal pure returns (bool) {\n return valuesCount(self) == 0;\n }\n\n /**\n * @param self The Value this function was called on\n * @return the average number that was used to calculate the sum\n */\n function getAverage(Values memory self) internal pure returns (uint256) {\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\n }\n\n /**\n * @dev Checks if the min and max numbers are within the acceptable tolerance\n * @param self The Value this function was called on\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\n * @return boolean\n */\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\n internal\n pure\n returns (bool)\n {\n if (isEmpty(self)) {\n return false;\n }\n uint256 average = getAverage(self);\n uint256 toleranceAmount = average.percent(tolerancePercentage);\n\n uint256 minTolerance = average - toleranceAmount;\n if (self.min < minTolerance) {\n return false;\n }\n\n uint256 maxTolerance = average + toleranceAmount;\n if (self.max > maxTolerance) {\n return false;\n }\n return true;\n }\n}\n" + }, + "contracts/escrow/escrow/ILoansEscrow.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface ILoansEscrow {\n function init() external;\n\n /**\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\n * @param dappAddress address of the target contract address\n * @param dappData encoded abi of the function in our contract we want to call\n * @return the called data in bytes\n */\n function callDapp(address dappAddress, bytes calldata dappData)\n external\n returns (bytes memory);\n\n /**\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\n * @param token address of the respective ERC20 token to approve for the spender\n * @param spender address of the respective spender who is approved by the token contract\n */\n function setTokenAllowance(address token, address spender) external;\n\n /**\n * @notice it allows user to claim their escrow tokens\n * @dev only the owner (TellerDiamond) can make this call on behalf of the users\n * @param token address of the respective token contract to claim tokens from\n * @param to address where the tokens should be transferred to\n * @param amount uint256 amount of tokens to be claimed\n */\n function claimToken(\n address token,\n address to,\n uint256 amount\n ) external;\n}\n" + }, + "contracts/market/collateral/ICollateralEscrow.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface ICollateralEscrow {\n /**\n * @notice it initializes an escrow\n * @param tokenAddress the address of the collateral token to be stored\n * @param isWETH check if it's wrapped Ethereum\n */\n function init(address tokenAddress, bool isWETH) external;\n\n /**\n * @notice it deposits an amount of the respective collateral token into the escrow\n * @param loanID the ID of the loan\n * @param amount the amount of collateral tokens to be deposited\n */\n function deposit(uint256 loanID, uint256 amount) external payable;\n\n /**\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\n * @dev only the TellerDiamond can make this call on behalf of the borrower\n * @param loanID identifier of the loan\n * @param amount number of collateral tokens to send\n * @param receiver payable address to transfer money to\n */\n function withdraw(\n uint256 loanID,\n uint256 amount,\n address payable receiver\n ) external;\n\n /**\n * @notice it returns the supply of the respective loan\n * @param loanID the respective loan ID\n * @return supply_ the amount in collateral of the respective loan\n */\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\n\n /**\n * @notice it returns the total supply of the collateral token held by the contract\n * @return supply_ the total amount of collateral\n */\n function totalSupply() external view returns (uint256 supply_);\n}\n" + }, + "contracts/market/libraries/LibLoans.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport { LibEscrow } from \"../../escrow/libraries/LibEscrow.sol\";\nimport { NumbersLib } from \"../../shared/libraries/NumbersLib.sol\";\nimport {\n PlatformSettingsLib\n} from \"../../settings/platform/libraries/PlatformSettingsLib.sol\";\nimport { PriceAggLib } from \"../../price-aggregator/PriceAggLib.sol\";\n\n// Storage\nimport {\n MarketStorageLib,\n MarketStorage,\n Loan,\n LoanStatus,\n LoanDebt,\n LoanTerms\n} from \"../../storage/market.sol\";\n\nlibrary LibLoans {\n using NumbersLib for int256;\n using NumbersLib for uint256;\n\n bytes32 internal constant ID = keccak256(\"LOANS\");\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\n\n function s() internal pure returns (MarketStorage storage) {\n return MarketStorageLib.store();\n }\n\n /**\n * @notice it returns the loan\n * @param loanID the ID of the respective loan\n * @return l_ the loan \n */\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\n l_ = s().loans[loanID];\n }\n\n /**\n * @notice it returns the loan debt from a respective loan\n * @param loanID the ID of the respective loan\n * @return d_ the loan debt from a respective loan\n */\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\n d_ = s().loanDebt[loanID];\n }\n\n // DEPRECATED\n function terms(uint256 loanID)\n internal\n view\n returns (LoanTerms storage t_)\n {\n t_ = s()._loanTerms[loanID];\n }\n\n /**\n * @notice Returns the total amount owed for a specified loan.\n * @param loanID The loan ID to get the total amount owed.\n * @return owed_ uint256 The total owed amount.\n */\n function getTotalOwed(uint256 loanID)\n internal\n view\n returns (uint256 owed_)\n {\n if (loan(loanID).status == LoanStatus.Active) {\n owed_ = debt(loanID).principalOwed + (debt(loanID).interestOwed);\n }\n }\n\n /**\n * @notice Returns the amount of interest owed for a given loan and loan amount.\n * @param loanID The loan ID to get the owed interest.\n * @param amountBorrow The principal of the loan to take out.\n * @return uint256 The interest owed.\n */\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\n internal\n view\n returns (uint256)\n {\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\n }\n \n function getCollateralNeeded(uint256 loanID)\n internal\n view\n returns (uint256 _needed)\n {\n (, _needed, ) = getCollateralNeededInfo(loanID);\n }\n\n /**\n * @notice it returns the total collateral needed in lending tokens, in collateral tokens and in escrowed loan values\n * @param loanID the loanID to get the total collateral needed\n * @return neededInLendingTokens total collateral needed in lending tokens\n * @return neededInCollateralTokens total collateral needed in collateral tokens\n * @return escrowLoanValue total collateral needed in loan value\n */\n function getCollateralNeededInfo(uint256 loanID)\n internal\n view\n returns (\n uint256 neededInLendingTokens,\n uint256 neededInCollateralTokens,\n uint256 escrowLoanValue\n )\n {\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\n loanID\n );\n\n // check if needed lending tokens is zero. if true, then needed collateral tokens is zero. else,\n if (neededInLendingTokens == 0) {\n neededInCollateralTokens = 0;\n } else {\n neededInCollateralTokens = PriceAggLib.valueFor(\n loan(loanID).lendingToken,\n loan(loanID).collateralToken,\n neededInLendingTokens\n );\n }\n }\n\n /**\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\n * @param loanID The loan ID to get needed collateral info for.\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\n */\n function getCollateralNeededInTokens(uint256 loanID)\n internal\n view\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\n {\n if (loan(loanID).collateralRatio == 0) {\n return (0, 0);\n }\n\n /*\n The collateral to principal owed ratio is the sum of:\n * collateral buffer percent\n * loan interest rate\n * liquidation reward percent\n * X factor of additional collateral\n */\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\n if (loan(loanID).status == LoanStatus.TermsSet) {\n neededInLendingTokens = loan(loanID).borrowedAmount.percent(\n loan(loanID).collateralRatio\n );\n } else if (loan(loanID).status == LoanStatus.Active) {\n uint16 requiredRatio =\n loan(loanID).collateralRatio -\n getInterestRatio(loanID) -\n uint16(PlatformSettingsLib.getCollateralBufferValue());\n\n neededInLendingTokens =\n debt(loanID).principalOwed +\n debt(loanID).interestOwed;\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\n if (\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\n ) {\n neededInLendingTokens -= escrowLoanValue;\n }\n neededInLendingTokens = neededInLendingTokens.percent(\n requiredRatio\n );\n }\n }\n\n /**\n * @notice check if a loan can go to end of auction with a collateral ratio\n * @return bool checking if collateralRatio is >= the over collateralized buffer value\n */\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\n internal\n view\n returns (bool)\n {\n return\n collateralRatio >=\n PlatformSettingsLib.getOverCollateralizedBufferValue();\n }\n\n /**\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\n * @notice There is a minimum threshold of 1%.\n * @dev The interest rate is APY (annual percentage yield).\n * @param loanID The loan ID to get the interest rate for.\n */\n function getInterestRatio(uint256 loanID)\n internal\n view\n returns (uint16 ratio_)\n {\n ratio_ = uint16(\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\n SECONDS_PER_YEAR\n );\n\n if (ratio_ == 0) {\n ratio_ = 1;\n }\n }\n}\n" + }, + "contracts/market/libraries/LibCollateral.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Interfaces\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\nimport { ICollateralEscrow } from \"../collateral/ICollateralEscrow.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../storage/app.sol\";\nimport { MarketStorageLib } from \"../../storage/market.sol\";\n\nlibrary LibCollateral {\n /**\n * @notice This event is emitted when collateral has been deposited for the loan\n * @param loanID ID of the loan for which collateral was deposited\n * @param depositor Account that deposited funds\n * @param amount Amount of collateral deposited\n */\n event CollateralDeposited(\n uint256 indexed loanID,\n address indexed depositor,\n uint256 amount\n );\n\n /**\n * @notice This event is emitted when collateral has been withdrawn\n * @param loanID ID of loan from which collateral was withdrawn\n * @param receiver Account that received funds\n * @param amount Value of collateral withdrawn\n */\n event CollateralWithdrawn(\n uint256 indexed loanID,\n address indexed receiver,\n uint256 amount\n );\n\n /**\n * @notice it gets MarketStorage's collateral escrow using the loanID\n * @param loanID the loanID to be used\n * @return c_ which is the collateral escrow\n */\n function e(uint256 loanID) internal view returns (ICollateralEscrow c_) {\n c_ = MarketStorageLib.store().collateralEscrows[\n MarketStorageLib.store().loans[loanID].collateralToken\n ];\n }\n\n function e(address token) internal view returns (ICollateralEscrow c_) {\n c_ = MarketStorageLib.store().collateralEscrows[token];\n }\n\n /**\n * @notice it deposits an amount of collateral into a collateral escrow's address of a respective loan\n * @param loanID the respective loan ID\n * @param amount the amount of collateral to deposit\n */\n function deposit(uint256 loanID, uint256 amount) internal {\n e(loanID).deposit{ value: amount }(loanID, amount);\n\n emit CollateralDeposited(loanID, msg.sender, amount);\n }\n\n /**\n * @notice it withdraws an amount from the collateral escrow\n * @param loanID the respective loanID to withdraw from\n * @param amount the number of collateral tokens to withdraw\n * @param receiver the address who receives the withdrawal\n */\n function withdraw(\n uint256 loanID,\n uint256 amount,\n address payable receiver\n ) internal {\n e(loanID).withdraw(loanID, amount, receiver);\n\n emit CollateralWithdrawn(loanID, receiver, amount);\n }\n\n /**\n * @notice it withdraws the entire supply in collateral of a respective loan to an address\n * @param loanID the respective loan's ID\n * @param receiver the address of the receiver to withdraw tokens from\n */\n function withdrawAll(uint256 loanID, address payable receiver) internal {\n withdraw(loanID, e(loanID).loanSupply(loanID), receiver);\n }\n\n /**\n * @notice it initializes a new escrow collateral to hold collateral tokens\n * @param token address of the collateral token it holds\n */\n function createEscrow(address token) internal {\n // Check if collateral escrow exists\n if (address(e(token)) == address(0)) {\n // Create escrow\n address escrow =\n AppStorageLib.store().collateralEscrowBeacon.cloneProxy(\"\");\n ICollateralEscrow(escrow).init(\n token,\n // Check if collateral token is WETH\n token == AppStorageLib.store().assetAddresses[\"WETH\"]\n );\n\n // Set max allowance\n IERC20(token).approve(escrow, type(uint256).max);\n // Save escrow address for loan\n MarketStorageLib.store().collateralEscrows[\n token\n ] = ICollateralEscrow(escrow);\n }\n }\n}\n" + }, + "contracts/market/libraries/LibConsensus.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AppStorageLib } from \"../../storage/app.sol\";\nimport {\n MarketStorageLib,\n MarketStorage,\n LoanRequest,\n LoanUserRequest,\n LoanConsensusResponse,\n Signature\n} from \"../../storage/market.sol\";\nimport { NumbersLib } from \"../../shared/libraries/NumbersLib.sol\";\nimport { NumbersList } from \"../../shared/libraries/NumbersList.sol\";\nimport {\n PlatformSettingsLib\n} from \"../../settings/platform/libraries/PlatformSettingsLib.sol\";\nimport { ECDSA } from \"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\";\nimport { RolesLib } from \"../../contexts2/access-control/roles/RolesLib.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\nlibrary LibConsensus {\n using NumbersList for NumbersList.Values;\n\n /**\n * @notice Represents loan terms based on consensus values\n * @param interestRate The consensus value for the interest rate based on all the loan responses from the signers\n * @param collateralRatio The consensus value for the ratio of collateral to loan amount required for the loan, based on all the loan responses from the signers\n * @param maxLoanAmount The consensus value for the largest amount of tokens that can be taken out in the loan, based on all the loan responses from the signers\n */\n struct AccruedLoanTerms {\n NumbersList.Values interestRate;\n NumbersList.Values collateralRatio;\n NumbersList.Values maxLoanAmount;\n }\n\n function s() private pure returns (MarketStorage storage) {\n return MarketStorageLib.store();\n }\n\n /**\n * @notice it processes a loan terms by doing multiple checks on the LoanRequest request and LoanResponse[] responses\n * @param request LoanRequest is the borrower request object to take out a loan\n * @return interestRate the borrower needs to pay back\n * @return collateralRatio the ratio of collateral the borrower needs to put up for the loan with an underlying asset\n * @return maxLoanAmount the borrower is entitled for\n */\n function processLoanTerms(LoanRequest calldata request)\n internal\n view\n returns (\n uint16 interestRate,\n uint16 collateralRatio,\n uint256 maxLoanAmount\n )\n {\n // get the signers from the asset address\n EnumerableSet.AddressSet storage signers =\n s().signers[request.request.assetAddress];\n\n require(\n uint256(\n NumbersLib.ratioOf(\n request.responses.length,\n EnumerableSet.length(signers)\n )\n ) >= PlatformSettingsLib.getRequiredSubmissionsPercentageValue(),\n \"Teller: insufficient signer responses\"\n );\n \n _validateLoanRequest(\n request.request.borrower,\n request.request.requestNonce\n );\n\n uint32 chainId = _getChainId();\n bytes32 requestHash = _hashRequest(request.request, chainId);\n\n // create term submissions for every response ...\n AccruedLoanTerms memory termSubmissions;\n\n for (uint256 i = 0; i < request.responses.length; i++) {\n LoanConsensusResponse memory response = request.responses[i];\n\n // check if the signers contains the response's signer\n require(\n EnumerableSet.contains(signers, response.signer),\n \"Teller: invalid signer\"\n );\n\n // check if the request's asset address equates to the response's asset address\n require(\n response.assetAddress == request.request.assetAddress,\n \"Teller: consensus address mismatch\"\n );\n\n // check if consensus response has expired\n require(\n uint256(response.responseTime) >=\n block.timestamp -\n PlatformSettingsLib.getTermsExpiryTimeValue(),\n \"Teller: consensus response expired\"\n );\n\n // check if the signature of hashed response data matches\n require(\n _signatureValid(\n response.signature,\n _hashResponse(requestHash, response, chainId),\n response.signer\n ),\n \"Teller: response signature invalid\"\n );\n\n // TODO: use a local AddressArrayLib instead to save gas\n for (uint8 j = 0; j < i; j++) {\n require(\n response.signer != request.responses[j].signer,\n \"Teller: dup signer response\"\n );\n }\n\n termSubmissions.interestRate.addValue(response.interestRate);\n termSubmissions.collateralRatio.addValue(response.collateralRatio);\n termSubmissions.maxLoanAmount.addValue(response.maxLoanAmount);\n }\n\n // get maximum tolerance value in order to receive the interestRate, collateralRatio and maxLoanAmount\n uint16 tolerance =\n uint16(PlatformSettingsLib.getMaximumToleranceValue());\n interestRate = uint16(\n _getConsensus(termSubmissions.interestRate, tolerance)\n );\n collateralRatio = uint16(\n _getConsensus(termSubmissions.collateralRatio, tolerance)\n );\n maxLoanAmount = _getConsensus(termSubmissions.maxLoanAmount, tolerance);\n }\n\n /**\n * @dev Checks if the nonce provided in the request is equal to the borrower's number of loans.\n * @dev Also verifies if the borrower has taken out a loan recently (rate limit).\n * @param borrower the borrower's address.\n * @param nonce the nonce included in the loan request.\n */\n function _validateLoanRequest(address borrower, uint256 nonce)\n private\n view\n {\n uint128[] storage borrowerLoans = s().borrowerLoans[borrower];\n uint256 numberOfLoans = borrowerLoans.length;\n\n require(nonce == numberOfLoans, \"Teller: bad request nonce\");\n\n // In case it is the first time that borrower requests loan terms, we don't\n // validate the rate limit.\n if (numberOfLoans == 0) {\n return;\n }\n\n require(\n uint256(\n s().loans[uint256(borrowerLoans[numberOfLoans - 1])]\n .loanStartTime\n ) +\n PlatformSettingsLib.getRequestLoanTermsRateLimitValue() <=\n block.timestamp,\n \"Teller: loan terms rate limit reached\"\n );\n }\n\n /**\n * @notice Gets the current chain id using the opcode 'chainid()'.\n * @return id_ The current chain id.\n */\n function _getChainId() private view returns (uint32 id_) {\n // silence state mutability warning without generating bytecode.\n // see https://github.com/ethereum/solidity/issues/2691\n assembly {\n id_ := chainid()\n }\n }\n\n /**\n * @notice Generates a hash for the loan request\n * @param request Struct of the protocol loan request\n * @return bytes32 Hash of the loan request\n */\n function _hashRequest(LoanUserRequest memory request, uint32 chainId)\n private\n pure\n returns (bytes32)\n {\n return\n keccak256(\n abi.encode(\n request.borrower,\n request.assetAddress,\n request.amount,\n request.requestNonce,\n request.duration,\n request.requestTime,\n chainId\n )\n );\n }\n\n /**\n * @notice Generates a hash for the loan response\n * @param requestHash Hash of the loan request\n * @param response Structs of the protocol loan responses\n * @return bytes32 Hash of the loan response\n */\n function _hashResponse(\n bytes32 requestHash,\n LoanConsensusResponse memory response,\n uint32 chainId\n ) internal pure returns (bytes32) {\n return\n keccak256(\n abi.encode(\n response.assetAddress,\n response.maxLoanAmount,\n requestHash,\n response.responseTime,\n response.interestRate,\n response.collateralRatio,\n chainId\n )\n );\n }\n\n /**\n * @notice It validates whether a signature is valid or not.\n * @param signature signature to validate.\n * @param dataHash used to recover the signer.\n * @param expectedSigner the expected signer address.\n * @return true if the expected signer is equal to the signer. Otherwise it returns false.\n */\n function _signatureValid(\n Signature memory signature,\n bytes32 dataHash,\n address expectedSigner\n ) internal pure returns (bool) {\n return\n expectedSigner ==\n ECDSA.recover(\n keccak256(\n abi.encodePacked(\n \"\\x19Ethereum Signed Message:\\n32\",\n dataHash\n )\n ),\n signature.v,\n signature.r,\n signature.s\n );\n }\n\n /**\n * @notice Gets the consensus value for a list of values (uint values).\n * @notice The values must be in a maximum tolerance range.\n * @return the consensus value.\n */\n function _getConsensus(NumbersList.Values memory values, uint16 tolerance)\n internal\n pure\n returns (uint256)\n {\n require(\n values.isWithinTolerance(tolerance),\n \"Teller: consensus response values too varied\"\n );\n\n return values.getAverage();\n }\n}\n" + }, + "contracts/settings/asset/libraries/MaxDebtRatioLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../../shared/libraries/CacheLib.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions for MaxDebtRatio asset setting.\n *\n * @author develop@teller.finance\n */\nlibrary MaxDebtRatioLib {\n bytes32 private constant NAME = keccak256(\"MaxDebtRatio\");\n\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n function get(address asset) internal view returns (uint16) {\n return uint16(s(asset).uints[NAME]);\n }\n\n function set(address asset, uint16 newValue) internal {\n s(asset).uints[NAME] = uint256(newValue);\n }\n}\n" + }, + "@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IBeacon.sol\";\nimport \"../Proxy.sol\";\nimport \"../ERC1967/ERC1967Upgrade.sol\";\n\n/**\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\n *\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\n * conflict with the storage layout of the implementation behind the proxy.\n *\n * _Available since v3.4._\n */\ncontract BeaconProxy is Proxy, ERC1967Upgrade {\n /**\n * @dev Initializes the proxy with `beacon`.\n *\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\n * constructor.\n *\n * Requirements:\n *\n * - `beacon` must be a contract with the interface {IBeacon}.\n */\n constructor(address beacon, bytes memory data) payable {\n assert(_BEACON_SLOT == bytes32(uint256(keccak256(\"eip1967.proxy.beacon\")) - 1));\n _upgradeBeaconToAndCall(beacon, data, false);\n }\n\n /**\n * @dev Returns the current beacon address.\n */\n function _beacon() internal view virtual returns (address) {\n return _getBeacon();\n }\n\n /**\n * @dev Returns the current implementation address of the associated beacon.\n */\n function _implementation() internal view virtual override returns (address) {\n return IBeacon(_getBeacon()).implementation();\n }\n\n /**\n * @dev Changes the proxy to use a new beacon. Deprecated: see {_upgradeBeaconToAndCall}.\n *\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\n *\n * Requirements:\n *\n * - `beacon` must be a contract.\n * - The implementation returned by `beacon` must be a contract.\n */\n function _setBeacon(address beacon, bytes memory data) internal virtual {\n _upgradeBeaconToAndCall(beacon, data, false);\n }\n}\n" + }, + "contracts/escrow/libraries/LibEscrow.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport { LibDapps } from \"../dapps/libraries/LibDapps.sol\";\nimport { LibLoans } from \"../../market/libraries/LibLoans.sol\";\nimport { PriceAggLib } from \"../../price-aggregator/PriceAggLib.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\n// Interfaces\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { ILoansEscrow } from \"../escrow/ILoansEscrow.sol\";\n\n// Storage\nimport { MarketStorageLib, MarketStorage } from \"../../storage/market.sol\";\n\nlibrary LibEscrow {\n function s() internal pure returns (MarketStorage storage) {\n return MarketStorageLib.store();\n }\n\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\n e_ = s().loanEscrows[loanID];\n }\n\n function exists(uint256 loanID) internal view returns (bool) {\n return address(e(loanID)) != address(0);\n }\n\n /**\n * @notice It returns a list of tokens owned by a loan escrow\n * @param loanID uint256 index used to return our token list\n * @return t_ which is a list of tokens\n */\n function getEscrowTokens(uint256 loanID)\n internal\n view\n returns (EnumerableSet.AddressSet storage t_)\n {\n t_ = s().escrowTokens[loanID];\n }\n\n /**\n * @notice It returns the balance of a respective token in a loan escrow\n * @param loanID uint256 index used to point to our loan escrow\n * @param token address of respective token to give us the balance of in our loan escrow\n * @return uint256 balance of respective token returned in an escrow loan\n */\n function balanceOf(uint256 loanID, address token)\n internal\n view\n returns (uint256)\n {\n return exists(loanID) ? IERC20(token).balanceOf(address(e(loanID))) : 0;\n }\n\n /**\n * @notice Adds or removes tokens held by the Escrow contract\n * @param loanID The loan ID to update the token list for\n * @param tokenAddress The token address to be added or removed\n */\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\n // Skip if is lending token\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\n\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\n if (balanceOf(loanID, tokenAddress) > 0) {\n if (!contains) {\n EnumerableSet.add(tokens, tokenAddress);\n }\n } else if (contains) {\n EnumerableSet.remove(tokens, tokenAddress);\n }\n }\n\n /**\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\n * @param loanID The loan ID to calculate value for\n * @return value_ Escrow total value denoted in the lending token.\n */\n function calculateTotalValue(uint256 loanID)\n internal\n view\n returns (uint256 value_)\n {\n if (!exists(loanID)) {\n return 0;\n }\n\n address lendingToken = LibLoans.loan(loanID).lendingToken;\n value_ += balanceOf(loanID, lendingToken);\n\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\n if (EnumerableSet.length(tokens) > 0) {\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\n uint256 tokenBal =\n balanceOf(loanID, EnumerableSet.at(tokens, i));\n value_ += PriceAggLib.valueFor(\n EnumerableSet.at(tokens, i),\n lendingToken,\n tokenBal\n );\n }\n }\n }\n}\n" + }, + "contracts/price-aggregator/PriceAggLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { PriceAggFacet } from \"./PriceAggFacet.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../storage/app.sol\";\n\n/**\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\n */\nlibrary PriceAggLib {\n /**\n * @notice It calculates the value of one token amount into another\n * @param src the source token\n * @param dst the destination token\n * @param srcAmount the amount of source token\n * @return value_ the returned value of src in dst\n */\n function valueFor(\n address src,\n address dst,\n uint256 srcAmount\n ) internal view returns (uint256 value_) {\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\n }\n\n /**\n * @notice It returns the price of the token pair as given from Compound.\n * @dev if no compound price is calculated, then it checks Chainlink price Aggregator\n * @param src the address of the source token\n * @param dst the address of the desitnation token\n * @return price_ gets the price of src in dst\n */\n function priceFor(address src, address dst)\n internal\n view\n returns (int256 price_)\n {\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\n }\n}\n" + }, + "contracts/escrow/dapps/libraries/LibDapps.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Interfaces\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { IAToken } from \"../interfaces/IAToken.sol\";\nimport { IAaveLendingPool } from \"../interfaces/IAaveLendingPool.sol\";\nimport {\n IAaveLendingPoolAddressesProvider\n} from \"../interfaces/IAaveLendingPoolAddressesProvider.sol\";\nimport {\n IUniswapV2Router\n} from \"../../../shared/interfaces/IUniswapV2Router.sol\";\nimport { IVault } from \"../interfaces/IVault.sol\";\n\n// Libraries\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\n// Storage\nimport { MarketStorageLib, MarketStorage } from \"../../../storage/market.sol\";\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\nlibrary LibDapps {\n function s() internal pure returns (MarketStorage storage) {\n return MarketStorageLib.store();\n }\n\n /**\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\n @return IAaveLendingPool instance address\n */\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\n return\n IAaveLendingPool(\n IAaveLendingPoolAddressesProvider(\n 0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5\n )\n .getLendingPool()\n ); // LP address provider contract is immutable and the address will never change\n }\n\n /**\n @notice Grabs the aToken instance from the lending pool\n @param tokenAddress The underlying asset address to get the aToken for\n @return IAToken instance\n */\n function getAToken(address tokenAddress) internal view returns (IAToken) {\n return\n IAToken(\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\n );\n }\n\n /**\n @notice Grabs the yVault address for a token from the asset settings\n @param tokenAddress The underlying token address for the associated yVault\n @return yVault instance\n */\n function getYVault(address tokenAddress) internal view returns (IVault) {\n return\n IVault(\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\n keccak256(\"yVaultAddress\")\n ]\n );\n }\n}\n" + }, + "contracts/escrow/dapps/interfaces/IAToken.sol": { + "content": "// SPDX-License-Identifier: agpl-3.0\npragma solidity ^0.8.0;\n\ninterface IAToken {\n /**\n * @dev Mints `amount` aTokens to `user`\n * @param user The address receiving the minted tokens\n * @param amount The amount of tokens getting minted\n * @param index The new liquidity index of the reserve\n * @return `true` if the the previous balance of the user was 0\n */\n function mint(\n address user,\n uint256 amount,\n uint256 index\n ) external returns (bool);\n\n /**\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\n * @param user The owner of the aTokens, getting them burned\n * @param receiverOfUnderlying The address that will receive the underlying\n * @param amount The amount being burned\n * @param index The new liquidity index of the reserve\n **/\n function burn(\n address user,\n address receiverOfUnderlying,\n uint256 amount,\n uint256 index\n ) external;\n\n /**\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\n * assets in borrow(), withdraw() and flashLoan()\n * @param user The recipient of the aTokens\n * @param amount The amount getting transferred\n * @return The amount transferred\n **/\n function transferUnderlyingTo(address user, uint256 amount)\n external\n returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender)\n external\n view\n returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\n * @param user The user whose balance is calculated\n * @return The scaled balance of the user\n **/\n function scaledBalanceOf(address user) external view returns (uint256);\n\n /**\n * @dev Returns the scaled balance of the user and the scaled total supply.\n * @param user The address of the user\n * @return The scaled balance of the user\n * @return The scaled balance and the scaled total supply\n **/\n function getScaledUserBalanceAndSupply(address user)\n external\n view\n returns (uint256, uint256);\n\n /**\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\n * @return The scaled total supply\n **/\n function scaledTotalSupply() external view returns (uint256);\n}\n" + }, + "contracts/escrow/dapps/interfaces/IAaveLendingPool.sol": { + "content": "// SPDX-License-Identifier: agpl-3.0\npragma solidity ^0.8.0;\n\nimport \"./IAaveLendingPoolAddressesProvider.sol\";\nimport \"./DataTypes.sol\";\n\ninterface IAaveLendingPool {\n /**\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\n * @param asset The address of the underlying asset to deposit\n * @param amount The amount to be deposited\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\n * is a different wallet\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\n * 0 if the action is executed directly by the user, without any middle-man\n **/\n function deposit(\n address asset,\n uint256 amount,\n address onBehalfOf,\n uint16 referralCode\n ) external;\n\n /**\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\n * @param asset The address of the underlying asset to withdraw\n * @param amount The underlying amount to be withdrawn\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\n * @param to Address that will receive the underlying, same as msg.sender if the user\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\n * different wallet\n * @return The final amount withdrawn\n **/\n function withdraw(\n address asset,\n uint256 amount,\n address to\n ) external returns (uint256);\n\n /**\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\n * corresponding debt token (StableDebtToken or VariableDebtToken)\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\n * @param asset The address of the underlying asset to borrow\n * @param amount The amount to be borrowed\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\n * 0 if the action is executed directly by the user, without any middle-man\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\n * if he has been given credit delegation allowance\n **/\n function borrow(\n address asset,\n uint256 amount,\n uint256 interestRateMode,\n uint16 referralCode,\n address onBehalfOf\n ) external;\n\n /**\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\n * @param asset The address of the borrowed underlying asset previously borrowed\n * @param amount The amount to repay\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\n * other borrower whose debt should be removed\n * @return The final amount repaid\n **/\n function repay(\n address asset,\n uint256 amount,\n uint256 rateMode,\n address onBehalfOf\n ) external returns (uint256);\n\n /**\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\n * @param asset The address of the underlying asset borrowed\n * @param rateMode The rate mode that the user wants to swap to\n **/\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\n\n /**\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\n * - Users can be rebalanced if the following conditions are satisfied:\n * 1. Usage ratio is above 95%\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\n * borrowed at a stable rate and depositors are not earning enough\n * @param asset The address of the underlying asset borrowed\n * @param user The address of the user to be rebalanced\n **/\n function rebalanceStableBorrowRate(address asset, address user) external;\n\n /**\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\n * @param asset The address of the underlying asset deposited\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\n **/\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\n external;\n\n /**\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\n * @param user The address of the borrower getting liquidated\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\n * to receive the underlying collateral asset directly\n **/\n function liquidationCall(\n address collateralAsset,\n address debtAsset,\n address user,\n uint256 debtToCover,\n bool receiveAToken\n ) external;\n\n /**\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\n * as long as the amount taken plus a fee is returned.\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\n * For further details please visit https://developers.aave.com\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\n * @param assets The addresses of the assets being flash-borrowed\n * @param amounts The amounts amounts being flash-borrowed\n * @param modes Types of the debt to open if the flash loan is not returned:\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\n * @param params Variadic packed params to pass to the receiver as extra information\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\n * 0 if the action is executed directly by the user, without any middle-man\n **/\n function flashLoan(\n address receiverAddress,\n address[] calldata assets,\n uint256[] calldata amounts,\n uint256[] calldata modes,\n address onBehalfOf,\n bytes calldata params,\n uint16 referralCode\n ) external;\n\n /**\n * @dev Returns the user account data across all the reserves\n * @param user The address of the user\n * @return totalCollateralETH the total collateral in ETH of the user\n * @return totalDebtETH the total debt in ETH of the user\n * @return availableBorrowsETH the borrowing power left of the user\n * @return currentLiquidationThreshold the liquidation threshold of the user\n * @return ltv the loan to value of the user\n * @return healthFactor the current health factor of the user\n **/\n function getUserAccountData(address user)\n external\n view\n returns (\n uint256 totalCollateralETH,\n uint256 totalDebtETH,\n uint256 availableBorrowsETH,\n uint256 currentLiquidationThreshold,\n uint256 ltv,\n uint256 healthFactor\n );\n\n /**\n * @dev Returns the configuration of the reserve\n * @param asset The address of the underlying asset of the reserve\n * @return The configuration of the reserve\n **/\n function getConfiguration(address asset)\n external\n view\n returns (DataTypes.ReserveConfigurationMap memory);\n\n /**\n * @dev Returns the configuration of the user across all the reserves\n * @param user The user address\n * @return The configuration of the user\n **/\n function getUserConfiguration(address user)\n external\n view\n returns (DataTypes.UserConfigurationMap memory);\n\n /**\n * @dev Returns the normalized income normalized income of the reserve\n * @param asset The address of the underlying asset of the reserve\n * @return The reserve's normalized income\n */\n function getReserveNormalizedIncome(address asset)\n external\n view\n returns (uint256);\n\n /**\n * @dev Returns the normalized variable debt per unit of asset\n * @param asset The address of the underlying asset of the reserve\n * @return The reserve normalized variable debt\n */\n function getReserveNormalizedVariableDebt(address asset)\n external\n view\n returns (uint256);\n\n /**\n * @dev Returns the state and configuration of the reserve\n * @param asset The address of the underlying asset of the reserve\n * @return The state of the reserve\n **/\n function getReserveData(address asset)\n external\n view\n returns (DataTypes.ReserveData memory);\n\n function finalizeTransfer(\n address asset,\n address from,\n address to,\n uint256 amount,\n uint256 balanceFromAfter,\n uint256 balanceToBefore\n ) external;\n\n function getReservesList() external view returns (address[] memory);\n\n function getAddressesProvider()\n external\n view\n returns (IAaveLendingPoolAddressesProvider);\n\n function paused() external view returns (bool);\n}\n" + }, + "contracts/escrow/dapps/interfaces/IAaveLendingPoolAddressesProvider.sol": { + "content": "// SPDX-License-Identifier: agpl-3.0\npragma solidity ^0.8.0;\n\n/**\n * @title LendingPoolAddressesProvider contract\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\n * - Owned by the Aave Governance\n * @author Aave\n **/\ninterface IAaveLendingPoolAddressesProvider {\n function getMarketId() external view returns (string memory);\n\n function getAddress(bytes32 id) external view returns (address);\n\n function getLendingPool() external view returns (address);\n\n function getPriceOracle() external view returns (address);\n\n function getLendingRateOracle() external view returns (address);\n}\n" + }, + "contracts/escrow/dapps/interfaces/IVault.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/**\n @notice This interface defines the different functions available for a Yearn Vault\n @author develop@teller.finance\n */\n\ninterface IVault {\n /**\n @notice Returns the unwrapped native token address that the Vault takes as deposit\n @return The address of the unwrapped token\n */\n function token() external view returns (address);\n\n /**\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\n @return The name of the wrapped token\n */\n function name() external view returns (string memory);\n\n /**\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\n @return The symbol of the wrapped token\n */\n function symbol() external view returns (string memory);\n\n /**\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\n @return The number of decimals for the token\n */\n function decimals() external view returns (uint8);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n @notice Returns the address of the Vault's controller\n @return The address of the controller contract\n */\n function controller() external view returns (address);\n\n /**\n @notice Returns the address of the Vault's governance contract\n @return The contract address\n */\n function governance() external view returns (address);\n\n /**\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\n @return The token price\n */\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\n\n /**\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\n @return The token price\n */\n function getPricePerShare() external view returns (uint256); // v2 vaults\n\n /**\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\n @param amountToDeposit The amount of tokens to deposit\n */\n function deposit(uint256 amountToDeposit) external;\n\n /**\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\n */\n function depositAll() external;\n\n /**\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\n @param amountToWithdraw The amount to withdraw\n */\n function withdraw(uint256 amountToWithdraw) external;\n\n /**\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\n */\n function withdrawAll() external;\n}\n" + }, + "contracts/escrow/dapps/interfaces/DataTypes.sol": { + "content": "// SPDX-License-Identifier: agpl-3.0\npragma solidity ^0.8.0;\n\nlibrary DataTypes {\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\n struct ReserveData {\n //stores the reserve configuration\n ReserveConfigurationMap configuration;\n //the liquidity index. Expressed in ray\n uint128 liquidityIndex;\n //variable borrow index. Expressed in ray\n uint128 variableBorrowIndex;\n //the current supply rate. Expressed in ray\n uint128 currentLiquidityRate;\n //the current variable borrow rate. Expressed in ray\n uint128 currentVariableBorrowRate;\n //the current stable borrow rate. Expressed in ray\n uint128 currentStableBorrowRate;\n uint40 lastUpdateTimestamp;\n //tokens addresses\n address aTokenAddress;\n address stableDebtTokenAddress;\n address variableDebtTokenAddress;\n //address of the interest rate strategy\n address interestRateStrategyAddress;\n //the id of the reserve. Represents the position in the list of the active reserves\n uint8 id;\n }\n\n struct ReserveConfigurationMap {\n //bit 0-15: LTV\n //bit 16-31: Liq. threshold\n //bit 32-47: Liq. bonus\n //bit 48-55: Decimals\n //bit 56: Reserve is active\n //bit 57: reserve is frozen\n //bit 58: borrowing is enabled\n //bit 59: stable rate borrowing enabled\n //bit 60-63: reserved\n //bit 64-79: reserve factor\n uint256 data;\n }\n\n struct UserConfigurationMap {\n uint256 data;\n }\n\n enum InterestRateMode { NONE, STABLE, VARIABLE }\n}\n" + }, + "@openzeppelin/contracts/utils/cryptography/ECDSA.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\n *\n * These functions can be used to verify that a message was signed by the holder\n * of the private keys of a given address.\n */\nlibrary ECDSA {\n /**\n * @dev Returns the address that signed a hashed message (`hash`) with\n * `signature`. This address can then be used for verification purposes.\n *\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\n * this function rejects them by requiring the `s` value to be in the lower\n * half order, and the `v` value to be either 27 or 28.\n *\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n * verification to be secure: it is possible to craft signatures that\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n * this is by receiving a hash of the original message (which may otherwise\n * be too long), and then calling {toEthSignedMessageHash} on it.\n */\n function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\n // Divide the signature in r, s and v variables\n bytes32 r;\n bytes32 s;\n uint8 v;\n\n // Check the signature length\n // - case 65: r,s,v signature (standard)\n // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._\n if (signature.length == 65) {\n // ecrecover takes the signature parameters, and the only way to get them\n // currently is to use assembly.\n // solhint-disable-next-line no-inline-assembly\n assembly {\n r := mload(add(signature, 0x20))\n s := mload(add(signature, 0x40))\n v := byte(0, mload(add(signature, 0x60)))\n }\n } else if (signature.length == 64) {\n // ecrecover takes the signature parameters, and the only way to get them\n // currently is to use assembly.\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let vs := mload(add(signature, 0x40))\n r := mload(add(signature, 0x20))\n s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)\n v := add(shr(255, vs), 27)\n }\n } else {\n revert(\"ECDSA: invalid signature length\");\n }\n\n return recover(hash, v, r, s);\n }\n\n /**\n * @dev Overload of {ECDSA-recover} that receives the `v`,\n * `r` and `s` signature fields separately.\n */\n function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {\n // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n //\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n // these malleable signatures as well.\n require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, \"ECDSA: invalid signature 's' value\");\n require(v == 27 || v == 28, \"ECDSA: invalid signature 'v' value\");\n\n // If the signature is valid (and not malleable), return the signer address\n address signer = ecrecover(hash, v, r, s);\n require(signer != address(0), \"ECDSA: invalid signature\");\n\n return signer;\n }\n\n /**\n * @dev Returns an Ethereum Signed Message, created from a `hash`. This\n * produces hash corresponding to the one signed with the\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\n * JSON-RPC method as part of EIP-191.\n *\n * See {recover}.\n */\n function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {\n // 32 is the length in bytes of hash,\n // enforced by the type signature above\n return keccak256(abi.encodePacked(\"\\x19Ethereum Signed Message:\\n32\", hash));\n }\n\n /**\n * @dev Returns an Ethereum Signed Typed Data, created from a\n * `domainSeparator` and a `structHash`. This produces hash corresponding\n * to the one signed with the\n * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\n * JSON-RPC method as part of EIP-712.\n *\n * See {recover}.\n */\n function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {\n return keccak256(abi.encodePacked(\"\\x19\\x01\", domainSeparator, structHash));\n }\n}\n" + }, + "@openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.2;\n\nimport \"../beacon/IBeacon.sol\";\nimport \"../../utils/Address.sol\";\nimport \"../../utils/StorageSlot.sol\";\n\n/**\n * @dev This abstract contract provides getters and event emitting update functions for\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\n *\n * _Available since v4.1._\n *\n * @custom:oz-upgrades-unsafe-allow delegatecall\n */\nabstract contract ERC1967Upgrade {\n // This is the keccak-256 hash of \"eip1967.proxy.rollback\" subtracted by 1\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\n\n /**\n * @dev Storage slot with the address of the current implementation.\n * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n /**\n * @dev Emitted when the implementation is upgraded.\n */\n event Upgraded(address indexed implementation);\n\n /**\n * @dev Returns the current implementation address.\n */\n function _getImplementation() internal view returns (address) {\n return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the EIP1967 implementation slot.\n */\n function _setImplementation(address newImplementation) private {\n require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n }\n\n /**\n * @dev Perform implementation upgrade\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeTo(address newImplementation) internal {\n _setImplementation(newImplementation);\n emit Upgraded(newImplementation);\n }\n\n /**\n * @dev Perform implementation upgrade with additional setup call.\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {\n _setImplementation(newImplementation);\n emit Upgraded(newImplementation);\n if (data.length > 0 || forceCall) {\n Address.functionDelegateCall(newImplementation, data);\n }\n }\n\n /**\n * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeToAndCallSecure(address newImplementation, bytes memory data, bool forceCall) internal {\n address oldImplementation = _getImplementation();\n\n // Initial upgrade and setup call\n _setImplementation(newImplementation);\n if (data.length > 0 || forceCall) {\n Address.functionDelegateCall(newImplementation, data);\n }\n\n // Perform rollback test if not already in progress\n StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);\n if (!rollbackTesting.value) {\n // Trigger rollback using upgradeTo from the new implementation\n rollbackTesting.value = true;\n Address.functionDelegateCall(\n newImplementation,\n abi.encodeWithSignature(\n \"upgradeTo(address)\",\n oldImplementation\n )\n );\n rollbackTesting.value = false;\n // Check rollback was effective\n require(oldImplementation == _getImplementation(), \"ERC1967Upgrade: upgrade breaks further upgrades\");\n // Finally reset to the new implementation and log the upgrade\n _setImplementation(newImplementation);\n emit Upgraded(newImplementation);\n }\n }\n\n /**\n * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\n * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\n *\n * Emits a {BeaconUpgraded} event.\n */\n function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {\n _setBeacon(newBeacon);\n emit BeaconUpgraded(newBeacon);\n if (data.length > 0 || forceCall) {\n Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\n }\n }\n\n /**\n * @dev Storage slot with the admin of the contract.\n * This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\n\n /**\n * @dev Emitted when the admin account has changed.\n */\n event AdminChanged(address previousAdmin, address newAdmin);\n\n /**\n * @dev Returns the current admin.\n */\n function _getAdmin() internal view returns (address) {\n return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the EIP1967 admin slot.\n */\n function _setAdmin(address newAdmin) private {\n require(newAdmin != address(0), \"ERC1967: new admin is the zero address\");\n StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\n }\n\n /**\n * @dev Changes the admin of the proxy.\n *\n * Emits an {AdminChanged} event.\n */\n function _changeAdmin(address newAdmin) internal {\n emit AdminChanged(_getAdmin(), newAdmin);\n _setAdmin(newAdmin);\n }\n\n /**\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\n */\n bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\n\n /**\n * @dev Emitted when the beacon is upgraded.\n */\n event BeaconUpgraded(address indexed beacon);\n\n /**\n * @dev Returns the current beacon.\n */\n function _getBeacon() internal view returns (address) {\n return StorageSlot.getAddressSlot(_BEACON_SLOT).value;\n }\n\n /**\n * @dev Stores a new beacon in the EIP1967 beacon slot.\n */\n function _setBeacon(address newBeacon) private {\n require(\n Address.isContract(newBeacon),\n \"ERC1967: new beacon is not a contract\"\n );\n require(\n Address.isContract(IBeacon(newBeacon).implementation()),\n \"ERC1967: beacon implementation is not a contract\"\n );\n StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;\n }\n}\n" + }, + "@openzeppelin/contracts/utils/StorageSlot.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC1967 implementation slot:\n * ```\n * contract ERC1967 {\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n * function _getImplementation() internal view returns (address) {\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n * }\n *\n * function _setImplementation(address newImplementation) internal {\n * require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n * }\n * }\n * ```\n *\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\n */\nlibrary StorageSlot {\n struct AddressSlot {\n address value;\n }\n\n struct BooleanSlot {\n bool value;\n }\n\n struct Bytes32Slot {\n bytes32 value;\n }\n\n struct Uint256Slot {\n uint256 value;\n }\n\n /**\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n */\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\n */\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\n */\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\n */\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n assembly {\n r.slot := slot\n }\n }\n}\n" + }, + "contracts/escrow/EscrowClaimTokens.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { PausableMods } from \"../settings/pausable/PausableMods.sol\";\n\n// Interfaces\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\n// Storage\nimport { MarketStorageLib, LoanStatus } from \"../storage/market.sol\";\n\n// Libraries\nimport { LibLoans } from \"../market/libraries/LibLoans.sol\";\nimport { LibEscrow } from \"./libraries/LibEscrow.sol\";\n\n/**\n * @notice Contains functionality to claim tokens that are in an escrow contract for a loan.\n */\ncontract EscrowClaimTokens is PausableMods {\n /**\n * @notice Notifies when the Escrow's tokens have been claimed.\n * @param recipient address where the tokens where sent to.\n */\n event TokensClaimed(address recipient);\n\n /**\n * @notice Sends the tokens owned by this escrow to the owner.\n * @param loanID The id of the loan being used.\n */\n function claimTokens(uint256 loanID) external paused(\"\", false) {\n require(\n LibLoans.loan(loanID).borrower == msg.sender,\n \"Teller: claim not borrower\"\n );\n require(\n LibLoans.loan(loanID).status == LoanStatus.Closed,\n \"Teller: loan not closed\"\n );\n\n __claimEscrowTokens(loanID);\n }\n\n function __claimEscrowTokens(uint256 loanID) internal {\n __claimToken(loanID, LibLoans.loan(loanID).lendingToken);\n\n EnumerableSet.AddressSet storage tokens =\n MarketStorageLib.store().escrowTokens[loanID];\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\n __claimToken(loanID, EnumerableSet.at(tokens, i));\n }\n\n emit TokensClaimed(msg.sender);\n }\n\n function __claimToken(uint256 loanID, address token) private {\n uint256 balance = LibEscrow.balanceOf(loanID, token);\n if (balance > 0) {\n LibEscrow.e(loanID).claimToken(\n token,\n LibLoans.loan(loanID).borrower,\n balance\n );\n }\n }\n}\n" + }, + "contracts/escrow/dapps/DappMods.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport { LibLoans } from \"../../market/libraries/LibLoans.sol\";\nimport {\n PlatformSettingsLib\n} from \"../../settings/platform/libraries/PlatformSettingsLib.sol\";\n\nabstract contract DappMods {\n /**\n * @notice it checks if the caller to a respective loan escrow is the borrower\n * @param loanID uint256 of the respective loan escrow\n */\n modifier onlyBorrower(uint256 loanID) {\n require(\n msg.sender == LibLoans.loan(loanID).borrower,\n \"Teller: dapp not loan borrower\"\n );\n _;\n }\n \n /**\n * @notice checks if the respective loan escrow is secure\n * @param loanID uint256 of the respective loan escrow\n */\n modifier onlySecured(uint256 loanID) {\n require(\n LibLoans.loan(loanID).collateralRatio >=\n PlatformSettingsLib.getCollateralBufferValue(),\n \"Teller: dapp loan not secured\"\n );\n _;\n }\n}\n" + }, + "contracts/escrow/dapps/libraries/LibCompound.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nlibrary LibCompound {\n // Compound error code for no errors\n uint256 constant NO_ERROR = 0;\n\n // Compound error code when caller does not have sufficient balance in the ERC-20 contract to complete the desired action.\n uint256 constant TOKEN_INSUFFICIENT_BALANCE = 13;\n}\n" + }, + "contracts/escrow/dapps/libraries/LibUniswap.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Interfaces\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport {\n IUniswapV2Router\n} from \"../../../shared/interfaces/IUniswapV2Router.sol\";\n\n// Libraries\nimport {\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\n\nlibrary LibUniswap {\n IUniswapV2Router constant ROUTER =\n IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);\n\n /**\n * @notice Swaps tokens for tokens on Uniswap.\n * @dev {path} must have at least 2 token addresses\n * @param path An array of token addresses.\n * @param sourceAmount amount of source token to swap.\n * @param minDestination The minimum amount of output tokens that must be received for the transaction not to revert.\n * @return amounts is the resulting number of tokens swapped for\n */\n function swap(\n address[] memory path,\n uint256 sourceAmount,\n uint256 minDestination\n ) internal returns (uint256) {\n SafeERC20.safeIncreaseAllowance(\n IERC20(path[0]),\n address(ROUTER),\n sourceAmount\n );\n uint256[] memory amounts =\n ROUTER.swapExactTokensForTokens(\n sourceAmount,\n minDestination,\n path,\n address(this),\n block.timestamp\n );\n\n return amounts[amounts.length - 1];\n }\n}\n" + }, + "contracts/escrow/escrow/LoansEscrow_V1.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\n\n// Interfaces\nimport { ILoansEscrow } from \"./ILoansEscrow.sol\";\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { ICErc20 } from \"../../shared/interfaces/ICErc20.sol\";\n\n// Libraries\nimport {\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport { Address } from \"@openzeppelin/contracts/utils/Address.sol\";\n\n// Proxy\nimport {\n InitializeableBeaconProxy\n} from \"../../shared/proxy/beacon/InitializeableBeaconProxy.sol\";\nimport { IBeacon } from \"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\";\n\ncontract LoansEscrow_V1 is ILoansEscrow {\n address public owner;\n\n modifier onlyOwner {\n require(owner == msg.sender, \"Teller: loan escrow not owner\");\n _;\n }\n\n function init() external override {\n require(owner == address(0), \"Teller: loan escrow already initialized\");\n owner = msg.sender;\n }\n\n /**\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\n * @param dappAddress address of the target contract address\n * @param dappData encoded abi of the function in our contract we want to call\n * @return resData_ the called data in\n */\n function callDapp(address dappAddress, bytes calldata dappData)\n external\n override\n onlyOwner\n returns (bytes memory resData_)\n {\n resData_ = Address.functionCall(\n dappAddress,\n dappData,\n \"Teller: dapp call failed\"\n );\n }\n\n /**\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\n * @param token address of the respective ERC20 token to approve for the spender\n * @param spender address of the respective spender who is approved by the token contract\n */\n function setTokenAllowance(address token, address spender)\n external\n override\n onlyOwner\n {\n IERC20(token).approve(spender, type(uint256).max);\n }\n\n /**\n * @notice it allows user to claim their escrow tokens\n * @dev only the owner (TellerDiamond) can make this call on behalf of their users\n * @param token address of the respective token contract to claim tokens from\n * @param to address where the tokens should be transferred to\n * @param amount uint256 amount of tokens to be claimed\n */\n function claimToken(\n address token,\n address to,\n uint256 amount\n ) external override onlyOwner {\n SafeERC20.safeTransfer(IERC20(token), to, amount);\n }\n}\n" + }, + "contracts/market/collateral/CollateralEscrow_V1.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\";\n\n// Interfaces\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { ICollateralEscrow } from \"./ICollateralEscrow.sol\";\nimport { IWETH } from \"../../shared/interfaces/IWETH.sol\";\n\n// Libraries\nimport {\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport { Address } from \"@openzeppelin/contracts/utils/Address.sol\";\n\ncontract CollateralEscrow_V1 is OwnableUpgradeable, ICollateralEscrow {\n mapping(uint256 => uint256) internal _balances; // loanID -> collateral\n address public collateralToken;\n bool internal _isWETH;\n\n /**\n * @notice it initializes an escrow\n * @param tokenAddress the address of the collateral token to be stored\n * @param isWETH check if it's wrapped Ethereum\n */\n function init(address tokenAddress, bool isWETH) external override {\n require(\n tokenAddress != address(0),\n \"Teller escrow: collateral token address 0\"\n );\n\n OwnableUpgradeable.__Ownable_init();\n collateralToken = tokenAddress;\n _isWETH = isWETH;\n }\n\n /**\n * @notice it deposits an amount of the respective collateral token into the escrow\n * @param loanID the ID of the loan\n * @param amount the amount of collateral tokens to be deposited\n */\n function deposit(uint256 loanID, uint256 amount)\n external\n payable\n override\n onlyOwner\n {\n if (_isWETH && msg.value > 0) {\n require(msg.value == amount, \"Teller: incorrect eth deposit\");\n IWETH(collateralToken).deposit{ value: msg.value }();\n } else {\n SafeERC20.safeTransferFrom(\n IERC20(collateralToken),\n msg.sender,\n address(this),\n amount\n );\n }\n\n _balances[loanID] += amount;\n }\n\n /**\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\n * @dev only the TellerDiamond can make this call on behalf of the borrower\n * @param loanID identifier of the loan\n * @param amount number of collateral tokens to send\n * @param receiver payable address to transfer money to\n */\n function withdraw(\n uint256 loanID,\n uint256 amount,\n address payable receiver\n ) external override onlyOwner {\n require(\n _balances[loanID] >= amount,\n \"Teller escrow: Insufficient collateral balance\"\n );\n\n SafeERC20.safeTransfer(IERC20(collateralToken), receiver, amount);\n _balances[loanID] -= amount;\n }\n\n /**\n * @notice it returns the supply of collateral of the respective loan\n * @param loanID the respective loan ID\n * @return supply_ the amount in collateral of the respective loan\n */\n function loanSupply(uint256 loanID)\n external\n view\n override\n returns (uint256 supply_)\n {\n supply_ = _balances[loanID];\n }\n\n /**\n * @notice it returns the total supply of the collateral token held by the contract\n * @return supply_ the total amount of collateral\n */\n function totalSupply() external view override returns (uint256 supply_) {\n supply_ = IERC20(collateralToken).balanceOf(address(this));\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\n address private _owner;\n\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Initializes the contract setting the deployer as the initial owner.\n */\n function __Ownable_init() internal initializer {\n __Context_init_unchained();\n __Ownable_init_unchained();\n }\n\n function __Ownable_init_unchained() internal initializer {\n address msgSender = _msgSender();\n _owner = msgSender;\n emit OwnershipTransferred(address(0), msgSender);\n }\n\n /**\n * @dev Returns the address of the current owner.\n */\n function owner() public view virtual returns (address) {\n return _owner;\n }\n\n /**\n * @dev Throws if called by any account other than the owner.\n */\n modifier onlyOwner() {\n require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n _;\n }\n\n /**\n * @dev Leaves the contract without owner. It will not be possible to call\n * `onlyOwner` functions anymore. Can only be called by the current owner.\n *\n * NOTE: Renouncing ownership will leave the contract without an owner,\n * thereby removing any functionality that is only available to the owner.\n */\n function renounceOwnership() public virtual onlyOwner {\n emit OwnershipTransferred(_owner, address(0));\n _owner = address(0);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) public virtual onlyOwner {\n require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n emit OwnershipTransferred(_owner, newOwner);\n _owner = newOwner;\n }\n uint256[49] private __gap;\n}\n" + }, + "contracts/shared/interfaces/IWETH.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/**\n * @notice It is the interface of functions that we use for the canonical WETH contract.\n *\n * @author develop@teller.finance\n */\ninterface IWETH {\n /**\n * @notice It withdraws ETH from the contract by sending it to the caller and reducing the caller's internal balance of WETH.\n * @param amount The amount of ETH to withdraw.\n */\n function withdraw(uint256 amount) external;\n\n /**\n * @notice It deposits ETH into the contract and increases the caller's internal balance of WETH.\n */\n function deposit() external payable;\n\n /**\n * @notice It gets the ETH deposit balance of an {account}.\n * @param account Address to get balance of.\n */\n function balanceOf(address account) external view returns (uint256);\n}\n" + }, + "contracts/lending/ttoken/TToken_V1.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport {\n CONTROLLER,\n ADMIN,\n EXCHANGE_RATE_FACTOR,\n ONE_HUNDRED_PERCENT\n} from \"./data.sol\";\nimport { ITTokenStrategy } from \"./strategies/ITTokenStrategy.sol\";\nimport { ERC20 } from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\n\n// Utils\nimport { Address } from \"@openzeppelin/contracts/utils/Address.sol\";\n\n// Interfaces\nimport { ITToken } from \"./ITToken.sol\";\nimport { ICErc20 } from \"../../shared/interfaces/ICErc20.sol\";\n\n// Libraries\nimport {\n IERC20,\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport {\n ERC165Checker\n} from \"@openzeppelin/contracts/utils/introspection/ERC165Checker.sol\";\nimport { RolesLib } from \"../../contexts2/access-control/roles/RolesLib.sol\";\nimport { NumbersLib } from \"../../shared/libraries/NumbersLib.sol\";\n\n// Storage\nimport \"./storage.sol\" as Storage;\n\n/**\n * @notice This contract represents a lending pool for an asset within Teller protocol.\n * @author develop@teller.finance\n */\ncontract TToken_V1 is ITToken {\n function() pure returns (Storage.Store storage) private constant s =\n Storage.store;\n\n /* Modifiers */\n\n /**\n * @notice Checks if the LP is restricted or has the CONTROLLER role.\n *\n * The LP being restricted means that only the Teller protocol may\n * lend/borrow funds.\n */\n modifier notRestricted {\n require(\n !s().restricted || RolesLib.hasRole(CONTROLLER, _msgSender()),\n \"Teller: platform restricted\"\n );\n _;\n }\n\n /* Public Functions */\n\n /**\n * @notice it returns the decimal places of the respective TToken\n * @return decimals of the token\n */\n function decimals() public view override returns (uint8) {\n return s().decimals;\n }\n\n /**\n * @notice The token that is the underlying assets for this Teller token.\n * @return ERC20 token that is the underl\n */\n function underlying() public view override returns (ERC20) {\n return s().underlying;\n }\n\n /**\n * @notice The balance of an {account} denoted in underlying value.\n * @param account Address to calculate the underlying balance.\n * @return balance_ the balance of the account\n */\n function balanceOfUnderlying(address account)\n public\n override\n returns (uint256)\n {\n return _valueInUnderlying(balanceOf(account), exchangeRate());\n }\n\n /**\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\n * @return rate_ The current exchange rate.\n */\n function exchangeRate() public override returns (uint256 rate_) {\n if (totalSupply() == 0) {\n return EXCHANGE_RATE_FACTOR;\n }\n\n rate_ = (currentTVL() * EXCHANGE_RATE_FACTOR) / totalSupply();\n }\n\n /**\n * @notice It calculates the total supply of the underlying asset.\n * @return totalSupply_ the total supply denoted in the underlying asset.\n */\n function totalUnderlyingSupply() public override returns (uint256) {\n bytes memory data =\n _delegateStrategy(\n abi.encodeWithSelector(\n ITTokenStrategy.totalUnderlyingSupply.selector\n )\n );\n return abi.decode(data, (uint256));\n }\n\n /**\n * @notice It calculates the market state values across a given markets.\n * @notice Returns values that represent the global state across the market.\n * @return totalSupplied Total amount of the underlying asset supplied.\n * @return totalBorrowed Total amount borrowed through loans.\n * @return totalRepaid The total amount repaid till the current timestamp.\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\n * @return totalOnLoan Total amount currently deployed in loans.\n */\n function getMarketState()\n external\n override\n returns (\n uint256 totalSupplied,\n uint256 totalBorrowed,\n uint256 totalRepaid,\n uint256 totalInterestRepaid,\n uint256 totalOnLoan\n )\n {\n totalSupplied = totalUnderlyingSupply();\n totalBorrowed = s().totalBorrowed;\n totalRepaid = s().totalRepaid;\n totalInterestRepaid = s().totalInterestRepaid;\n totalOnLoan = totalBorrowed - totalRepaid;\n }\n\n /**\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\n * @return tvl_ The value locked in the pool.\n *\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\n */\n function currentTVL() public override returns (uint256 tvl_) {\n tvl_ += totalUnderlyingSupply();\n tvl_ += s().totalBorrowed;\n tvl_ -= s().totalRepaid;\n }\n\n /**\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\n * @param newLoanAmount the new loan amount to consider the StD ratio.\n * @return ratio_ Whether debt ratio for lending pool is valid.\n */\n function debtRatioFor(uint256 newLoanAmount)\n external\n override\n returns (uint16 ratio_)\n {\n uint256 onLoan = s().totalBorrowed - s().totalRepaid;\n uint256 supplied = totalUnderlyingSupply() + onLoan;\n if (supplied > 0) {\n ratio_ = NumbersLib.ratioOf(onLoan + newLoanAmount, supplied);\n }\n }\n\n /**\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\n * @param recipient The account to send the funds to.\n * @param amount Funds requested to fulfil the loan.\n */\n function fundLoan(address recipient, uint256 amount)\n external\n override\n authorized(CONTROLLER, _msgSender())\n {\n // If TToken is not holding enough funds to cover the loan, call the strategy to try to withdraw\n uint256 balance = s().underlying.balanceOf(address(this));\n if (balance < amount) {\n _delegateStrategy(\n abi.encodeWithSelector(\n ITTokenStrategy.withdraw.selector,\n amount - balance\n )\n );\n }\n\n // Increase total borrowed amount\n s().totalBorrowed += amount;\n\n // Transfer tokens to recipient\n SafeERC20.safeTransfer(s().underlying, recipient, amount);\n }\n\n /**\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\n * @param interestAmount Interest value paid into the pool from a loan.\n */\n function repayLoan(uint256 amount, uint256 interestAmount)\n external\n override\n authorized(CONTROLLER, _msgSender())\n {\n s().totalRepaid += amount;\n s().totalInterestRepaid += interestAmount;\n }\n\n /**\n * @notice Deposit underlying token amount into LP and mint tokens.\n * @param amount The amount of underlying tokens to use to mint.\n * @return Amount of TTokens minted.\n */\n function mint(uint256 amount)\n external\n override\n notRestricted\n returns (uint256)\n {\n require(amount > 0, \"Teller: cannot mint 0\");\n require(\n amount <= s().underlying.balanceOf(_msgSender()),\n \"Teller: insufficient underlying\"\n );\n\n // Calculate amount of tokens to mint\n uint256 mintAmount = _valueOfUnderlying(amount, exchangeRate());\n\n // Transfer tokens from lender\n SafeERC20.safeTransferFrom(\n s().underlying,\n _msgSender(),\n address(this),\n amount\n );\n\n // Mint Teller token value of underlying\n _mint(_msgSender(), mintAmount);\n\n emit Mint(_msgSender(), mintAmount, amount);\n\n return mintAmount;\n }\n\n /**\n * @notice Redeem supplied Teller token underlying value.\n * @param amount The amount of Teller tokens to redeem.\n */\n function redeem(uint256 amount) external override {\n require(amount > 0, \"Teller: cannot withdraw 0\");\n require(\n amount <= balanceOf(_msgSender()),\n \"Teller: redeem amount exceeds balance\"\n );\n\n // Accrue interest and calculate exchange rate\n uint256 underlyingAmount = _valueInUnderlying(amount, exchangeRate());\n require(\n underlyingAmount <= totalUnderlyingSupply(),\n \"Teller: redeem ttoken lp not enough supply\"\n );\n\n // Burn Teller Tokens and transfer underlying\n _redeem(amount, underlyingAmount);\n }\n\n /**\n * @notice Redeem supplied underlying value.\n * @param amount The amount of underlying tokens to redeem.\n */\n function redeemUnderlying(uint256 amount) external override {\n require(amount > 0, \"Teller: cannot withdraw 0\");\n require(\n amount <= totalUnderlyingSupply(),\n \"Teller: redeem ttoken lp not enough supply\"\n );\n\n // Accrue interest and calculate exchange rate\n uint256 rate = exchangeRate();\n uint256 tokenValue = _valueOfUnderlying(amount, rate);\n\n // Make sure sender has adequate balance\n require(\n tokenValue <= balanceOf(_msgSender()),\n \"Teller: redeem amount exceeds balance\"\n );\n\n // Burn Teller Tokens and transfer underlying\n _redeem(tokenValue, amount);\n }\n\n /**\n * @dev Redeem an {amount} of Teller Tokens and transfers {underlyingAmount} to the caller.\n * @param amount Total amount of Teller Tokens to burn.\n * @param underlyingAmount Total amount of underlying asset tokens to transfer to caller.\n *\n * This function should only be called by {redeem} and {redeemUnderlying} after the exchange\n * rate and both token values have been calculated to use.\n */\n function _redeem(uint256 amount, uint256 underlyingAmount) internal {\n // Burn Teller tokens\n _burn(_msgSender(), amount);\n\n // Make sure enough funds are available to redeem\n _delegateStrategy(\n abi.encodeWithSelector(\n ITTokenStrategy.withdraw.selector,\n underlyingAmount\n )\n );\n\n // Transfer funds back to lender\n SafeERC20.safeTransfer(s().underlying, _msgSender(), underlyingAmount);\n\n emit Redeem(_msgSender(), amount, underlyingAmount);\n }\n\n /**\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\n *\n * See {TTokenStrategy}.\n */\n function rebalance() public override {\n _delegateStrategy(\n abi.encodeWithSelector(ITTokenStrategy.rebalance.selector)\n );\n }\n\n /**\n * @notice Sets a new strategy to use for balancing funds.\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\n * @param initData Optional data to initialize the strategy.\n *\n * Requirements:\n * - Sender must have ADMIN role\n */\n function setStrategy(address strategy, bytes calldata initData)\n external\n override\n authorized(ADMIN, _msgSender())\n {\n require(\n ERC165Checker.supportsInterface(\n strategy,\n type(ITTokenStrategy).interfaceId\n ),\n \"Teller: strategy does not support ITTokenStrategy\"\n );\n s().strategy = strategy;\n if (initData.length > 0) {\n _delegateStrategy(initData);\n }\n }\n\n /**\n * @notice Gets the strategy used for balancing funds.\n * @return address of the strategy contract\n */\n function getStrategy() external view override returns (address) {\n return s().strategy;\n }\n\n /**\n * @notice Sets the restricted state of the platform.\n * @param state boolean value that resembles the platform's state\n */\n function restrict(bool state)\n public\n override\n authorized(ADMIN, _msgSender())\n {\n s().restricted = state;\n }\n\n /**\n * @notice it initializes the Teller Token\n * @param admin address of the admin to the respective Teller Token\n * @param underlying address of the ERC20 token\n */\n function initialize(address admin, address underlying)\n external\n override\n initializer\n {\n require(\n Address.isContract(msg.sender),\n \"Teller: controller not contract\"\n );\n require(\n Address.isContract(underlying),\n \"Teller: underlying token not contract\"\n );\n\n RolesLib.grantRole(CONTROLLER, msg.sender);\n RolesLib.grantRole(ADMIN, admin);\n\n s().underlying = ERC20(underlying);\n __ERC20_init(\n string(abi.encodePacked(\"Teller \", s().underlying.name())),\n string(abi.encodePacked(\"t\", s().underlying.symbol()))\n );\n s().decimals = s().underlying.decimals();\n // Platform restricted by default\n s().restricted = true;\n }\n\n /**\n * @notice it retrieves the value of the underlying token\n * @param amount the amount of tokens to calculate the value of\n * @param rate the exchangeRate() to divide with the amount * exchange_rate_factor\n * @return value_ the underlying value of the token amount\n */\n function _valueOfUnderlying(uint256 amount, uint256 rate)\n internal\n pure\n returns (uint256 value_)\n {\n value_ = (amount * EXCHANGE_RATE_FACTOR) / rate;\n }\n\n /**\n * @notice it retrives the value in the underlying tokens\n * \n */\n function _valueInUnderlying(uint256 amount, uint256 rate)\n internal\n pure\n returns (uint256 value_)\n {\n value_ = (amount * (rate)) / EXCHANGE_RATE_FACTOR;\n }\n\n /**\n * @notice Delegates data to call on the strategy contract.\n * @param callData Data to call the strategy contract with.\n *\n * Requirements:\n * - Sender must have ADMIN role\n */\n function _delegateStrategy(bytes memory callData)\n internal\n returns (bytes memory)\n {\n return Address.functionDelegateCall(s().strategy, callData);\n }\n}\n" + }, + "contracts/lending/ttoken/data.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Role ID used to pull funds for the asset it manages (i.e. TellerDiamond)\nbytes32 constant CONTROLLER = keccak256(\"CONTROLLER\");\n// Role ID used to for accounts to call special methods that modify its state\nbytes32 constant ADMIN = keccak256(\"ADMIN\");\n\nuint256 constant EXCHANGE_RATE_FACTOR = 1e18;\nuint256 constant ONE_HUNDRED_PERCENT = 10000;\n" + }, + "contracts/lending/ttoken/strategies/ITTokenStrategy.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface ITTokenStrategy {\n event StrategyRebalanced(\n string indexed strategyName,\n address indexed sender\n );\n\n /**\n * @notice it returns the total supply of an underlying asset in a Teller token.\n * @return uint256 the underlying supply\n */\n function totalUnderlyingSupply() external returns (uint256);\n\n /**\n * @notice it rebalances the underlying asset held by the Teller Token.\n *\n */\n function rebalance() external;\n\n /**\n * @notice it withdraws amount of tokens in a pool\n * @param amount amount to withdraw\n */\n\n function withdraw(uint256 amount) external;\n}\n" + }, + "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165.sol\";\n\n/**\n * @dev Library used to query support of an interface declared via {IERC165}.\n *\n * Note that these functions return the actual result of the query: they do not\n * `revert` if an interface is not supported. It is up to the caller to decide\n * what to do in these cases.\n */\nlibrary ERC165Checker {\n // As per the EIP-165 spec, no interface should ever match 0xffffffff\n bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;\n\n /**\n * @dev Returns true if `account` supports the {IERC165} interface,\n */\n function supportsERC165(address account) internal view returns (bool) {\n // Any contract that implements ERC165 must explicitly indicate support of\n // InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid\n return _supportsERC165Interface(account, type(IERC165).interfaceId) &&\n !_supportsERC165Interface(account, _INTERFACE_ID_INVALID);\n }\n\n /**\n * @dev Returns true if `account` supports the interface defined by\n * `interfaceId`. Support for {IERC165} itself is queried automatically.\n *\n * See {IERC165-supportsInterface}.\n */\n function supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) {\n // query support of both ERC165 as per the spec and support of _interfaceId\n return supportsERC165(account) &&\n _supportsERC165Interface(account, interfaceId);\n }\n\n /**\n * @dev Returns a boolean array where each value corresponds to the\n * interfaces passed in and whether they're supported or not. This allows\n * you to batch check interfaces for a contract where your expectation\n * is that some interfaces may not be supported.\n *\n * See {IERC165-supportsInterface}.\n *\n * _Available since v3.4._\n */\n function getSupportedInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool[] memory) {\n // an array of booleans corresponding to interfaceIds and whether they're supported or not\n bool[] memory interfaceIdsSupported = new bool[](interfaceIds.length);\n\n // query support of ERC165 itself\n if (supportsERC165(account)) {\n // query support of each interface in interfaceIds\n for (uint256 i = 0; i < interfaceIds.length; i++) {\n interfaceIdsSupported[i] = _supportsERC165Interface(account, interfaceIds[i]);\n }\n }\n\n return interfaceIdsSupported;\n }\n\n /**\n * @dev Returns true if `account` supports all the interfaces defined in\n * `interfaceIds`. Support for {IERC165} itself is queried automatically.\n *\n * Batch-querying can lead to gas savings by skipping repeated checks for\n * {IERC165} support.\n *\n * See {IERC165-supportsInterface}.\n */\n function supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) {\n // query support of ERC165 itself\n if (!supportsERC165(account)) {\n return false;\n }\n\n // query support of each interface in _interfaceIds\n for (uint256 i = 0; i < interfaceIds.length; i++) {\n if (!_supportsERC165Interface(account, interfaceIds[i])) {\n return false;\n }\n }\n\n // all interfaces supported\n return true;\n }\n\n /**\n * @notice Query if a contract implements an interface, does not check ERC165 support\n * @param account The address of the contract to query for support of an interface\n * @param interfaceId The interface identifier, as specified in ERC-165\n * @return true if the contract at account indicates support of the interface with\n * identifier interfaceId, false otherwise\n * @dev Assumes that account contains a contract that supports ERC165, otherwise\n * the behavior of this method is undefined. This precondition can be checked\n * with {supportsERC165}.\n * Interface identification is specified in ERC-165.\n */\n function _supportsERC165Interface(address account, bytes4 interfaceId) private view returns (bool) {\n bytes memory encodedParams = abi.encodeWithSelector(IERC165(account).supportsInterface.selector, interfaceId);\n (bool success, bytes memory result) = account.staticcall{ gas: 30000 }(encodedParams);\n if (result.length < 32) return false;\n return success && abi.decode(result, (bool));\n }\n}\n" + }, + "contracts/lending/ttoken/storage.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { ERC20, IERC20 } from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\n\nstruct Store {\n ERC20 underlying;\n address strategy;\n uint256 totalBorrowed;\n uint256 totalRepaid;\n uint256 totalInterestRepaid;\n uint8 decimals;\n bool restricted;\n}\n\nbytes32 constant POSITION = keccak256(\"ttoken.storage.position\");\n\n/**\n * @notice it saves the Store struct in a hashed slot\n */\nfunction store() pure returns (Store storage s_) {\n bytes32 position = POSITION;\n assembly {\n s_.slot := position\n }\n}\n" + }, + "contracts/lending/ttoken/strategies/compound/TTokenCompoundStrategy_1.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// contracts\nimport {\n RolesMods\n} from \"../../../../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN } from \"../../data.sol\";\n\n// Interfaces\nimport { ICErc20 } from \"../../../../shared/interfaces/ICErc20.sol\";\nimport { TTokenStrategy } from \"../TTokenStrategy.sol\";\n\n// Libraries\nimport {\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport { NumbersLib } from \"../../../../shared/libraries/NumbersLib.sol\";\n\n// Storage\nimport \"../../storage.sol\" as TokenStorage;\nimport \"./storage.sol\" as CompoundStorage;\n\ncontract TTokenCompoundStrategy_1 is RolesMods, TTokenStrategy {\n /**\n * @dev it creates a reference to the TToken storage\n */\n function() pure returns (TokenStorage.Store storage)\n private constant tokenStore = TokenStorage.store;\n\n /**\n * @dev it creates a reference to the Compound storage\n */\n function() pure returns (CompoundStorage.Store storage)\n private constant compoundStore = CompoundStorage.store;\n\n string public constant NAME = \"CompoundStrategy_1\";\n\n /* External Functions */\n\n /**\n * @notice it returns the total supply of an underlying asset in a Teller token.\n * @return uint256 the underlying supply\n */\n function totalUnderlyingSupply() external override returns (uint256) {\n return\n tokenStore().underlying.balanceOf(address(this)) +\n compoundStore().cToken.balanceOfUnderlying(address(this));\n }\n\n /**\n * @notice Rebalances the underlying asset held by the Teller Token.\n *\n * This strategy looks at the ratio of held underlying asset balance and balance deposited into\n * Compound. Based on the store {balanceRatioMin} and {balanceRatioMax} values, will deposit\n * (storedRatio > balanceRatioMax) or withdraw to keep the ratio within that range.\n */\n function rebalance() public override {\n (uint256 storedBal, uint256 compoundBal, uint16 storedRatio) =\n _getBalanceInfo();\n if (storedRatio > compoundStore().balanceRatioMax) {\n // Calculate median ratio to rebalance to\n uint16 medianRatio =\n (compoundStore().balanceRatioMax +\n compoundStore().balanceRatioMin) / 2;\n uint256 requiredBal =\n NumbersLib.percent(storedBal + compoundBal, medianRatio);\n uint256 amountToDeposit = storedBal - requiredBal;\n\n // Allow Compound to take underlying tokens\n SafeERC20.safeIncreaseAllowance(\n tokenStore().underlying,\n address(compoundStore().cToken),\n amountToDeposit\n );\n\n // Deposit tokens into Compound\n compoundStore().cToken.mint(amountToDeposit);\n\n emit StrategyRebalanced(NAME, msg.sender);\n } else if (storedRatio < compoundStore().balanceRatioMin) {\n // Withdraw tokens from Compound\n _withdraw(0, storedBal, compoundBal, storedRatio);\n\n emit StrategyRebalanced(NAME, msg.sender);\n }\n }\n\n /**\n * @notice Rebalances the TToken funds by indicating a minimum {amount} of underlying tokens that must be present\n * after the call.\n * @notice If the minimum amount is present, no rebalance happens.\n * @param amount Amount of underlying tokens that must be available.\n */\n function withdraw(uint256 amount) external override {\n (uint256 storedBal, uint256 compoundBal, uint16 storedRatio) =\n _getBalanceInfo();\n if (storedBal < amount) {\n _withdraw(amount, storedBal, compoundBal, storedRatio);\n }\n }\n\n /**\n * @notice it gets balances and the current ratio of the underlying asset stored on the TToken.\n * @return storedBalance_ returns the total stored balance of the current underlying token\n * @return compoundBalance_ returns the total stored balance\n * @return storedRatio_ ratio of current storedBalance_ over storedBalance_ and compoundBalance_\n */\n function _getBalanceInfo()\n internal\n returns (\n uint256 storedBalance_,\n uint256 compoundBalance_,\n uint16 storedRatio_\n )\n {\n storedBalance_ = tokenStore().underlying.balanceOf(address(this));\n compoundBalance_ = compoundStore().cToken.balanceOfUnderlying(\n address(this)\n );\n storedRatio_ = NumbersLib.ratioOf(\n storedBalance_,\n storedBalance_ + compoundBalance_\n );\n }\n\n /**\n * @notice it rebalances funds stored on the TToken by indicating an extra {amount} to withdraw.\n */\n function _withdraw(\n uint256 amount,\n uint256 storedBal,\n uint256 compoundBal,\n uint16 storedRatio\n ) internal {\n // Calculate amount to rebalance\n uint16 medianRatio =\n (compoundStore().balanceRatioMax +\n compoundStore().balanceRatioMin) / 2;\n uint256 requiredBal =\n NumbersLib.percent(\n storedBal + compoundBal - amount,\n medianRatio - storedRatio\n );\n uint256 redeemAmount = requiredBal - storedBal + amount;\n // Withdraw tokens from Compound if needed\n compoundStore().cToken.redeemUnderlying(redeemAmount);\n }\n\n /**\n * @notice Sets the Compound token that should be used to manage the underlying Teller Token asset.\n * @param cTokenAddress Address of the Compound token that has the same underlying asset as the TToken.\n * @param balanceRatioMin Percentage indicating the _ limit of underlying token balance should remain on the TToken\n * @param balanceRatioMax Percentage indicating the _ limit of underlying token balance should remain on the TToken\n */\n function init(\n address cTokenAddress,\n uint16 balanceRatioMin,\n uint16 balanceRatioMax\n ) external {\n compoundStore().cToken = ICErc20(cTokenAddress);\n compoundStore().balanceRatioMin = balanceRatioMin;\n compoundStore().balanceRatioMax = balanceRatioMax;\n }\n}\n" + }, + "contracts/lending/ttoken/strategies/TTokenStrategy.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { ERC165 } from \"@openzeppelin/contracts/utils/introspection/ERC165.sol\";\nimport { ITTokenStrategy } from \"./ITTokenStrategy.sol\";\n\nabstract contract TTokenStrategy is ITTokenStrategy, ERC165 {\n /**\n * @notice it checks if interface is supported according to the ERC165 standard\n * @param interfaceId Id of the interface in question\n */\n function supportsInterface(bytes4 interfaceId)\n public\n view\n override\n returns (bool)\n {\n return\n ERC165.supportsInterface(interfaceId) ||\n interfaceId == type(ITTokenStrategy).interfaceId;\n }\n}\n" + }, + "contracts/lending/ttoken/strategies/compound/storage.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { ICErc20 } from \"../../../../shared/interfaces/ICErc20.sol\";\n\nstruct Store {\n ICErc20 cToken;\n uint16 balanceRatioMax;\n uint16 balanceRatioMin;\n}\n\nbytes32 constant POSITION = keccak256(\n \"ttoken.strategy.compound.storage.position\"\n);\n\nfunction store() pure returns (Store storage s_) {\n bytes32 position = POSITION;\n assembly {\n s_.slot := position\n }\n}\n" + }, + "@openzeppelin/contracts/utils/introspection/ERC165.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n *\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\n */\nabstract contract ERC165 is IERC165 {\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return interfaceId == type(IERC165).interfaceId;\n }\n}\n" + }, + "contracts/settings/asset/libraries/AssetYVaultLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../../shared/libraries/CacheLib.sol\";\nimport { IVault } from \"../../../escrow/dapps/interfaces/IVault.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions for Yearn vault asset setting.\n *\n * @author develop@teller.finance\n */\nlibrary AssetYVaultLib {\n bytes32 private constant NAME = keccak256(\"yVault\");\n\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n function get(address asset) internal view returns (IVault) {\n return IVault(s(asset).addresses[NAME]);\n }\n\n function set(address asset, address newValue) internal {\n s(asset).addresses[NAME] = newValue;\n }\n}\n" + }, + "contracts/escrow/dapps/YearnFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Storage\nimport { DappMods } from \"./DappMods.sol\";\nimport { PausableMods } from \"../../settings/pausable/PausableMods.sol\";\nimport { LibDapps } from \"./libraries/LibDapps.sol\";\nimport { LibEscrow } from \"../libraries/LibEscrow.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport { IVault } from \"./interfaces/IVault.sol\";\n\ncontract YearnFacet is PausableMods, DappMods {\n using SafeERC20 for IERC20;\n\n /**\n @notice This event is emitted when a yVault deposit is invoked successfully\n @param iVault The address of the yVault\n @param amount The amount of funds to deposit\n @param tokenBalanceBeforeDeposit The balance of tokens held after depositing\n @param tokenBalanceAfterDeposit The balance of tokens held after depositing\n */\n event YearnDeposited(\n address tokenAddress,\n address iVault,\n uint256 amount,\n uint256 tokenBalanceBeforeDeposit,\n uint256 tokenBalanceAfterDeposit\n );\n\n /**\n @notice This event is emitted when a yVault withdraw is invoked successfully\n @param underlyingToken The address of the underlying token of the vault\n @param iVault The address of the yVault\n @param amount The amount of funds to withdraw\n @param tokenBalanceBeforeWithdrawal The balance of tokens held before withdrawal\n @param tokenBalanceAfterWithdrawal The balance of tokens held after withdrawal\n */\n event YearnWithdrawn(\n address underlyingToken,\n address iVault,\n uint256 amount,\n uint256 tokenBalanceBeforeWithdrawal,\n uint256 tokenBalanceAfterWithdrawal\n );\n\n /**\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\n @param loanID The id of the loan being used\n @param tokenAddress The address of the token being deposited\n @param amount The amount of tokens to be deposited into the vault\n */\n function yearnDeposit(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n IVault iVault = LibDapps.getYVault(tokenAddress);\n uint256 tokenBalanceBeforeDeposit = iVault.balanceOf(address(this));\n IERC20(tokenAddress).safeApprove(address(iVault), amount);\n\n bytes memory callData = abi.encode(IVault.deposit.selector, amount);\n LibDapps.s().loanEscrows[loanID].callDapp(address(iVault), callData);\n\n uint256 tokenBalanceAfterDeposit = iVault.balanceOf(address(this));\n require(\n tokenBalanceAfterDeposit > tokenBalanceBeforeDeposit,\n \"YEARN_BALANCE_NOT_INCREASED\"\n );\n\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n LibEscrow.tokenUpdated(loanID, address(iVault));\n\n emit YearnDeposited(\n tokenAddress,\n address(iVault),\n amount,\n tokenBalanceBeforeDeposit,\n tokenBalanceAfterDeposit\n );\n }\n\n /**\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\n @param loanID the id of the loan being used\n @param tokenAddress The address of the token being deposited\n @param amount The amount of tokens to be deposited into the vault\n */\n function yearnWithdraw(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n IVault iVault = LibDapps.getYVault(tokenAddress);\n uint256 price = iVault.getPricePerShare();\n uint256 shares = amount / price;\n uint256 tokenBalanceBeforeWithdrawal =\n IERC20(tokenAddress).balanceOf(address(this));\n require(\n shares >= iVault.balanceOf(address(this)),\n \"INSUFFICIENT_DEPOSIT\"\n );\n\n bytes memory callData = abi.encode(IVault.withdraw.selector, shares);\n LibDapps.s().loanEscrows[loanID].callDapp(address(iVault), callData);\n\n uint256 tokenBalanceAfterWithdrawal =\n IERC20(tokenAddress).balanceOf(address(this));\n require(\n tokenBalanceAfterWithdrawal > tokenBalanceBeforeWithdrawal,\n \"WITHDRAWAL_UNSUCCESSFUL\"\n );\n\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n LibEscrow.tokenUpdated(loanID, address(iVault));\n\n emit YearnWithdrawn(\n iVault.token(),\n address(iVault),\n amount,\n tokenBalanceBeforeWithdrawal,\n tokenBalanceAfterWithdrawal\n );\n }\n\n /**\n @notice Redeems all funds from a yVault from a previous deposit\n @param loanID the id of the loan being used\n @param tokenAddress The address of the token being deposited\n */\n function yearnWithdrawAll(uint256 loanID, address tokenAddress)\n public\n paused(\"\", false)\n onlyBorrower(loanID)\n {\n IVault iVault = LibDapps.getYVault(tokenAddress);\n uint256 tokenBalanceBeforeWithdrawal =\n IERC20(tokenAddress).balanceOf(address(this));\n\n bytes memory callData = abi.encode(IVault.withdrawAll.selector);\n LibDapps.s().loanEscrows[loanID].callDapp(address(iVault), callData);\n\n uint256 tokenBalanceAfterWithdrawal =\n IERC20(tokenAddress).balanceOf(address(this));\n require(\n tokenBalanceAfterWithdrawal > tokenBalanceBeforeWithdrawal,\n \"WITHDRAWAL_UNSUCCESSFUL\"\n );\n\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n LibEscrow.tokenUpdated(loanID, address(iVault));\n\n emit YearnWithdrawn(\n iVault.token(),\n address(iVault),\n tokenBalanceBeforeWithdrawal,\n tokenBalanceBeforeWithdrawal,\n tokenBalanceAfterWithdrawal\n );\n }\n}\n" + }, + "contracts/escrow/dapps/PoolTogetherFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Storage\nimport { DappMods } from \"./DappMods.sol\";\nimport { PausableMods } from \"../../settings/pausable/PausableMods.sol\";\nimport { LibDapps } from \"./libraries/LibDapps.sol\";\nimport { LibEscrow } from \"../libraries/LibEscrow.sol\";\nimport {\n AssetPPoolLib\n} from \"../../settings/asset/libraries/AssetPPoolLib.sol\";\nimport { PoolTogetherLib } from \"./libraries/PoolTogetherLib.sol\";\nimport { PrizePoolInterface } from \"./interfaces/PrizePoolInterface.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\n\ncontract PoolTogetherFacet is PausableMods, DappMods {\n using SafeERC20 for IERC20;\n /**\n * @notice This event is emitted every time Pool Together depositTo is invoked successfully.\n * @param tokenAddress address of the underlying token.\n * @param ticketAddress pool ticket token address.\n * @param amount amount of tokens deposited.\n * @param tokenBalance underlying token balance after depositing.\n * @param creditBalanceAfter pool together credit after depositing.\n */\n event PoolTogetherDeposited(\n address indexed tokenAddress,\n address indexed ticketAddress,\n uint256 amount,\n uint256 tokenBalance,\n uint256 creditBalanceAfter\n );\n\n /**\n * @notice This event is emitted every time Pool Together withdrawInstantlyFrom is invoked successfully.\n * @param tokenAddress address of the underlying token.\n * @param ticketAddress pool ticket token address.\n * @param amount amount of tokens to Redeem.\n * @param tokenBalance underlying token balance after Redeem.\n * @param creditBalanceAfter pool together credit after depositing.\n */\n event PoolTogetherWithdrawal(\n address indexed tokenAddress,\n address indexed ticketAddress,\n uint256 amount,\n uint256 tokenBalance,\n uint256 creditBalanceAfter\n );\n\n /**\n * @notice This function deposits the users funds into a Pool Together Prize Pool for a ticket.\n * @param loanID id of the loan being used in the dapp\n * @param tokenAddress address of the token.\n * @param amount of tokens to deposit.\n */\n function poolTogetherDepositTicket(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n require(\n LibEscrow.balanceOf(loanID, tokenAddress) >= amount,\n \"POOL_INSUFFICIENT_UNDERLYING\"\n );\n\n PrizePoolInterface prizePool = AssetPPoolLib.get(tokenAddress);\n\n address ticketAddress = PoolTogetherLib.getTicketAddress(tokenAddress);\n uint256 balanceBefore = LibEscrow.balanceOf(loanID, ticketAddress);\n IERC20(tokenAddress).safeApprove(address(prizePool), amount);\n\n bytes memory callData =\n abi.encode(\n PrizePoolInterface.depositTo.selector,\n address(this),\n amount,\n ticketAddress,\n address(this)\n );\n LibDapps.s().loanEscrows[loanID].callDapp(address(prizePool), callData);\n\n uint256 balanceAfter = LibEscrow.balanceOf(loanID, ticketAddress);\n require(balanceAfter > balanceBefore, \"DEPOSIT_ERROR\");\n\n LibEscrow.tokenUpdated(loanID, address(ticketAddress));\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n\n emit PoolTogetherDeposited(\n tokenAddress,\n ticketAddress,\n amount,\n balanceBefore,\n balanceAfter\n );\n }\n\n /**\n * @notice This function withdraws the users funds from a Pool Together Prize Pool.\n * @param loanID id of the loan being used in the dapp\n * @param tokenAddress address of the token.\n * @param amount The amount of tokens to withdraw.\n */\n function poolTogetherWithdraw(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n PrizePoolInterface prizePool = AssetPPoolLib.get(tokenAddress);\n\n address ticketAddress = PoolTogetherLib.getTicketAddress(tokenAddress);\n uint256 balanceBefore = LibEscrow.balanceOf(loanID, ticketAddress);\n\n (\n uint256 maxExitFee, /* uint256 burnedCredit */\n\n ) =\n prizePool.calculateEarlyExitFee(\n address(this),\n ticketAddress,\n amount\n );\n\n bytes memory callData =\n abi.encode(\n PrizePoolInterface.withdrawInstantlyFrom.selector,\n address(this),\n amount,\n ticketAddress,\n maxExitFee\n );\n LibDapps.s().loanEscrows[loanID].callDapp(address(prizePool), callData);\n\n uint256 balanceAfter = LibEscrow.balanceOf(loanID, ticketAddress);\n require(balanceAfter < balanceBefore, \"WITHDRAW_ERROR\");\n\n LibEscrow.tokenUpdated(loanID, address(ticketAddress));\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n\n emit PoolTogetherWithdrawal(\n tokenAddress,\n ticketAddress,\n amount,\n balanceBefore,\n balanceAfter\n );\n }\n\n /**\n * @notice This function withdraws the users funds from a Pool Together Prize Pool.\n * @param loanID id of the loan being used in the dapp\n * @param tokenAddress address of the token.\n */\n function poolTogetherWithdrawAll(uint256 loanID, address tokenAddress)\n public\n paused(\"\", false)\n onlyBorrower(loanID)\n {\n PrizePoolInterface prizePool = AssetPPoolLib.get(tokenAddress);\n\n address ticketAddress = PoolTogetherLib.getTicketAddress(tokenAddress);\n\n uint256 balanceBefore = LibEscrow.balanceOf(loanID, ticketAddress);\n\n (uint256 maxExitFee, ) =\n prizePool.calculateEarlyExitFee(\n address(this),\n ticketAddress,\n balanceBefore\n );\n\n bytes memory callData =\n abi.encode(\n PrizePoolInterface.withdrawInstantlyFrom.selector,\n address(this),\n balanceBefore,\n ticketAddress,\n maxExitFee\n );\n LibDapps.s().loanEscrows[loanID].callDapp(address(prizePool), callData);\n\n uint256 balanceAfter = LibEscrow.balanceOf(loanID, ticketAddress);\n require(balanceAfter < balanceBefore, \"WITHDRAW_ERROR\");\n\n LibEscrow.tokenUpdated(loanID, address(ticketAddress));\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n\n emit PoolTogetherWithdrawal(\n tokenAddress,\n ticketAddress,\n balanceBefore,\n LibEscrow.balanceOf(loanID, tokenAddress),\n balanceAfter\n );\n }\n}\n" + }, + "contracts/settings/asset/libraries/AssetPPoolLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../../shared/libraries/CacheLib.sol\";\nimport {\n PrizePoolInterface\n} from \"../../../escrow/dapps/interfaces/PrizePoolInterface.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions for Pool together asset setting.\n *\n * @author develop@teller.finance\n */\nlibrary AssetPPoolLib {\n bytes32 private constant NAME = keccak256(\"pPoolAddress\");\n\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n function get(address asset) internal view returns (PrizePoolInterface) {\n return PrizePoolInterface(s(asset).addresses[NAME]);\n }\n\n function set(address asset, address newValue) internal {\n s(asset).addresses[NAME] = newValue;\n }\n}\n" + }, + "contracts/escrow/dapps/libraries/PoolTogetherLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Interfaces\nimport {\n AssetPPoolLib\n} from \"../../../settings/asset/libraries/AssetPPoolLib.sol\";\n\nlibrary PoolTogetherLib {\n /**\n * @notice Grabs the controlled ticket token address for the prize pool\n * @notice The pool underlying address must match the supplied token address.\n * @param tokenAddress The token address to get the cToken for.\n * @return The address of the ticket token contract.\n */\n function getTicketAddress(address tokenAddress)\n internal\n view\n returns (address)\n {\n return AssetPPoolLib.get(tokenAddress).tokens()[1];\n }\n}\n" + }, + "contracts/escrow/dapps/interfaces/PrizePoolInterface.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title Escrows assets and deposits them into a yield source. Exposes interest to Prize Strategy. Users deposit and withdraw from this contract to participate in Prize Pool.\n/// @notice Accounting is managed using Controlled Tokens, whose mint and burn functions can only be called by this contract.\n/// @dev Must be inherited to provide specific yield-bearing asset control, such as Compound cTokens\ninterface PrizePoolInterface {\n /// @notice Deposit assets into the Prize Pool in exchange for tokens\n /// @param to The address receiving the newly minted tokens\n /// @param amount The amount of assets to deposit\n /// @param controlledToken The address of the type of token the user is minting\n /// @param referrer The referrer of the deposit\n function depositTo(\n address to,\n uint256 amount,\n address controlledToken,\n address referrer\n ) external;\n\n /// @notice Withdraw assets from the Prize Pool instantly. A fairness fee may be charged for an early exit.\n /// @param from The address to redeem tokens from.\n /// @param amount The amount of tokens to redeem for assets.\n /// @param controlledToken The address of the token to redeem (i.e. ticket or sponsorship)\n /// @param maximumExitFee The maximum exit fee the caller is willing to pay. This should be pre-calculated by the calculateExitFee() fxn.\n /// @return The actual exit fee paid\n function withdrawInstantlyFrom(\n address from,\n uint256 amount,\n address controlledToken,\n uint256 maximumExitFee\n ) external returns (uint256);\n\n /// @notice Returns the balance that is available to award.\n /// @dev captureAwardBalance() should be called first\n /// @return The total amount of assets to be awarded for the current prize\n function awardBalance() external view returns (uint256);\n\n /// @notice Calculates the early exit fee for the given amount\n /// @param from The user who is withdrawing\n /// @param controlledToken The type of collateral being withdrawn\n /// @param amount The amount of collateral to be withdrawn\n /// @return exitFee The exit fee\n /// @return burnedCredit The user's credit that was burned\n function calculateEarlyExitFee(\n address from,\n address controlledToken,\n uint256 amount\n ) external returns (uint256 exitFee, uint256 burnedCredit);\n\n /// @notice Estimates the amount of time it will take for a given amount of funds to accrue the given amount of credit.\n /// @param _principal The principal amount on which interest is accruing\n /// @param _interest The amount of interest that must accrue\n /// @return durationSeconds The duration of time it will take to accrue the given amount of interest, in seconds.\n function estimateCreditAccrualTime(\n address _controlledToken,\n uint256 _principal,\n uint256 _interest\n ) external view returns (uint256 durationSeconds);\n\n /// @notice Returns the credit balance for a given user. Not that this includes both minted credit and pending credit.\n /// @param user The user whose credit balance should be returned\n /// @return The balance of the users credit\n function balanceOfCredit(address user, address controlledToken)\n external\n returns (uint256);\n\n /// @notice Returns the credit rate of a controlled token\n /// @param controlledToken The controlled token to retrieve the credit rates for\n /// @return creditLimitMantissa The credit limit fraction. This number is used to calculate both the credit limit and early exit fee.\n /// @return creditRateMantissa The credit rate. This is the amount of tokens that accrue per second.\n function creditPlanOf(address controlledToken)\n external\n view\n returns (uint128 creditLimitMantissa, uint128 creditRateMantissa);\n\n /// @dev Returns the address of the underlying ERC20 asset\n /// @return The address of the asset\n function token() external view returns (address);\n\n /// @notice An array of the Tokens controlled by the Prize Pool (ie. Tickets, Sponsorship)\n /// @return An array of controlled token addresses\n function tokens() external view returns (address[] memory);\n\n /// @notice The total of all controlled tokens and timelock.\n /// @return The current total of all tokens and timelock.\n function accountedBalance() external view returns (uint256);\n}\n" + }, + "contracts/nft/distributor/internal/distributor.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../store.sol\";\n\n// Libraries\nimport \"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\";\n\n// Utils\nimport { ClaimNFTRequest } from \"../data.sol\";\n\ncontract int_distributor_NFT_v1 is sto_NFTDistributor {\n /**\n * @notice It checks the merkle root for a tier if it has already been claimed.\n * @param merkleIndex Index of the tier.\n * @param nodeIndex Index of the node in the merkle root.\n */\n function _setClaimed(uint256 merkleIndex, uint256 nodeIndex) internal {\n uint256 claimedWordIndex = nodeIndex / 256;\n uint256 claimedBitIndex = nodeIndex % 256;\n distributorStore().claimedBitMap[merkleIndex][claimedWordIndex] =\n distributorStore().claimedBitMap[merkleIndex][claimedWordIndex] |\n (1 << claimedBitIndex);\n }\n\n /**\n * @notice It checks the merkle root for a tier if it has already been claimed.\n * @param merkleIndex Index of the tier.\n * @param nodeIndex Index of the node in the merkle root.\n * @return claimed_ returns a boolean to check if the tier has already been claimed\n */\n function _isClaimed(uint256 merkleIndex, uint256 nodeIndex)\n internal\n view\n returns (bool)\n {\n uint256 claimedWordIndex = nodeIndex / 256;\n uint256 claimedBitIndex = nodeIndex % 256;\n uint256 claimedWord =\n distributorStore().claimedBitMap[merkleIndex][claimedWordIndex];\n uint256 mask = (1 << claimedBitIndex);\n return claimedWord & mask == mask;\n }\n\n /**\n * @notice it verifies the request's merkle proof with the merkle root in order to claim an NFT\n * @param account the account's address to be hashed and verified with the claim\n * @param request the request with the merkle proof to verify\n */\n function _verifyProof(address account, ClaimNFTRequest memory request)\n internal\n view\n returns (bool verified)\n {\n verified = MerkleProof.verify(\n request.merkleProof,\n distributorStore().merkleRoots[request.merkleIndex].merkleRoot,\n keccak256(\n abi.encodePacked(request.nodeIndex, account, request.amount)\n )\n );\n }\n}\n" + }, + "contracts/nft/distributor/external/distributor.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../store.sol\";\nimport \"../internal/distributor.sol\";\n\ncontract ext_distributor_NFT_v1 is sto_NFTDistributor, int_distributor_NFT_v1 {\n /**\n * @notice It gets the TellerNFT diamond instance used to mint.\n * @return nft_ return the NFT instance\n */\n function nft() external view returns (ITellerNFT nft_) {\n nft_ = distributorStore().nft;\n }\n\n /**\n * @notice It gets the merkle roots for NFTs it can distribute.\n * @return roots_ returns the merkle\n */\n function getMerkleRoots()\n external\n view\n returns (MerkleRoot[] memory roots_)\n {\n roots_ = distributorStore().merkleRoots;\n }\n\n /**\n * @notice It checks the merkle root for a tier if it has already been claimed.\n * @param merkleIndex Index of the tier.\n * @param nodeIndex Index of the node in the merkle root.\n * @return claimed_ returns a boolean to check if the tier has already been claimed\n */\n function isClaimed(uint256 merkleIndex, uint256 nodeIndex)\n external\n view\n returns (bool claimed_)\n {\n claimed_ = _isClaimed(merkleIndex, nodeIndex);\n }\n}\n\ncontract ext_distributor_NFT is ext_distributor_NFT_v1 {}\n" + }, + "contracts/nft/distributor/entry/claim.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../store.sol\";\nimport \"../../../contexts/access-control/modifiers/authorized.sol\";\n\nimport \"../internal/distributor.sol\";\n\n// Utils\nimport { ClaimNFTRequest, ADMIN, DistributorEvents } from \"../data.sol\";\n\ncontract ent_claim_NFTDistributor_v1 is\n sto_NFTDistributor,\n int_distributor_NFT_v1,\n mod_authorized_AccessControl_v1\n{\n /**\n * @notice Claims TellerNFTs for a given verifiable merkle proofs for each tier.\n * @param account The address to claim NFTs on behalf.\n * @param requests An array requests data generated from the merkle tree.\n *\n * Requirements:\n * - Node in the merkle root must not be claimed already\n * - Proof of the node must match the merkle tree\n */\n function claim(address account, ClaimNFTRequest[] calldata requests)\n external\n {\n for (uint256 i; i < requests.length; i++) {\n require(\n !_isClaimed(requests[i].merkleIndex, requests[i].nodeIndex),\n \"TellerNFT Distributor: already claimed\"\n );\n require(\n _verifyProof(account, requests[i]),\n \"TellerNFT Distributor: invalid proof\"\n );\n\n // Mark it claimed and send the token.\n _setClaimed(requests[i].merkleIndex, requests[i].nodeIndex);\n uint256 tierIndex =\n distributorStore().merkleRoots[requests[i].merkleIndex]\n .tierIndex;\n for (uint256 j; j < requests[i].amount; j++) {\n distributorStore().nft.mint(tierIndex, account);\n }\n\n //Find the newly minted tokens and add to memory\n uint256[] memory postOwnedTokens =\n distributorStore().nft.getOwnedTokens(account);\n\n uint256[] memory newlyMintedTokenIds =\n new uint256[](requests[i].amount);\n\n uint256 offset = postOwnedTokens.length - requests[i].amount;\n\n for (uint256 k; k < requests[i].amount; k++) {\n newlyMintedTokenIds[k] = postOwnedTokens[k + offset];\n }\n\n //For each newly minted token, set the tier index in the Dictionary contract\n distributorStore().dictionary.setTokenTierForTokenIds(\n newlyMintedTokenIds,\n tierIndex\n );\n }\n\n emit DistributorEvents.Claimed(account);\n }\n\n function setNFTDictionaryAddress(address dictionary)\n external\n authorized(ADMIN, msg.sender)\n {\n distributorStore().dictionary = TellerNFTDictionary(dictionary);\n }\n}\n" + }, + "contracts/nft/distributor/entry/add-merkle.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../store.sol\";\nimport \"../../../contexts/access-control/modifiers/authorized.sol\";\n\n// Utils\nimport { DistributorEvents, ADMIN, MerkleRoot } from \"../data.sol\";\n\ncontract ent_addMerkle_NFTDistributor_v1 is\n sto_NFTDistributor,\n mod_authorized_AccessControl_v1\n{\n /**\n * @notice Adds a new merkle to be able to claim NFTs.\n * @param tierIndex Index of NFT tier to assign merkle for.\n * @param merkleRoot The merkle root to assign to the new tier.\n *\n * Requirements:\n * - Caller must be an admin\n */\n function addMerkle(uint256 tierIndex, bytes32 merkleRoot)\n external\n authorized(ADMIN, msg.sender)\n {\n MerkleRoot storage merkle = distributorStore().merkleRoots.push();\n merkle.tierIndex = tierIndex;\n merkle.merkleRoot = merkleRoot;\n\n emit DistributorEvents.MerkleAdded(\n distributorStore().merkleRoots.length - 1\n );\n }\n}\n" + }, + "contracts/contexts2/access-control/ownership/OwnerLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlStorageLib, AccessControlStorage } from \"../storage.sol\";\n\nlibrary OwnerLib {\n function s() private pure returns (AccessControlStorage storage) {\n return AccessControlStorageLib.store();\n }\n\n /**\n * @dev Emitted when {owner} is set for {account}.\n */\n event OwnerSet(address indexed account, address indexed owner);\n\n /**\n * @dev Emitted when new {owner} is given ownership of {account}.\n */\n event OwnerTransferred(\n address indexed account,\n address indexed owner,\n address indexed prevOwner\n );\n\n /**\n * @notice Gets the owner for an address.\n * @param account Address to check ownership of.\n */\n function ownerOf(address account) internal view returns (address) {\n return AccessControlStorageLib.store().owners[account];\n }\n\n /**\n * @notice Sets an owner for an address.\n * @dev Should only use when circumventing admin checking.\n * @param account Address to set ownership of.\n * @param owner Address to set ownership of {account} to.\n */\n function setOwner(address account, address owner) internal {\n s().owners[account] = owner;\n emit OwnerSet(account, owner);\n }\n\n /**\n * @notice Transfers ownership of an address.\n * @dev Should only use when circumventing admin checking.\n * @param account Address to transfer ownership of.\n * @param newOwner Address to transfer ownership of {account} to.\n */\n function transferOwner(address account, address newOwner) internal {\n s().owners[account] = newOwner;\n emit OwnerTransferred(account, newOwner, msg.sender);\n }\n}\n" + }, + "contracts/contexts2/access-control/ownership/OwnerMods.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { OwnerLib } from \"./OwnerLib.sol\";\n\nabstract contract OwnerMods {\n modifier onlyOwner(address addr) {\n require(\n OwnerLib.ownerOf(addr) == msg.sender,\n \"AccessControl: not owner\"\n );\n _;\n }\n}\n" + }, + "contracts/contexts2/access-control/ownership/OwnerFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlStorageLib } from \"../storage.sol\";\nimport { OwnerLib } from \"./OwnerLib.sol\";\nimport { RolesMods } from \"../roles/RolesMods.sol\";\nimport { ADMIN } from \"../../../shared/roles.sol\";\n\ncontract OwnerFacet is RolesMods {\n /**\n * @notice Sets an owner for an address.\n * @param account Address to set ownership of.\n * @param owner Address to set ownership of {account} to.\n *\n * Requirements:\n * - Sender must be role admin.\n */\n function setOwner(address account, address owner)\n external\n authorized(ADMIN, msg.sender)\n {\n require(\n OwnerLib.ownerOf(account) == address(0),\n \"AccessControl: owner already set\"\n );\n OwnerLib.setOwner(account, owner);\n }\n\n /**\n * @notice Transfers ownership of an address.\n * @param account Address to transfer ownership of.\n * @param owner Address to transfer ownership of {account} to.\n *\n * Requirements:\n * - Sender must be role admin.\n */\n function transferOwner(address account, address owner)\n external\n authorized(ADMIN, msg.sender)\n {\n require(\n OwnerLib.ownerOf(account) == msg.sender,\n \"AccessControl: not owner\"\n );\n OwnerLib.transferOwner(account, owner);\n }\n}\n" + }, + "contracts/escrow/dapps/AaveFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Storage\nimport { DappMods } from \"./DappMods.sol\";\nimport { PausableMods } from \"../../settings/pausable/PausableMods.sol\";\nimport { LibDapps } from \"./libraries/LibDapps.sol\";\nimport { LibEscrow } from \"../libraries/LibEscrow.sol\";\nimport { IAToken } from \"./interfaces/IAToken.sol\";\nimport { IAaveLendingPool } from \"./interfaces/IAaveLendingPool.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\n\ncontract AaveFacet is PausableMods, DappMods {\n using SafeERC20 for IERC20;\n /**\n @notice This event is emitted every time Aave deposit is invoked successfully.\n @param tokenAddress address of the underlying token.\n @param aTokenAddress aave token address.\n @param amount amount of tokens to Deposit.\n @param aTokenBalanceBeforeDeposit aTokens balance after Deposit.\n @param aTokenBalanceAfterDeposit aTokens balance after Deposit.\n */\n event AaveDeposited(\n address indexed tokenAddress,\n address indexed aTokenAddress,\n uint256 amount,\n uint256 aTokenBalanceBeforeDeposit,\n uint256 aTokenBalanceAfterDeposit\n );\n\n /**\n @notice This event is emitted every time Aave redeem is invoked successfully.\n @param tokenAddress address of the underlying token.\n @param aTokenAddress aave token address.\n @param amount amount of tokens to Withdrawal.\n @param aTokenBalanceBeforeDeposit aTokens balance after Withdrawal.\n @param aTokenBalanceAfterWithdrawal aTokens balance after Withdrawal.\n */\n event AaveWithdrawn(\n address indexed tokenAddress,\n address indexed aTokenAddress,\n uint256 amount,\n uint256 aTokenBalanceBeforeDeposit,\n uint256 aTokenBalanceAfterWithdrawal\n );\n\n /**\n @notice The deposit, the aToken needs to be approved to have access to the token balance\n @param loanID id of the loan being used in the dapp\n @param tokenAddress address of the token\n @param amount amount of tokens to deposit\n */\n function aaveDeposit(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n IAaveLendingPool aaveLendingPool = LibDapps.getAaveLendingPool();\n IAToken aToken = LibDapps.getAToken(tokenAddress);\n uint256 aTokenBalanceBeforeDeposit = aToken.balanceOf(address(this));\n IERC20(tokenAddress).safeApprove(address(aaveLendingPool), amount);\n\n bytes memory callData =\n abi.encode(\n IAaveLendingPool.deposit.selector,\n tokenAddress,\n amount,\n address(this),\n 0\n );\n LibDapps.s().loanEscrows[loanID].callDapp(\n address(aaveLendingPool),\n callData\n );\n\n uint256 aTokenBalanceAfterDeposit = aToken.balanceOf(address(this));\n require(\n aTokenBalanceAfterDeposit > aTokenBalanceBeforeDeposit,\n \"AAVE_BALANCE_NOT_INCREASED\"\n );\n\n LibEscrow.tokenUpdated(loanID, address(aToken));\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n\n emit AaveDeposited(\n tokenAddress,\n address(aToken),\n amount,\n aTokenBalanceBeforeDeposit,\n aTokenBalanceAfterDeposit\n );\n }\n\n /**\n @notice This function withdraws the user's aTokens for a specific amount\n @param loanID id of the loan being used in the dapp\n @param tokenAddress address of the token\n @param amount amount of the underlying tokens to withdraw\n */\n function aaveWithdraw(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n IAToken aToken = LibDapps.getAToken(tokenAddress);\n IAaveLendingPool aaveLendingPool = LibDapps.getAaveLendingPool();\n uint256 aTokenBalanceBeforeWithdraw = aToken.balanceOf(address(this));\n require(\n aTokenBalanceBeforeWithdraw >= amount,\n \"NO_BALANCE_TO_WITHDRAW\"\n );\n\n bytes memory callData =\n abi.encode(\n IAaveLendingPool.withdraw.selector,\n tokenAddress,\n amount,\n address(this)\n );\n LibDapps.s().loanEscrows[loanID].callDapp(\n address(aaveLendingPool),\n callData\n );\n\n uint256 aTokenBalanceAfterWithdraw = aToken.balanceOf(address(this));\n require(\n aTokenBalanceAfterWithdraw < aTokenBalanceBeforeWithdraw,\n \"AAVE_WITHDRAWAL_ERROR\"\n );\n\n LibEscrow.tokenUpdated(loanID, address(aToken));\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n\n emit AaveWithdrawn(\n tokenAddress,\n address(aToken),\n amount,\n aTokenBalanceBeforeWithdraw,\n aTokenBalanceAfterWithdraw\n );\n }\n\n /**\n @notice This function withdraws all the user's aTokens from previous deposits\n @param loanID id of the loan being used in the dapp\n @param tokenAddress address of the token\n */\n function aaveWithdrawAll(uint256 loanID, address tokenAddress)\n public\n paused(\"\", false)\n onlyBorrower(loanID)\n {\n IAToken aToken = LibDapps.getAToken(tokenAddress);\n\n uint256 aTokenBalanceBeforeWithdraw = aToken.balanceOf(address(this));\n require(aTokenBalanceBeforeWithdraw >= 0, \"NO_BALANCE_TO_WITHDRAW\");\n\n IAaveLendingPool aaveLendingPool = LibDapps.getAaveLendingPool();\n\n bytes memory callData =\n abi.encode(\n IAaveLendingPool.withdraw.selector,\n tokenAddress,\n aTokenBalanceBeforeWithdraw,\n address(this)\n );\n LibDapps.s().loanEscrows[loanID].callDapp(\n address(aaveLendingPool),\n callData\n );\n\n uint256 aTokenBalanceAfterWithdraw = aToken.balanceOf(address(this));\n require(aTokenBalanceAfterWithdraw == 0, \"AAVE_WITHDRAWAL_ERROR\");\n\n LibEscrow.tokenUpdated(loanID, address(aToken));\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n\n emit AaveWithdrawn(\n tokenAddress,\n address(aToken),\n aTokenBalanceBeforeWithdraw,\n aTokenBalanceBeforeWithdraw,\n aTokenBalanceAfterWithdraw\n );\n }\n}\n" + }, + "contracts/settings/asset/libraries/AssetATokenLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../../shared/libraries/CacheLib.sol\";\nimport { IAToken } from \"../../../escrow/dapps/interfaces/IAToken.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions for Aave asset setting.\n *\n * @author develop@teller.finance\n */\nlibrary AssetATokenLib {\n bytes32 private constant NAME = keccak256(\"aToken\");\n\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n function get(address asset) internal view returns (IAToken) {\n return IAToken(s(asset).addresses[NAME]);\n }\n\n function set(address asset, address newValue) internal {\n s(asset).addresses[NAME] = newValue;\n }\n}\n" + }, + "contracts/shared/facets/DiamondLoupeFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/******************************************************************************\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\n/******************************************************************************/\n\nimport { LibDiamond } from \"../libraries/LibDiamond.sol\";\nimport { IDiamondLoupe } from \"../interfaces/IDiamondLoupe.sol\";\nimport {\n IERC165\n} from \"@openzeppelin/contracts/utils/introspection/IERC165.sol\";\n\ncontract DiamondLoupeFacet is IDiamondLoupe, IERC165 {\n // Diamond Loupe Functions\n ////////////////////////////////////////////////////////////////////\n /// These functions are expected to be called frequently by tools.\n //\n // struct Facet {\n // address facetAddress;\n // bytes4[] functionSelectors;\n // }\n\n /// @notice Gets all facets and their selectors.\n /// @return facets_ Facet\n function facets() external view override returns (Facet[] memory facets_) {\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\n uint256 numFacets = ds.facetAddresses.length;\n facets_ = new Facet[](numFacets);\n for (uint256 i; i < numFacets; i++) {\n address facetAddress_ = ds.facetAddresses[i];\n facets_[i].facetAddress = facetAddress_;\n facets_[i].functionSelectors = ds.facetFunctionSelectors[\n facetAddress_\n ]\n .functionSelectors;\n }\n }\n\n /// @notice Gets all the function selectors provided by a facet.\n /// @param _facet The facet address.\n /// @return facetFunctionSelectors_\n function facetFunctionSelectors(address _facet)\n external\n view\n override\n returns (bytes4[] memory facetFunctionSelectors_)\n {\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\n facetFunctionSelectors_ = ds.facetFunctionSelectors[_facet]\n .functionSelectors;\n }\n\n /// @notice Get all the facet addresses used by a diamond.\n /// @return facetAddresses_\n function facetAddresses()\n external\n view\n override\n returns (address[] memory facetAddresses_)\n {\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\n facetAddresses_ = ds.facetAddresses;\n }\n\n /// @notice Gets the facet that supports the given selector.\n /// @dev If facet is not found return address(0).\n /// @param _functionSelector The function selector.\n /// @return facetAddress_ The facet address.\n function facetAddress(bytes4 _functionSelector)\n external\n view\n override\n returns (address facetAddress_)\n {\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\n facetAddress_ = ds.selectorToFacetAndPosition[_functionSelector]\n .facetAddress;\n }\n\n // This implements ERC-165.\n function supportsInterface(bytes4 _interfaceId)\n external\n view\n override\n returns (bool)\n {\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\n return ds.supportedInterfaces[_interfaceId];\n }\n}\n" + }, + "contracts/shared/libraries/LibDiamond.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/******************************************************************************\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\n/******************************************************************************/\n\nimport { IDiamondCut } from \"../interfaces/IDiamondCut.sol\";\nimport { IDiamondLoupe } from \"../interfaces/IDiamondLoupe.sol\";\nimport {\n IERC165\n} from \"@openzeppelin/contracts/utils/introspection/IERC165.sol\";\nimport { IERC173 } from \"../interfaces/IERC173.sol\";\nimport { LibMeta } from \"./LibMeta.sol\";\n\nlibrary LibDiamond {\n bytes32 constant DIAMOND_STORAGE_POSITION =\n keccak256(\"diamond.standard.diamond.storage\");\n\n struct FacetAddressAndPosition {\n address facetAddress;\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\n }\n\n struct FacetFunctionSelectors {\n bytes4[] functionSelectors;\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\n }\n\n struct DiamondStorage {\n // maps function selector to the facet address and\n // the position of the selector in the facetFunctionSelectors.selectors array\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\n // maps facet addresses to function selectors\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\n // facet addresses\n address[] facetAddresses;\n // Used to query if a contract implements an interface.\n // Used to implement ERC-165.\n mapping(bytes4 => bool) supportedInterfaces;\n // owner of the contract\n address contractOwner;\n }\n\n function diamondStorage()\n internal\n pure\n returns (DiamondStorage storage ds)\n {\n bytes32 position = DIAMOND_STORAGE_POSITION;\n assembly {\n ds.slot := position\n }\n }\n\n event OwnershipTransferred(\n address indexed previousOwner,\n address indexed newOwner\n );\n\n function setContractOwner(address _newOwner) internal {\n DiamondStorage storage ds = diamondStorage();\n address previousOwner = ds.contractOwner;\n ds.contractOwner = _newOwner;\n emit OwnershipTransferred(previousOwner, _newOwner);\n }\n\n function contractOwner() internal view returns (address contractOwner_) {\n contractOwner_ = diamondStorage().contractOwner;\n }\n\n function enforceIsContractOwner() internal view {\n require(\n LibMeta.msgSender() == diamondStorage().contractOwner,\n \"LibDiamond: Must be contract owner\"\n );\n }\n\n event DiamondCut(\n IDiamondCut.FacetCut[] _diamondCut,\n address _init,\n bytes _calldata\n );\n\n function addDiamondFunctions(\n address _diamondCutFacet,\n address _diamondLoupeFacet,\n address _ownershipFacet\n ) internal {\n IDiamondCut.FacetCut[] memory cut = new IDiamondCut.FacetCut[](3);\n bytes4[] memory functionSelectors = new bytes4[](1);\n functionSelectors[0] = IDiamondCut.diamondCut.selector;\n cut[0] = IDiamondCut.FacetCut({\n facetAddress: _diamondCutFacet,\n action: IDiamondCut.FacetCutAction.Add,\n functionSelectors: functionSelectors\n });\n functionSelectors = new bytes4[](5);\n functionSelectors[0] = IDiamondLoupe.facets.selector;\n functionSelectors[1] = IDiamondLoupe.facetFunctionSelectors.selector;\n functionSelectors[2] = IDiamondLoupe.facetAddresses.selector;\n functionSelectors[3] = IDiamondLoupe.facetAddress.selector;\n functionSelectors[4] = IERC165.supportsInterface.selector;\n cut[1] = IDiamondCut.FacetCut({\n facetAddress: _diamondLoupeFacet,\n action: IDiamondCut.FacetCutAction.Add,\n functionSelectors: functionSelectors\n });\n functionSelectors = new bytes4[](2);\n functionSelectors[0] = IERC173.transferOwnership.selector;\n functionSelectors[1] = IERC173.owner.selector;\n cut[2] = IDiamondCut.FacetCut({\n facetAddress: _ownershipFacet,\n action: IDiamondCut.FacetCutAction.Add,\n functionSelectors: functionSelectors\n });\n diamondCut(cut, address(0), \"\");\n }\n\n // Internal function version of diamondCut\n function diamondCut(\n IDiamondCut.FacetCut[] memory _diamondCut,\n address _init,\n bytes memory _calldata\n ) internal {\n for (\n uint256 facetIndex;\n facetIndex < _diamondCut.length;\n facetIndex++\n ) {\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\n if (action == IDiamondCut.FacetCutAction.Add) {\n addFunctions(\n _diamondCut[facetIndex].facetAddress,\n _diamondCut[facetIndex].functionSelectors\n );\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\n replaceFunctions(\n _diamondCut[facetIndex].facetAddress,\n _diamondCut[facetIndex].functionSelectors\n );\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\n removeFunctions(\n _diamondCut[facetIndex].facetAddress,\n _diamondCut[facetIndex].functionSelectors\n );\n } else {\n revert(\"LibDiamondCut: Incorrect FacetCutAction\");\n }\n }\n emit DiamondCut(_diamondCut, _init, _calldata);\n initializeDiamondCut(_init, _calldata);\n }\n\n function addFunctions(\n address _facetAddress,\n bytes4[] memory _functionSelectors\n ) internal {\n require(\n _functionSelectors.length > 0,\n \"LibDiamondCut: No selectors in facet to cut\"\n );\n DiamondStorage storage ds = diamondStorage();\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\n require(\n _facetAddress != address(0),\n \"LibDiamondCut: Add facet can't be address(0)\"\n );\n uint16 selectorPosition =\n uint16(\n ds.facetFunctionSelectors[_facetAddress]\n .functionSelectors\n .length\n );\n // add new facet address if it does not exist\n if (selectorPosition == 0) {\n enforceHasContractCode(\n _facetAddress,\n \"LibDiamondCut: New facet has no code\"\n );\n ds.facetFunctionSelectors[_facetAddress]\n .facetAddressPosition = uint16(ds.facetAddresses.length);\n ds.facetAddresses.push(_facetAddress);\n }\n for (\n uint256 selectorIndex;\n selectorIndex < _functionSelectors.length;\n selectorIndex++\n ) {\n bytes4 selector = _functionSelectors[selectorIndex];\n address oldFacetAddress =\n ds.selectorToFacetAndPosition[selector].facetAddress;\n require(\n oldFacetAddress == address(0),\n \"LibDiamondCut: Can't add function that already exists\"\n );\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(\n selector\n );\n ds.selectorToFacetAndPosition[selector]\n .facetAddress = _facetAddress;\n ds.selectorToFacetAndPosition[selector]\n .functionSelectorPosition = selectorPosition;\n selectorPosition++;\n }\n }\n\n function replaceFunctions(\n address _facetAddress,\n bytes4[] memory _functionSelectors\n ) internal {\n require(\n _functionSelectors.length > 0,\n \"LibDiamondCut: No selectors in facet to cut\"\n );\n DiamondStorage storage ds = diamondStorage();\n require(\n _facetAddress != address(0),\n \"LibDiamondCut: Add facet can't be address(0)\"\n );\n uint16 selectorPosition =\n uint16(\n ds.facetFunctionSelectors[_facetAddress]\n .functionSelectors\n .length\n );\n // add new facet address if it does not exist\n if (selectorPosition == 0) {\n enforceHasContractCode(\n _facetAddress,\n \"LibDiamondCut: New facet has no code\"\n );\n ds.facetFunctionSelectors[_facetAddress]\n .facetAddressPosition = uint16(ds.facetAddresses.length);\n ds.facetAddresses.push(_facetAddress);\n }\n for (\n uint256 selectorIndex;\n selectorIndex < _functionSelectors.length;\n selectorIndex++\n ) {\n bytes4 selector = _functionSelectors[selectorIndex];\n address oldFacetAddress =\n ds.selectorToFacetAndPosition[selector].facetAddress;\n require(\n oldFacetAddress != _facetAddress,\n \"LibDiamondCut: Can't replace function with same function\"\n );\n removeFunction(oldFacetAddress, selector);\n // add function\n ds.selectorToFacetAndPosition[selector]\n .functionSelectorPosition = selectorPosition;\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(\n selector\n );\n ds.selectorToFacetAndPosition[selector]\n .facetAddress = _facetAddress;\n selectorPosition++;\n }\n }\n\n function removeFunctions(\n address _facetAddress,\n bytes4[] memory _functionSelectors\n ) internal {\n require(\n _functionSelectors.length > 0,\n \"LibDiamondCut: No selectors in facet to cut\"\n );\n DiamondStorage storage ds = diamondStorage();\n // if function does not exist then do nothing and return\n require(\n _facetAddress == address(0),\n \"LibDiamondCut: Remove facet address must be address(0)\"\n );\n for (\n uint256 selectorIndex;\n selectorIndex < _functionSelectors.length;\n selectorIndex++\n ) {\n bytes4 selector = _functionSelectors[selectorIndex];\n address oldFacetAddress =\n ds.selectorToFacetAndPosition[selector].facetAddress;\n removeFunction(oldFacetAddress, selector);\n }\n }\n\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\n DiamondStorage storage ds = diamondStorage();\n require(\n _facetAddress != address(0),\n \"LibDiamondCut: Can't remove function that doesn't exist\"\n );\n // an immutable function is a function defined directly in a diamond\n require(\n _facetAddress != address(this),\n \"LibDiamondCut: Can't remove immutable function\"\n );\n // replace selector with last selector, then delete last selector\n uint256 selectorPosition =\n ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\n uint256 lastSelectorPosition =\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.length -\n 1;\n // if not the same then replace _selector with lastSelector\n if (selectorPosition != lastSelectorPosition) {\n bytes4 lastSelector =\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[\n lastSelectorPosition\n ];\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[\n selectorPosition\n ] = lastSelector;\n ds.selectorToFacetAndPosition[lastSelector]\n .functionSelectorPosition = uint16(selectorPosition);\n }\n // delete the last selector\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\n delete ds.selectorToFacetAndPosition[_selector];\n\n // if no more selectors for facet address then delete the facet address\n if (lastSelectorPosition == 0) {\n // replace facet address with last facet address and delete last facet address\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\n uint256 facetAddressPosition =\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\n if (facetAddressPosition != lastFacetAddressPosition) {\n address lastFacetAddress =\n ds.facetAddresses[lastFacetAddressPosition];\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\n ds.facetFunctionSelectors[lastFacetAddress]\n .facetAddressPosition = uint16(facetAddressPosition);\n }\n ds.facetAddresses.pop();\n delete ds.facetFunctionSelectors[_facetAddress]\n .facetAddressPosition;\n }\n }\n\n function initializeDiamondCut(address _init, bytes memory _calldata)\n internal\n {\n if (_init == address(0)) {\n require(\n _calldata.length == 0,\n \"LibDiamondCut: _init is address(0) but_calldata is not empty\"\n );\n } else {\n require(\n _calldata.length > 0,\n \"LibDiamondCut: _calldata is empty but _init is not address(0)\"\n );\n if (_init != address(this)) {\n enforceHasContractCode(\n _init,\n \"LibDiamondCut: _init address has no code\"\n );\n }\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\n if (success == false) {\n if (error.length > 0) {\n // bubble up the error\n revert(string(error));\n } else {\n revert(\"LibDiamondCut: _init function reverted\");\n }\n }\n }\n }\n\n function enforceHasContractCode(\n address _contract,\n string memory _errorMessage\n ) internal view {\n uint256 contractSize;\n assembly {\n contractSize := extcodesize(_contract)\n }\n require(contractSize != 0, _errorMessage);\n }\n}\n" + }, + "contracts/shared/interfaces/IERC173.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title ERC-173 Contract Ownership Standard\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\n/* is ERC165 */\ninterface IERC173 {\n /// @notice Get the address of the owner\n /// @return owner_ The address of the owner.\n function owner() external view returns (address owner_);\n\n /**\n * @notice Set the address of the new owner of the contract\n * @dev Set _newOwner to address(0) to renounce any ownership.\n * @param _newOwner The address of the new owner of the contract\n */\n function transferOwnership(address _newOwner) external;\n}\n" + }, + "contracts/shared/libraries/LibMeta.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nlibrary LibMeta {\n function getChainID() internal view returns (uint256 id) {\n assembly {\n id := chainid()\n }\n }\n\n function msgSender() internal view returns (address sender_) {\n if (msg.sender == address(this)) {\n bytes memory array = msg.data;\n uint256 index = msg.data.length;\n assembly {\n // Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those.\n sender_ := and(\n mload(add(array, index)),\n 0xffffffffffffffffffffffffffffffffffffffff\n )\n }\n } else {\n sender_ = msg.sender;\n }\n }\n}\n" + }, + "contracts/shared/facets/OwnershipFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { LibDiamond } from \"../libraries/LibDiamond.sol\";\nimport { IERC173 } from \"../interfaces/IERC173.sol\";\n\ncontract OwnershipFacet is IERC173 {\n function transferOwnership(address _newOwner) external override {\n LibDiamond.enforceIsContractOwner();\n LibDiamond.setContractOwner(_newOwner);\n }\n\n function owner() external view override returns (address owner_) {\n owner_ = LibDiamond.contractOwner();\n }\n}\n" + }, + "contracts/shared/facets/DiamondCutFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/******************************************************************************\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\n/******************************************************************************/\n\nimport { IDiamondCut } from \"../interfaces/IDiamondCut.sol\";\nimport { LibDiamond } from \"../libraries/LibDiamond.sol\";\n\ncontract DiamondCutFacet is IDiamondCut {\n /// @notice Add/replace/remove any number of functions and optionally execute\n /// a function with delegatecall\n /// @param _diamondCut Contains the facet addresses and function selectors\n /// @param _init The address of the contract or facet to execute _calldata\n /// @param _calldata A function call, including function selector and arguments\n /// _calldata is executed with delegatecall on _init\n function diamondCut(\n FacetCut[] calldata _diamondCut,\n address _init,\n bytes calldata _calldata\n ) external override {\n LibDiamond.enforceIsContractOwner();\n LibDiamond.diamondCut(_diamondCut, _init, _calldata);\n }\n}\n" + }, + "contracts/contexts/access-control/internal/authorize.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./has-role.sol\";\n\nabstract contract int_authorize_AccessControl_v1 is\n int_hasRole_AccessControl_v1\n{\n function authorize(bytes32 role, address account) internal view {\n require(_hasRole(role, account), \"UNAUTHORIZED\");\n }\n}\n" + }, + "contracts/contexts/access-control/external/has-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { int_hasRole_AccessControl_v1 } from \"../internal/has-role.sol\";\n\ncontract ext_hasRole_AccessControl_V1 is int_hasRole_AccessControl_v1 {\n function hasRole(bytes32 role, address account)\n external\n view\n returns (bool hasRole_)\n {\n hasRole_ = _hasRole(role, account);\n }\n}\n\ncontract ext_hasRole_AccessControl is ext_hasRole_AccessControl_V1 {}\n" + }, + "contracts/contexts/access-control/external/index.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./has-role.sol\";\n" + }, + "contracts/contexts/access-control/external/admin-role-for.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {\n int_adminRoleFor_AccessControl_v1\n} from \"../internal/admin-role-for.sol\";\n\ncontract ext_adminRoleFor_AccessControl_V1 is\n int_adminRoleFor_AccessControl_v1\n{\n function adminRoleFor(bytes32 role)\n external\n view\n returns (bytes32 adminRoleFor_)\n {\n adminRoleFor_ = _adminRoleFor(role);\n }\n}\n\ncontract ext_adminRoleFor_AccessControl is int_adminRoleFor_AccessControl_v1 {}\n" + } + }, + "settings": { + "optimizer": { + "enabled": true, + "runs": 200 + }, + "outputSelection": { + "*": { + "*": [ + "abi", + "evm.bytecode", + "evm.deployedBytecode", + "evm.methodIdentifiers", + "metadata", + "devdoc", + "userdoc", + "storageLayout", + "evm.gasEstimates" + ], + "": ["ast"] + } + }, + "metadata": { + "useLiteralContent": true + } + } +} diff --git a/deployments/polygon_mumbai/.chainId b/deployments/polygon_mumbai/.chainId new file mode 100644 index 000000000..d7e2f72ce --- /dev/null +++ b/deployments/polygon_mumbai/.chainId @@ -0,0 +1 @@ +80001 \ No newline at end of file diff --git a/deployments/polygon_mumbai/.latestDeploymentBlock b/deployments/polygon_mumbai/.latestDeploymentBlock new file mode 100644 index 000000000..d3cbbd08f --- /dev/null +++ b/deployments/polygon_mumbai/.latestDeploymentBlock @@ -0,0 +1 @@ +15692567 \ No newline at end of file diff --git a/deployments/polygon_mumbai/.nftDistribution.json b/deployments/polygon_mumbai/.nftDistribution.json new file mode 100644 index 000000000..ba7b0cdda --- /dev/null +++ b/deployments/polygon_mumbai/.nftDistribution.json @@ -0,0 +1,24244 @@ +[ + { + "merkleRoot": "0xc89404836fea55313fc16e4eb70d6e841584fc7bcaf5e1d0013bbdae5624bde8", + "tierIndex": 0, + "tokenTotal": "0x0701", + "claims": { + "0x000f4432a40560bBFf1b581a8b7AdEd8dab80026": { + "index": 0, + "amount": "0x01", + "proof": [ + "0xa59f9dfda949d0f0a9c89a293e6c2da7dd772ee935a51c089c535c5fa9eb334c", + "0x0ac9b2299a2ed35f2222a3b68dfc9e41d64bfc7b448389495176837bda0ca684", + "0xa1721ee66f5b33fb1491876c9638c9e321f4e9e99e92b69903d4c3b0954511ab", + "0xc677cbee79568f65b4882bd20044555e2bddfb473bfa6749d1d07caa3dd6fd2b", + "0xdf701aa8bdb3ffefff1b359214087cc585fa0a0d40716a6635a8d2db4380dba1", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0013AA2FB5EC916660b38f1D53D4fC9BF8eF8A84": { + "index": 1, + "amount": "0x01", + "proof": [ + "0xc8c6a0437dd638a5c27d5870d6b6f04fd1b31ae23f8fc1b678dfa6680b5c380f", + "0x1e392297b0fc9beb554c93adde9a167b28fe120c9a33cac33de0afeecf14d5dd", + "0x906c494d7d3c4c5f521930d1042cfae9154fc6b37e57ecec673d01e269ef7429", + "0x1f4f9d2e01bb8c804693d53134cf046798ee2607f0aa015ff42b474e23cf7ed2", + "0x97fbe90108c9d6db20d511e4419e4ed044f589ef1f2a9f6539187bad21502f90", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0023AD7791C6695eb012A179E801541AAd824DBF": { + "index": 2, + "amount": "0x02", + "proof": [ + "0x2ebe49f0615b0744b192e5b430545b1ebf526db63473d2ac30318edd8e205d18", + "0x3f19992fce4ab826b241a152c2db7c1332d1aa389d91d453c37e20f823e44e2b", + "0x33ee9937a125c825df46cd7852ad611a4a2bd56aa65171e409297909c605ac3b", + "0x9e8ae6c0c829ef47f1fdcf07618192e842b30fccb4c38a8af79f05f97c75c097", + "0x4325701890e79e85b41231157c1ced07357ce871ed6fb4f233c2f82c38bcf4bb", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0025befed0d57A11dB1dC26A80e651Bb38C97027": { + "index": 3, + "amount": "0x01", + "proof": [ + "0xb714fc9f95d54313e1123d67037d1572a36be6b5a382ca1dd070e3c34301fb09", + "0xec07ef0f0314b6d06604b4578ce01aa3d06ddfc4df44a188c5077de166dff521", + "0x2370bc3e49aeead81a8f59e3d80747fc9da94142f3be3098f2b9504a9dc4fd7b", + "0x841ca200e81dde455c9bb72802b7b377b46a9d6779eec08b07e61939b8d43c1b", + "0x529f1b48ab616d4dd60f663753a7779d8ec25952bc8c34df4aa96347bdb0d542", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x005d64b3Fedd6d53EDf19142087D51c7ac6ba595": { + "index": 4, + "amount": "0x01", + "proof": [ + "0x6867397b816f6c537863a6cd2a04353f9bb0c506320e9ae0040428f2e62841b6", + "0x4c0577a50ba0d4814b5c1c9aa0d140e225a46040256b3d5107e99d5d093e10ed", + "0x41d6fd233f2e0eec852b23d812e880270cb6012eea56144ea5d03648def773de", + "0x2b5637be96c5474a58c9ffbe0539171817312be59bc8b7c71e23242dd20afa66", + "0x245190f95f5e09d43d1da7e9757fa066be1942b52f7e4962cbbe6a5f2e0981bc", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x009154b39CA41372Df54564fb8fF2C437a83c411": { + "index": 5, + "amount": "0x01", + "proof": [ + "0x4eff0bc5080bddc0cafb9a01586775df0609752cc2ad4075670a920ec254497b", + "0x9167268bb67d5571096efaa161cce2c8e3c801840ac1d4e910cdc4742b2914b8", + "0xe823abd564575edaba5671df2299c869d599b76d50814c956babb2392af273b8", + "0xde9fcf6a43c240e1d4c7ca780516b34aba68d02c35c5ad3090d1ba1aa8d40999", + "0xcc9986a7987738d81db64db86f583aed4fde214b766f55d0f15a876c8f790fb8", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x00929C5c2c4f00B540e429247669Eb6fcd8b1DBF": { + "index": 6, + "amount": "0x01", + "proof": [ + "0xa11a0182990cda0b1402e891b6f07294f6c2962ad90d9ce9c9b68b7f558c2471", + "0x04b4ec9a15a6d28017131f5bb5cf6cff60e552ee2716a308b8ea5a55ad7391f3", + "0x7306ff63535bc4b71716d17c36277e5ccdcae2c03cbbe50c57c9420e43b33b29", + "0x4fa24b2d1635e25dea497fe90d30db11d577f752b726d47caf1b4952bdf93c96", + "0xc36c52715656389b2693c145860adf3b1f3d4d24a139850b1fa5f2236456376e", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x00F928a6aDC7c345EF919fe5A8Be2458580eF9f6": { + "index": 7, + "amount": "0x01", + "proof": [ + "0x7530b688657678a72a3e764be901a84c7cd305ba502e1784b0922f53dd0c937f", + "0xc2a75931f9920c5db34acbbb5ad755aaae18129b7ad5e434043ca4d97d81362e", + "0x6b1d50c8f881c6c8993f73ba91868e17e454e5d10e04868fd2b9002bfa1fa4c5", + "0x2542d5bed1352bb1dd1986da7e22c1f92c0eb7a7dead185e5100d7004e8e054c", + "0xb78cb1aa869958030ce4a14b5fff6309166225c83e0cdd2b91deb7b1639f67c4", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0103a4966daba5a947df52b0B892d8b3fdEF5A4F": { + "index": 8, + "amount": "0x01", + "proof": [ + "0xc2ddead119e1a1aba9e31c4691090363368d6f0c8b404d55d169653e24999dd7", + "0xbbba871a00094f3668a4e2ca6ae0591b1f2f7b091d9d7a7fd36ed011e6739e1e", + "0x31c626a13fd36bf9222fabb7f884eb7f6bbc58d99a42ea76aaf069282a6bfa97", + "0x65c5caf7f221e805a211309d005cab013498255a9343870184292835ae911371", + "0xcf22c1d43a94c7c6471efe1209a3b103ec0a9836b6c11fe8d2e98d18b2e9cb36", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x012bFF890c15c9d10E3C7fe59be5441be208cD9A": { + "index": 9, + "amount": "0x01", + "proof": [ + "0x6845f96158560411b9bb7e466a7e94190c7da9c339859ed1e5f2f18feb349144", + "0x4c0577a50ba0d4814b5c1c9aa0d140e225a46040256b3d5107e99d5d093e10ed", + "0x41d6fd233f2e0eec852b23d812e880270cb6012eea56144ea5d03648def773de", + "0x2b5637be96c5474a58c9ffbe0539171817312be59bc8b7c71e23242dd20afa66", + "0x245190f95f5e09d43d1da7e9757fa066be1942b52f7e4962cbbe6a5f2e0981bc", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0131337c0f29d6A5Df5fA80bff9a6F40DF201Cb1": { + "index": 10, + "amount": "0x02", + "proof": [ + "0x499188e370cc64e56a87292f8f0baeacd3f345ad391b783913ba75e0784761c9", + "0x7d69384a7f3bcafcda2540f733207c72df8489da61392f68b03bde28d686b9a2", + "0xa1607b1dced9e8d9d1aaa755c5c6bc84b483e3063f866818b53e0747d67d0d1d", + "0xa5e8bb53f83c3715772cbf32d53d2e1c1c9b5abd0d51618f0e2ec2960d9a33b8", + "0x43f59a603c2458850547e5a84d47e61be843b4a3c814303ed1b52e1e4d37a1b5", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x019788a95d0b3881B0ca1a82737B31CA74F1Ce50": { + "index": 11, + "amount": "0x01", + "proof": [ + "0x19bf4458725887e86720c38b39f14da8594477e3ad984f2bf6fadf547179b2b7", + "0x5696a22d898d45b4070212f76b4421aeb433c0ac34348e18e5949ba7290d59c9", + "0x242867d7413fcb0291041584037c07852dc6949a3340933353fcccaf1840148f", + "0x9259974d28cfc23eade84b4a12eba89f4b5d3b0064ca7ad3dcf3a6a6a2555c91", + "0x93994074bdd819d668a79fc2c79be23cb074a679cd3fe03940945d4c6f9fa9b3", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0198d1Dc90637A50E65C038DAA55E927903C0c23": { + "index": 12, + "amount": "0x01", + "proof": [ + "0xac4e4bea90b2d092099f2541c11e98e0344fadcb4879ec200cc34e842d669bac", + "0x520475fa32c633832b3a9928245d557e745e205fec21d1f9021b7a82455ecc9e", + "0x547310dbf01783252ecf8dcb1f11da8552ff7f0911e701b5e17e3f8ce6679a4b", + "0xf685abad756fc52292f02befc3f5465de8d8f16cce61117b3f5de4fc38a60819", + "0xa952d1dc401036dd357d470bb699a7e9cfc64f0caf6dc51a638cd2487f5e73fb", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0226068cE182ad66482ac08219d41e00Eae74aa7": { + "index": 13, + "amount": "0x01", + "proof": [ + "0xdd986836887feb88f37f32dbcc70a7ba4a158efdb0fc64d089af535931001c31", + "0xa17bded509fba25ac9fa8af53dfe82bf78b94bb09d35d6c304a40fc4c2f0b837", + "0xeffafc2bde50804ba4e5e2909025d61329f3df3401c7029f57fe93a263cdfa73", + "0xc84beec6531767197744c2106caed4823936b1ceed7475952444acf832b57446", + "0xd8ba0ec6899e7ab5afd6774d7465b2ebc52e677b805f74deb131b1b243bae70a", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x02513D2DDaF15d332C8eD1b001814a3de8cF6050": { + "index": 14, + "amount": "0x01", + "proof": [ + "0x5cf4f70a57970390cc3368123f8218324a55c1f30b89f5a3b886482f27e07c09", + "0x2f61c8831a65791851700458e81b71e370f088e6410f6d67b29127c65d931550", + "0x747693e41d14ef24bc2453cf37d950f88e7f694e4fdd7fef48e85a35e7221968", + "0x4bbd36041ce4968e3db3409953e198317c2cb3811d91f8fc5a98ba5c581d59e5", + "0x140105e3fa17ce783a651f2281967c53a37a748c29442efd53ee24d8a1cff6f5", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x025430a7D45D98E812cf12DD59790b9981d4Ff54": { + "index": 15, + "amount": "0x01", + "proof": [ + "0x68bb5bb354000977071f725027227d77a770685da99347a9a45fcff676d9520b", + "0xdad13a5f20613b56b4713919259a1223c244ee31a78e9f17acaef2803039532c", + "0x41d6fd233f2e0eec852b23d812e880270cb6012eea56144ea5d03648def773de", + "0x2b5637be96c5474a58c9ffbe0539171817312be59bc8b7c71e23242dd20afa66", + "0x245190f95f5e09d43d1da7e9757fa066be1942b52f7e4962cbbe6a5f2e0981bc", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x02b6bD2420cCADC38726BD34BB7f5c52B3F4F3ff": { + "index": 16, + "amount": "0x01", + "proof": [ + "0x40a202cc5225dc276216e7a1f245a9ead40611cb37c334e6a9d8f709f1f584e5", + "0x8b566b277921d2b78a6cab9850dc5f97e85f826d814f45b2d443592b68c11510", + "0x6cb469a96723651e405715162b9903adfe081b56ef3c5c27f903302a7ba044a3", + "0x3ae549d14256824a2b8db4d8292224eb9b3beda41a6712098d825d2a32cc6dcd", + "0x98ba92b6a1d3418a3c44b684c9f0dc2177f48d3a6b666334d112dacbb6f5acae", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x03DcA0e82c9Fd8876245ee54997dD4aF73849FD2": { + "index": 17, + "amount": "0x01", + "proof": [ + "0x58d306f2dc3dfc94d960a3495fd9a21ea61fe9841f97df9ac0eeca3f2f838cb0", + "0x76e86ff6ebe71556f8a31c670ca1f187e44babd68d51a629caf896709e37ba0e", + "0x136170c6f928bfc56e43011f019f3a590b74ac414acde4927d918d53fd5e8ef8", + "0x5190cb032ba95080f88929faf2eabe8bd342a53206176fd2c3afcbef4577ab71", + "0xf9f105f90db6fe2970fb4e03b35654f9b69375879c783d3f1700e04b2e2f925b", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x03E9A17304a1c1fe229965616b7DDDcd96579a29": { + "index": 18, + "amount": "0x01", + "proof": [ + "0xdd095563864f8781c8539a968b1e674277da20008d6c1a7c879f51f98b6c36c9", + "0x219c8ca8f20acbb6200dc31e1fee1aa9997717563eaa34e2cf9331a1ef595181", + "0xeffafc2bde50804ba4e5e2909025d61329f3df3401c7029f57fe93a263cdfa73", + "0xc84beec6531767197744c2106caed4823936b1ceed7475952444acf832b57446", + "0xd8ba0ec6899e7ab5afd6774d7465b2ebc52e677b805f74deb131b1b243bae70a", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0462096A2631fA4974713F0C0E29B43b510f6570": { + "index": 19, + "amount": "0x01", + "proof": [ + "0x9d07c327a65bccfb2c7209636e0b1dc8d4649ab414a674e8eff10875d8947af0", + "0xeb9a72ceb9e987db10e8ec9b26152d9e24d0d0bda5769fe7fea362f5d643a41c", + "0xe767c29b89a3fef6f98f344b4b24add9c02f5cb6d6e67d487d02bc732178dd9f", + "0x2710311af5d5c72181aeccf7f1e36c3065b1ac40ab236128e22d5cefe5ca9032", + "0x0b385e4882f89784f506afafe6dd217c6ad9d142ccf58713e27961d25b2c6d0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x047D6d15c64635ba2bF80d4555983B97cF2162CE": { + "index": 20, + "amount": "0x01", + "proof": [ + "0x54c234091ad033b927fbb7112b8499b9594432a61692a63d3edd30dd3887395d", + "0x5e884faed9d652ecdbeef8dcbe3007213a8c6607a1d23dc7c7ad2b55ad40ed4d", + "0xb38048ecbdb0d7a97188f59825c94f13ca314f4be11d86febd1cdf302e0326ad", + "0x9104efb4441e61a09b4e458e6b45f6759c37c20733b5823cc04f759cc53d5575", + "0x6ae25cafc683eaf0756d86c89deb0abecfbfd01e812ffbed4e7a26f11cb91f8c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x04a8E03e24B56A44033b0dafa0066D6aA6688120": { + "index": 21, + "amount": "0x01", + "proof": [ + "0x19d785f81919d878547ff98af155301e26c8219322965ca6e6fed1cdb02f654f", + "0x5696a22d898d45b4070212f76b4421aeb433c0ac34348e18e5949ba7290d59c9", + "0x242867d7413fcb0291041584037c07852dc6949a3340933353fcccaf1840148f", + "0x9259974d28cfc23eade84b4a12eba89f4b5d3b0064ca7ad3dcf3a6a6a2555c91", + "0x93994074bdd819d668a79fc2c79be23cb074a679cd3fe03940945d4c6f9fa9b3", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x04d171Eed1f702Ef57A2ab8219924a0ec12e536C": { + "index": 22, + "amount": "0x01", + "proof": [ + "0xe4b781fcb80183c0be1a4ab4625263947f32beec5108507bbd262419d407e2cd", + "0x007137c0db88ab5a14704769ff1022f9cdfc635654535e5c778106d6519453c4", + "0x6cfbef2c974896a0631830fdf28466959c8202a21abfd2bb81bcaf67782572e1", + "0x372cbc91aed35f80f87f2c13bba747106e9ece94f8d166e828a5c70b321c5528", + "0x7968b2383e3b914ab3a36580b205f1449b51563630c77871f712e94743e3bf39", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x055de0509847776D1D1B8E6ad9635Fb5B53A0bC0": { + "index": 23, + "amount": "0x03", + "proof": [ + "0x6306419a7c7917d236cd4ad40a2f65e68321a3b5e1f767baf15ce3ee834cd01f", + "0x21ebeadacca530cc0ebe74db46cae3f7a2f1f5f88d4e8ae64ef5c4aceeefd606", + "0xafc939acce9fa59fdef6399379f0c2e101cdd8d5bc66ed4c1d5bbcb5fd709886", + "0x22784474cee51afee6127b1f3fb642ff75cdb40aeb505017bf6b1a1162a44c35", + "0xfe7d73c06bd76d1271e4b772b51e13505a812b7c919129debfd7d15fb5014d16", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x058B10CbE1872ad139b00326686EE8CCef274C58": { + "index": 24, + "amount": "0x01", + "proof": [ + "0x58a11fddeed4f7f032f64a34e493f793e570013a5ec8d77c0e5db91242234655", + "0x3863e91deb132a16fcb6977c0a9dfb96b8b531f2e35f96dcb9343757a7429e31", + "0x136170c6f928bfc56e43011f019f3a590b74ac414acde4927d918d53fd5e8ef8", + "0x5190cb032ba95080f88929faf2eabe8bd342a53206176fd2c3afcbef4577ab71", + "0xf9f105f90db6fe2970fb4e03b35654f9b69375879c783d3f1700e04b2e2f925b", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x05AE0683d8B39D13950c053E70538f5810737bC5": { + "index": 25, + "amount": "0x02", + "proof": [ + "0x16c103a20d043b415baa307f51b5a2b5374381cc559b3fcac0fc3009f4de02c8", + "0xec7984d82e4108cd68f03600909ac5bb276898d3aa56b76e632a57ebc9e22259", + "0xd5460b9cbd07eb643394af0ee8ffa7d20c13c474c42f8d3f770490047dfc42ec", + "0xd4e406b94f7009e26e52781d8bbbf71780c9ab5d8d7b9162b8469ca115683ffc", + "0x6431c24d3d46ea6b0d1959c0de03265dc474d3e67139f2bedca26b5aab0c0c5b", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x06940cfBc097ed8A3F535715E500Ffbe1E685fDc": { + "index": 26, + "amount": "0x02", + "proof": [ + "0x0c9e362f1769de6bf145791b3d32348563c06f0adacf6412450ed5601b5e4c4b", + "0x8682d699b4b1fae82553ca6d03c7e4554aa9e2a6839dc9d70506ef88a7a00695", + "0x1ac17eae005e68d333e431b1be274794132926bcec9fd36924d6e7e39904133c", + "0x979cc6c181e08190bb233f0cf5b0f7b487d9aadc675c9326a9af9732d3369d45", + "0x4a36dc66177a8394f6b14fc9adbe4ad7e0cc2dead6acb72d80990e336fef8d45", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x06CD8aDC40334213e56eE5b32B3567dec21a95D1": { + "index": 27, + "amount": "0x02", + "proof": [ + "0x2e70a177bbc3d38e79a066eb28b30c41c6d1af9516a2bcb5debcf57bc83e9c55", + "0xcee67e6b369f2863b42982f3bbcacce67b4206c192012a65ced1e1524f58583f", + "0x33ee9937a125c825df46cd7852ad611a4a2bd56aa65171e409297909c605ac3b", + "0x9e8ae6c0c829ef47f1fdcf07618192e842b30fccb4c38a8af79f05f97c75c097", + "0x4325701890e79e85b41231157c1ced07357ce871ed6fb4f233c2f82c38bcf4bb", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x070DcB7ba170091F84783b224489aA8B280c1A30": { + "index": 28, + "amount": "0x01", + "proof": [ + "0x8a0b73fffedcdc37dd8c6694dcf435cd5a2c261227cc33f93e3bdafc01338b6e", + "0xca7d4b33116553b088d5508cb576f443b2548689df4d4a0dca732579241ec864", + "0xaf004a51521001e3a2257071c94b92bf3ca21deaabe3c3482b0ee37b2ab2fbbe", + "0x0c15cd0e5fb4411c59b182f983d4322f33d3be8bd2c5425b705021fa316a402d", + "0xe4fc54838dec16cd3ac94713f191dc41ac7f5e070180d4843c9aaaf9c71ce29f", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0730adF4229B97A3362FcAE4D77ac93F41508792": { + "index": 29, + "amount": "0x01", + "proof": [ + "0x251d56395dab323e2a6359be25074f979bfa695143e4a28e57757d11cb28154e", + "0x535034e8f81b573b657b7678716d1a9f95a9d9057a53fc91faa82f0832a333a5", + "0x9a7506db8eb154b6d45fd70ef0e57ee187ef27ec6e42a2253be7f3ac118f3fcc", + "0x4b1c846f0a8bc448aead7f2cfec46ac450b23d2f229b5350dd63009a82a1dccf", + "0xe29ba79106b7b14c14912bb5fba509f27997ddbe5a7ebc941fa75e3475af4aef", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0743C080AB509B7F2643db1FDCd591e0d6051DAa": { + "index": 30, + "amount": "0x01", + "proof": [ + "0x20bb8c4a489fad882c715a72f59770f30b8753154854c73f33958e1e66bc56ad", + "0x68ac79e6b0038449e7c6171e1abee8619718fbea94c1605fdca3ccaf599aa090", + "0x65c9c0c546d81a46cba9c8cb702c77ff47deec1dcd6f975abb3e5cfe8dafb0b0", + "0xc59577d42e813ea179264892414f1c8c6f09486aba6c8a1a1cfecbf6d1e7784d", + "0x6665ebe68e892e4e5135c09f9cdc379628aaa60a8ff322ed2ba75fab3b3a9cc0", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x07529A0DBeaA96754F7296DB6C0Aca9224601917": { + "index": 31, + "amount": "0x01", + "proof": [ + "0xd801f9478bf23b0ed2d29116cbab357129c72891a7c7f7a60eae83f188fe2305", + "0xc444e68fb51c3ee6268c2251e0bc4e1ffa81391195666bedb09363e903edb74d", + "0xe5131f39e8805c0037f27f127ffa4446b615fb4b7a3617c4bc555a5d8c3944ab", + "0x539804c7bf7a9b6235d14df5f64369e5a3ba52daf4ce320d3134eb569c42ebaa", + "0x57a1600e1002b648fc38956dc1d2f34be5ee3f6cf170c73bd27c43b2a01e45db", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x075e8dA02770b708625494f6DcA5dc3d61b4D345": { + "index": 32, + "amount": "0x01", + "proof": [ + "0x9fa402fe5f69abc8f9f7fdfa9f2a82dcb2a1b701374385453480428d40599c81", + "0xdce185db93ea364b2cbd2fa79a267a698149ae21d035953168d02bc6d76332b4", + "0xed1fedc58d0a592f61e92d2a8ab04ba2c92cccb2e77a5caf9f83f2e4f14db538", + "0x4fa24b2d1635e25dea497fe90d30db11d577f752b726d47caf1b4952bdf93c96", + "0xc36c52715656389b2693c145860adf3b1f3d4d24a139850b1fa5f2236456376e", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x07D96f8798f76110f07404C95EDe69DA9b1f7dA6": { + "index": 33, + "amount": "0x02", + "proof": [ + "0xde3db84afd5889a58cb856d9f719599c959b280bd4fa738db14139f808c79ed5", + "0x8959d9d3238ab37dec4eaa2554858d93b800e4362c66b491ef4fe830d0e0a903", + "0x31a842d521aec1d044113ff905ab1b4cbcfd79d2a39867e544a17434c3fae105", + "0x285f0861eec4fffdb569c07f6f01125414c98685171578e7317ed5b8c16ba373", + "0x966715df220dfbe5e11392b257b61b64c18178d1825b654f95f67d7c9558a2a2", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x07Fe3C145711575cbfA77175a3D6D03d051F19CF": { + "index": 34, + "amount": "0x01", + "proof": [ + "0xef25fcfb615f7c669db649ad3c5301dd8df276f0c68050db60a1b3bb1ff0da52", + "0x8cc17d0f380b74dddffffa310d27cad5ff4172c9fa0cedfe83f90553757150b3", + "0x8b6f824fe42a7f1d9f569625e32995ee98e15b37301a2c7063fe65c4ed0c6e78", + "0xfbd5cea7e1eb5806f6f82efdb0e881576ab386159b1b3ff7402e4bf56a947d8c", + "0x58340ed8edb441d787ada6b1aaf2b1e42912724e1f0f7887cde9253262aa0534", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0865aB296021946dC8Ce735e0d006aB33ba485be": { + "index": 35, + "amount": "0x02", + "proof": [ + "0x8d44656b6b67356570af99cb291821f3287cbbdd8a32679e09280a4cdbee2ee2", + "0xa2cf422335730cffe37f7091da1df639821c9ee87a748942afac2c65f9a8721e", + "0xe0327321894dc1feb38e3fe36a354623f4288831a6705367168694406a92d9af", + "0x7217bacc0b5fadfdc27aef27f3baae246ba909c02961594a63bb24f24958cc4c", + "0x8fbc13f50b0f82a781945a74ddd5c5abde0b4a8983852c66ecda77a68df50722", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0885a6798B1Ff9f8B3330B68a025c2552B140136": { + "index": 36, + "amount": "0x01", + "proof": [ + "0xc1812d5dd46259011e1cdc4be567dff449a8d7e157c817de5866a3757ce6e3e6", + "0x7d917920580fee841bc99aa999a2a20981f2d1eda669d945b56207b3c94b00e5", + "0x71e3366d76c55a2318750b2a51d86a41babf197eaec484325789436df87b8918", + "0x56b8291821908612de8ad02adfee632a6221773b416cedb3db9fd4f3ba5d30ff", + "0xbd7abdce9ec414fe47ea73146a2131622bdacb914ea6353abee1b0a149275092", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x08E9412FFdAF26c969f34B92889f14C340Af4994": { + "index": 37, + "amount": "0x01", + "proof": [ + "0x896c329726c8f2bc307b5f30bfefc7dd3e103b249cd5b71b84cf9ddf1698970e", + "0x822d4f4a856b42a89d2f85351b0fda4ccbd91ae86142a30869bce8083f1125eb", + "0x955d9858f13d562b2b223301c8206ff82e44d35786e621872e8a0ddcd2c8af96", + "0x16f452fd982f0f4e3fe20a4b2fdefc9226e8d1db4c0b29793acf9535b6c65c66", + "0xe4fc54838dec16cd3ac94713f191dc41ac7f5e070180d4843c9aaaf9c71ce29f", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x09247BcA14D8222D563668771c3EAA2830A61dC4": { + "index": 38, + "amount": "0x01", + "proof": [ + "0xf69ac87d8fe0354073754ca6f84be055d92123a55f1d8ca80fb6320445314ced", + "0x44cbbeed7b88c4386570b5c8e618c9d5290e2044c47bade3d6311e3d36263b03", + "0x3cf18ad5ca915c66f70477dcf495054eee4647174a0cbbdc03c3a2a0a13dee2b", + "0x11f5a22099e6617cfb9a813c15cac667d29fe00a5f0d1618572f9c1368ac6385", + "0x8e7f75ccc4d864471b1a7ec71efa29a4e8cc4761c26a6987c8043d9ca642a2a0", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x09430565E3a38884FeDD42E5FD0E05656F7B24b2": { + "index": 39, + "amount": "0x01", + "proof": [ + "0x10dde644471a0e75ea2993d1ae7fc6811b0f443bbec000a261f2d04422a1f25f", + "0x4c1cbbe795567fe73702ccafcb7210ae8c0400539910bddec0f986a073a2f5f4", + "0x2d080e14bc6209922a0f1386a059fdcb9274a63e7b85c402a8d63fb6bfa35125", + "0x2eb27b26c39f3350831b9042b1a0e6295ae6da1b11f07f10b4a83da8dc66b536", + "0x4bab2069d20a5d1d2f5ebdb61803a57609b7709eca9e925e31a7d14434af1326", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x094363100FF589b142Ee74C8c90340c388Edecfa": { + "index": 40, + "amount": "0x01", + "proof": [ + "0x484fee9970ff9c5a4159f3ff8dbab97ff22808e9de285797a954f599670a1d42", + "0x67dc31eb86ead2b664bbcd08dfbe333cbd85203640629b59eff787775194f429", + "0xc117d5a519f6e0f840872df99b897139406abd328261f34a6e382399bddb5bca", + "0xa5e8bb53f83c3715772cbf32d53d2e1c1c9b5abd0d51618f0e2ec2960d9a33b8", + "0x43f59a603c2458850547e5a84d47e61be843b4a3c814303ed1b52e1e4d37a1b5", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x096264b480512B7fc44acf4eA63D9eA899E518ce": { + "index": 41, + "amount": "0x01", + "proof": [ + "0x9cae96a16cf810fc003d6951372d00804db84a6d496b2acfa258da94e31776ad", + "0xeb9a72ceb9e987db10e8ec9b26152d9e24d0d0bda5769fe7fea362f5d643a41c", + "0xe767c29b89a3fef6f98f344b4b24add9c02f5cb6d6e67d487d02bc732178dd9f", + "0x2710311af5d5c72181aeccf7f1e36c3065b1ac40ab236128e22d5cefe5ca9032", + "0x0b385e4882f89784f506afafe6dd217c6ad9d142ccf58713e27961d25b2c6d0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0998160bdF3Ff6D86A4E9D5c31e0eFC3Ca7e7D01": { + "index": 42, + "amount": "0x01", + "proof": [ + "0x835e17f6203a94c2124d1ed9e82d688090f5c885e552717b0dc9833842ee32c4", + "0xc0f3feeaa2e0c1f96f57682c3681c383d91522fc2d625de91138dc693b4ce03a", + "0xc1327fd5c0d304512764186ee58b613917e50f9a632100c058142561a8ca2611", + "0x02cef8ccb3c7906e41a7ed9d223c95f320f2860a3d5a5dc4598d02362970eeec", + "0x9dda7d74fd49fdacbeb3afcd37c878516159fe4b594e491ff7ecbc80fd8d6808", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x09CF915e195aF33FA7B932C253352Ae9FBdB0106": { + "index": 43, + "amount": "0x01", + "proof": [ + "0x85df3a9e815125b918e13caf3cafd9aa03aa00bec3f595e1a4308d43d92b07ec", + "0x199abc3952348c45f42cff88fef339c1f9b3ad7bca996eaf4d0c3fda33ff3fe9", + "0x6bd30df1554552e0e9b030df3da576a8a2771bdb0e518021ef2f17fad6b2fe6a", + "0xdb5507911490bc1574fb624fe6bd570cc6afcd947118f0c9c38fe90a00ee8b29", + "0x9dda7d74fd49fdacbeb3afcd37c878516159fe4b594e491ff7ecbc80fd8d6808", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0Aa350FB487F75d4f5d6ED920A5ae0923ded06E1": { + "index": 44, + "amount": "0x02", + "proof": [ + "0x3b3e950cb0a24e682231e8d83096705161d1a63c59ab1cd7f7a30ff1c535c435", + "0xfa57d760b889735f50b5eab928528ac69d97b1713399d7aa8437b0144bf99b8e", + "0xc2aa8ca221a28e31ed71a4539c43e41e94c128f08a109bd6a1b093e635ca88f6", + "0x0f96aeb97a653e888416c064689ed19e2c4f980fba2ae619d0c47550168b385d", + "0xb5bb98883f5ea232108866e1400cd4067f34fc2d70605fd2c67051a6095af7f8", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0Ae3d5949202165584A270cbac7A733b0307a766": { + "index": 45, + "amount": "0x01", + "proof": [ + "0xda4e5f749440615c62ef019ab486d51675e590a31651c0d35e4d8ea6915e8e4d", + "0x7fbd4fd3ba3eeae8eadfcaa188b892e34ed2832c462eabc0bcd5136ceddc2d99", + "0x9dabc5eec4ef62215a8dfd99f8da29641f4d2cade52a73474d7fa008bf611d21", + "0x3cc86f19d7ab5abe54cb84f21d19174b3158c792e08130d0d4f813b822ec451c", + "0xd8ba0ec6899e7ab5afd6774d7465b2ebc52e677b805f74deb131b1b243bae70a", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0B7E38BF0Bca35D9c5b435DAe88aE6C74aCaB7ee": { + "index": 46, + "amount": "0x01", + "proof": [ + "0xad22f77bdb2601359fa81ad4697ac73a17584a0044a3141a1d64af0976337ddb", + "0x05a502a53d1b07fe2bed7d2b2c4a37e626b6fb6cbc1751fedada4af414510237", + "0xd7ee782e7b8b92e8ee009d7874df94ca08040bfb250a415f26b44bde9008b154", + "0xf685abad756fc52292f02befc3f5465de8d8f16cce61117b3f5de4fc38a60819", + "0xa952d1dc401036dd357d470bb699a7e9cfc64f0caf6dc51a638cd2487f5e73fb", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0B83d0C0976b71724054E9F74A471F7d1c7AbDc4": { + "index": 47, + "amount": "0x01", + "proof": [ + "0xad43a10e20b2bb21b658b15aaa1aea7ccecea2d41064de5a9863a0e5e4f675f3", + "0x9607e1060d07f16010086b043ab302ad2f3781b1a171a1ed56fcf57f2e9aa2a1", + "0xd7ee782e7b8b92e8ee009d7874df94ca08040bfb250a415f26b44bde9008b154", + "0xf685abad756fc52292f02befc3f5465de8d8f16cce61117b3f5de4fc38a60819", + "0xa952d1dc401036dd357d470bb699a7e9cfc64f0caf6dc51a638cd2487f5e73fb", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0B8c527b763d6b14E20c4aC4Acaec957273739D7": { + "index": 48, + "amount": "0x01", + "proof": [ + "0x9caa9a2beb594eaf0836676bd25183e4e2490f2c04f95b10e997061c29ab0dc0", + "0xceb14a87e05e18e322519107ae5ea9ef1fc0125141887bfe7989570d7a6fd3a0", + "0xe767c29b89a3fef6f98f344b4b24add9c02f5cb6d6e67d487d02bc732178dd9f", + "0x2710311af5d5c72181aeccf7f1e36c3065b1ac40ab236128e22d5cefe5ca9032", + "0x0b385e4882f89784f506afafe6dd217c6ad9d142ccf58713e27961d25b2c6d0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0B9e7316297D576012fBFa8BCD9B8c35e316d53B": { + "index": 49, + "amount": "0x01", + "proof": [ + "0x4e29c8c85dd8db6d2b6a9d11966cf492e7640d71283ae667f3cfba18014a56df", + "0xd35de31a11f2c71104f9bb4d17986cab48f3fb4323f24b6b902a5d5d7f2d42c6", + "0xc9b824e8443131ec044d11642590dda66ca265300328d8dbe4689483b562b29e", + "0xf94cc4240e18301aa3e9325f55d6ec2e2e84a181037fd49b69a29a1aedce082c", + "0x43f59a603c2458850547e5a84d47e61be843b4a3c814303ed1b52e1e4d37a1b5", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0BF6305D4382C37a7C330604048AE9813DDadE28": { + "index": 50, + "amount": "0x01", + "proof": [ + "0xcc4320f24cc539384c3462315c21bdba1fc2f39120560c4477087388cea79831", + "0x100c90050d686ceef1ea638893036da3b576b84dfdad93442b36888a87b33aaa", + "0x283f3fb0109ecec757290961e9c3e0c9092dd7697857daa95c6c89647800e706", + "0x9bd1c3205e48cecbaefedf96e5d998ea4bb84adb658c966bfa31e3599a4a0ea7", + "0x2e78635a0ed4a14dadd872d564c5dd2afc4f21b0307932d27d4471c48082b7f3", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0C635dC500222aF8a12072922C6aC5a4fc536faC": { + "index": 51, + "amount": "0x01", + "proof": [ + "0x40f68576fedb9bf260e390df6f44c53d2d08d2a380e93583dea88456a9e32dc1", + "0x3fdfb5850e1ad0d463ae605dd97fb9c2e1f82d5cde33c885397112bf83732cc9", + "0x308e3c3f0424a4c813565e783cb4d79cc2927c1d11c780b46d52f0c53a01784a", + "0x3ae549d14256824a2b8db4d8292224eb9b3beda41a6712098d825d2a32cc6dcd", + "0x98ba92b6a1d3418a3c44b684c9f0dc2177f48d3a6b666334d112dacbb6f5acae", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0C89176C253a78CceC62AD8D0a037b9448fbA8c5": { + "index": 52, + "amount": "0x01", + "proof": [ + "0x332dfda7edbe6c3e788ecb8bbbf0e163072304f214ccb86cd32362f4574691a7", + "0xee991f9d916caba88413353602ea6bbc0a227642f7d3405f16a01948480d2756", + "0x2ceb10a8fdb6b89453aa45138287aaa29f977b0aca5b8c98dcc42bdaf69fa298", + "0x9c7a414e889956f4c85241ac1c103f8242a6795725b10a2a17d9a1d125767087", + "0x963cc7ad3f8f0ded379d05906b629df8cc616633784013c90731955d0b0736d8", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0Cb38052ba5D15DBEe0Eb4cB6a1779F28343DA09": { + "index": 53, + "amount": "0x04", + "proof": [ + "0x5f722156083a6bdcf520cccb778519a8379f12027ac32b34dbb564eebd560786", + "0x67791dcb4b866491f2d6208a6071883bf8999654049486544c9a5540e6391435", + "0x235df6c4bfff7e5ae5051713ca9a7dc5664282cfc88bace4488c612d23aaec19", + "0x70db17f5bfc52cce1e5c71a7571d4c960efb51e88d7fc8b1162dd074c38f333e", + "0xdfdb156cb5d2b90a5253163570fe08739b17ab3fc383c79eb041c1d1a667fe84", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0Eb96D5ec478B68fF0d48628Ab4DF6A63c21ddAa": { + "index": 54, + "amount": "0x0a", + "proof": [ + "0xd01de81e7184f7db95e6b7ff44ccfa2f5313bbdef1791ec6d2df05ef0d64e4e7", + "0x5d055356ced4e10b8976ba076c2fbd99736886f69869e724ab4afb0d5dcd3c20", + "0xda6a400b1d206393ae5c21fe289d6b139252aa072673d47cca7709e41439c7e9", + "0xcea68af505202af90a0679269376e373d9ceca250970bcb6953e0f30f5dcfc7d", + "0x85ada07677b521b0dd2e0d60f51f92f7b1217f46e36379a5afa5a74fd5c87a5a", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0F0eAE91990140C560D4156DB4f00c854Dc8F09E": { + "index": 55, + "amount": "0x01", + "proof": [ + "0x309e5f46823cf12e8653da795e411b39d6d3316b49d9f9c3023cbb6339183cb6", + "0xe3c03f472eefb48125de49e678cb3cbfe265531d0aa112ba2cddf16904716926", + "0x84397224dcf960c935f9f1d840b696834d2c96bc90fb990bf0e58178e4151092", + "0xb74deb44e6419575dd75ff4fb4c2cc26c6f8bccff72ef47a08f3f27e13f3de40", + "0xd6d09ea62a0a0959d8a1f1cbd849b805597a75fe443bbbc4d5e2555bf8225437", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0F56F8f29eD1766a1e3950c85a741060bCeEF557": { + "index": 56, + "amount": "0x01", + "proof": [ + "0x78b17e5d4240796184e17054146d6f8d4dd0842ca8e089b23c428b5e19b978cb", + "0xd7f214ca7ca4b7f3eeda982d1033c6c109dd9327a692fd65ffa8f185241e3b5f", + "0x430e9eec036c03066fc0319049daaa271c11c2e68b105a49cf5a3f241fa703d0", + "0x9b12cab9303ffdb5818321d84969747034ab90e273c8fb6d0031d1f6e3e1f83c", + "0x80cf615f05f15e9ed665dd7df5d086fcb70ed5a5086e02db7c08752fcaab6507", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0FAc4EFa9Fb13445Fe1dF54213602Db311688516": { + "index": 57, + "amount": "0x02", + "proof": [ + "0x923c10d277e848b268e44bb0fa9bfb6f9e74720e9c3b98cbcecd34c3466fbfc2", + "0x3f2b0450f93a25660c625812580e2dcaa6f91c463f685fc0f4c507c9f6bbe00a", + "0xf7812c617fd43b12d11ba57fd1f9b80022f8cbcc05f057d95b7bb516ebef605c", + "0xeb79377abd71cdb891e1379260c8fb1947760c17e28c7168ccd62f5d772f861a", + "0xea7c0076ebef0c429d544548828ff19d5600136801cc28845bdfa9990d97a058", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0Ffd670749D4179558b6B367E30e72ce2efea28F": { + "index": 58, + "amount": "0x01", + "proof": [ + "0xb687100d5d839e7ac7b02008c5baaa24a92fa24643f57fb047c34dc46a3908ff", + "0xe4526e937dad465c204fa88891d630722d9e6d3e97e7eabc336351d4f30490c5", + "0x2370bc3e49aeead81a8f59e3d80747fc9da94142f3be3098f2b9504a9dc4fd7b", + "0x841ca200e81dde455c9bb72802b7b377b46a9d6779eec08b07e61939b8d43c1b", + "0x529f1b48ab616d4dd60f663753a7779d8ec25952bc8c34df4aa96347bdb0d542", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0a50f6f860075D3a20327B8210D95131872eebe8": { + "index": 59, + "amount": "0x05", + "proof": [ + "0x95c88fc88e0a8ec91deb90bb3e34f46980771ac0f62e77103f6aa8c243a45c09", + "0xde1bc7c03fdb02b201652e08a3a21cd6746b818430c282326f24634230597653", + "0x1e8f6edc1f9dfa901b23584d944d29352277c21bd90680f8bd4cc7247d86dd9b", + "0xb27289c273000ad0db5ed9acba0b01be05f672a2f40d51317a96231114834c95", + "0x62ba7b58fd554e8be295bf9d4baf9eefd0b518ead5cb8bab321717a08160ae0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0a7550f4b6AeB2645BA095153DE74367BA294DBE": { + "index": 60, + "amount": "0x01", + "proof": [ + "0xd6d31a663d15c4d896e8a7cf29778556ab9401f697a111d9275f7fcedc7b0580", + "0x07730ce4488fe2287bd7d607130c6e4195a27714289b2ce16b743b707fdeab7b", + "0xc38008defe51c0239555c45ec16a876cbbdd254e08722230d0d69a1db6d54953", + "0xd382b6f12ac3804a083f91e50c5b4faff460036b8bbe9e3c74b4468370b346f2", + "0x57a1600e1002b648fc38956dc1d2f34be5ee3f6cf170c73bd27c43b2a01e45db", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0b869f689f1e80Cd630b0135B576C3eA1E8bC78c": { + "index": 61, + "amount": "0x01", + "proof": [ + "0xb01392caa72598162fae2c234238ed659765a99ef6f2826e33778b589bbb5207", + "0xd7061525778fa3fb49d7f0936ea2fe4e8e443e40eb600592763fdbe9ce723c86", + "0x3b785839cd26b611d66f8b353ee5f32ff1026532ac266e55f2864fb32246d378", + "0x577f81e56558cea5cd9d5160218e718fdbd9b124f0dd5499c3e14a238415b645", + "0x72373ecc225af245878bc638c49c8901db1430b7210a3008231acc8f8118d2e0", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0b9715C99e38D1a52A3cfB8A60627d249ba0dfF2": { + "index": 62, + "amount": "0x02", + "proof": [ + "0xae0fa55ae7bc2f8b92a80547935aa9424575372b1f32c8f9bd81a18a36f4dced", + "0x04d02269b25155fbc9a34072518480cc8ba1806ee9df4cb2d6e207542bbeefd0", + "0x98dcf697690e69aa965e2413c9bdda9a1af7d0ccf6a569bb34035b0369e22372", + "0x298bc701f239e72f83c6fbd5aa5172caa103b1453ebcf9fd1dfe23628f4dad14", + "0xa952d1dc401036dd357d470bb699a7e9cfc64f0caf6dc51a638cd2487f5e73fb", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0b9Eb7C23Da50dcb52F070E171DD53980082e77d": { + "index": 63, + "amount": "0x01", + "proof": [ + "0x599f3f8eac149a566ec027ff75822bc475d12aa3f1a8e7784855b8ef70b26ab6", + "0x60aa814bbf80a454545653f32fe51ef43892a92d8211ca558afff6153de13565", + "0xf605611ce1c692b9714072be746e6b2642baaa0e106fff51378e6de24bb39de1", + "0xd34d09ef2d0160dc3204b5dba612749c3a92de5f38fe30c9dfc3d0d199e36074", + "0xf9f105f90db6fe2970fb4e03b35654f9b69375879c783d3f1700e04b2e2f925b", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0c0a7e520ee9b0AA16972B1729c6722Bb7Ee32cd": { + "index": 64, + "amount": "0x01", + "proof": [ + "0xb1c43155e1aa104ca1cb7ff0bbafbe399190dc5690283a4fe4094b976d79d81a", + "0x2b8ccd99af23429cdf432903596a90f7c4c538ed69414fc53b41e6b1fc46eff7", + "0x29019a0cb0bda0ba23b44ca59094eb26fe840748f490419f63051f2087caee0d", + "0x49f4781ffbed71f831627c02425eed106f4714988055f5e0978de46ca35b3ae0", + "0x72373ecc225af245878bc638c49c8901db1430b7210a3008231acc8f8118d2e0", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0c4c5daA515DB24865cb38F281a1a2853dad3cC4": { + "index": 65, + "amount": "0x01", + "proof": [ + "0xca65b5fe233d606e155afc21a38450a872a0e2843469bbc7f183acbb8afe54da", + "0xed2f2c1e2c500d64f5a1fd0e2fd6a6ac4936c739ea792743f384e32352711bdf", + "0x44e28972482d62299900dbde770b7f615c2062b558ca8938a3d427799471882a", + "0x9bd1c3205e48cecbaefedf96e5d998ea4bb84adb658c966bfa31e3599a4a0ea7", + "0x2e78635a0ed4a14dadd872d564c5dd2afc4f21b0307932d27d4471c48082b7f3", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0d307D9C8B6D4aaD162A662E4bbFbA9Ea96A5F81": { + "index": 66, + "amount": "0x01", + "proof": [ + "0xe8558c7890321fe427c9f455800b74e6756a11c36e768096870de131986d3820", + "0x4fa7ce6d590033ee16a7b8a7d984006d773d9a00252a5d673993b621325745e1", + "0x4c4c1774cd1fa5133abdc712ac7336a6ec726c09e58e3dacc97192f36b62378f", + "0xa26acb471e2d600bf69b92e87438242435f7a1ed8e490016e5305ddbcea64c2c", + "0x3ac4ae4a4697e2400113df3bd55f84456aff86925f45224af80fd8af20592214", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0d94B6e4c2Aa9383964986020B3534D34885f700": { + "index": 67, + "amount": "0x02", + "proof": [ + "0xa82ba192c6aa36284b92dc5f5505c6d2711f30034a78d679f60d47391a7bcbc9", + "0xc877bc6b4ac51ad2d48575c87748ae94debe6948a8143e714b09ad09b0711ea5", + "0x31fc7a90e64fedd0c716849f9c3d85d7bb0f0af21a85776a85104ce4712fea76", + "0x21367d58d52b32234887e9e91e468488a647d2d7407cacfa709cd59618255499", + "0x59d5a4275936eb4dfca0d17bab02b4a25bd4dc43ef3aa0e3515a07f7c0f68a93", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0e2Ae98b93a865719458c2aC86F5591E4adDAD86": { + "index": 68, + "amount": "0x01", + "proof": [ + "0xcb17c6878c774d1dc52981b3fc570ef207a43cfb48c7c5b7426f5cd557b522c0", + "0xed2f2c1e2c500d64f5a1fd0e2fd6a6ac4936c739ea792743f384e32352711bdf", + "0x44e28972482d62299900dbde770b7f615c2062b558ca8938a3d427799471882a", + "0x9bd1c3205e48cecbaefedf96e5d998ea4bb84adb658c966bfa31e3599a4a0ea7", + "0x2e78635a0ed4a14dadd872d564c5dd2afc4f21b0307932d27d4471c48082b7f3", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0ef6E547DD86de09F0E8eCE1E5A9f5cCB335aDE1": { + "index": 69, + "amount": "0x01", + "proof": [ + "0x3b8dec61349d30daf1d9792ea7b7747aaee8831a4abc3e9cb3c5defbd8284d87", + "0x542c5f90b54a284b6731f393940acaf25d1a3f38f27d8ffea681fa179d93fccb", + "0xc2aa8ca221a28e31ed71a4539c43e41e94c128f08a109bd6a1b093e635ca88f6", + "0x0f96aeb97a653e888416c064689ed19e2c4f980fba2ae619d0c47550168b385d", + "0xb5bb98883f5ea232108866e1400cd4067f34fc2d70605fd2c67051a6095af7f8", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0f07EBbd719C9aAd480AcE5f6aA2c044E92380Ac": { + "index": 70, + "amount": "0x02", + "proof": [ + "0xbef02917b0b6d03592b397185faa2979d6cd09ecf1ca0baed7de8f3eacb44d29", + "0xc13a59afb72f6b99e40d7476264dfdfb0bfb8e74edba3803b60e51694c5d9e64", + "0xb8ba31195c91c8c313866172aa3210fabaf1ae5dc11c67181101d637d0e73050", + "0xde546e8389f64cf158f6546ecf18f3c473b0c5660810c1eba849db699f2c4883", + "0xbd7abdce9ec414fe47ea73146a2131622bdacb914ea6353abee1b0a149275092", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0f7338CeEF806e895A88c676d717043168A3E13e": { + "index": 71, + "amount": "0x01", + "proof": [ + "0xd7685c6ae354ddc4be8fb009cdfe61700906281ca47ea30ce93faaad3538235e", + "0x731d6d17fb186464deb9cc1244045b51347f9522b715e17c628f1418489278e2", + "0xc38008defe51c0239555c45ec16a876cbbdd254e08722230d0d69a1db6d54953", + "0xd382b6f12ac3804a083f91e50c5b4faff460036b8bbe9e3c74b4468370b346f2", + "0x57a1600e1002b648fc38956dc1d2f34be5ee3f6cf170c73bd27c43b2a01e45db", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0f87316EaE80058c4e489F752C057eC1B4d00A0e": { + "index": 72, + "amount": "0x02", + "proof": [ + "0x7b3ca71596dae77a481b592f5ef4159ae02a653e18ff3cc63c817d63b91dcce9", + "0x5abb765f1d646311ac232b61b47e72693e2e694ee181babe375589be9993b712", + "0x4c323856e3ed5872317143e057e5eb0b9c02e5efcad37c36801f077d7c535fbf", + "0x81cb79cde32d282b43e0e438fe2b6758f17fd2d569d10c780c800d4c492134d6", + "0xe2050f6c95c616c1cfdb04f4b6d0afb5afa0fb464f767c38aba0f07df915a97f", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x0f951699Eb95204107a105890Ac9Af6C587C260D": { + "index": 73, + "amount": "0x01", + "proof": [ + "0xeba65a1548e6e347b03483f2d768582121f026788dc3e93f53f65633d6a0d9d8", + "0x9bfbd72090a3c88024b9d2ba9181c3380417587b51fc90b0b2304edc64f7e391", + "0xde0c48888840a3a312e45aefc38e872d11021fbfb1c21f69dd0002cc3205c985", + "0xa6bb3b2aef22e52a1e0052bc5777bac639d24ffe832889b483d829660c1bbc1c", + "0x3ac4ae4a4697e2400113df3bd55f84456aff86925f45224af80fd8af20592214", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x102696290781CBEa241B19d0b9B0D2F8462a501C": { + "index": 74, + "amount": "0x01", + "proof": [ + "0xee67fb68f6f34d138cfabed16c04a78cf60fcb3ad577aa14d816cfbd0dadab68", + "0xe4c720a1a55551d11e715aa0329811976b18a8448e42ca24e51c05d4e75c1fad", + "0xc71ffc537d3b73c4d65d5ec902214853d0ca3a6ef44a38e578c0f12fbc4929f0", + "0xfbd5cea7e1eb5806f6f82efdb0e881576ab386159b1b3ff7402e4bf56a947d8c", + "0x58340ed8edb441d787ada6b1aaf2b1e42912724e1f0f7887cde9253262aa0534", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x102902245322aAd61D55cfAD8213472A5702a593": { + "index": 75, + "amount": "0x01", + "proof": [ + "0xbaef7276ad865296be1abff94a62efb5cff502d7a4183259b9067141226b14b0", + "0xd6cd14298018d0b1eb6afc73b1ec8e58665030456cca48d4ebb8f1b29a924e32", + "0x3017eb0d540f971e8043a85f710c1ca576ba8ace44cc77d31d57c352236b7562", + "0x6a8275b9d29aafc6358bf9f174b96a6a2561ace2c21d2edeb2a14975f0d9b0c1", + "0x83e262e483a6f2ff9f4df14637dbbdfeddf0c6b0b4ca462c4375d29a3521e052", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x10534D4e612071E6B6480C498dd8BDB8f51b9ed7": { + "index": 76, + "amount": "0x01", + "proof": [ + "0xa3ac4b36fd135715ecab39b7d6473648198dbf8b807438fbadabf08b179cdaf5", + "0xb1ecb70d62cac7b856505e9d704ee9608347da8130e989925f729fe25fadf52f", + "0x2951c6889bb57f842bbebd143d63e6a3223010b180cb5d4a43421a7db1a043b3", + "0x9d1cf6e9f51d85a77dd4eec2524ba22941ec238f140f4f63c1712d78c1e4c21f", + "0xdf701aa8bdb3ffefff1b359214087cc585fa0a0d40716a6635a8d2db4380dba1", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1065d2693FC1cC627f746ADE3ca5D36C37762C13": { + "index": 77, + "amount": "0x01", + "proof": [ + "0x53bf7010a8c42d3b568dfee0c91c02910320ee242e71928d97d9fd8ca72496ba", + "0x7afac21ac2d930fcf47949be2e43e5cb949155599b2463700f8c686b2e91e23c", + "0xe13a3f7e9464f63c11cdf4d34aff17ba3b16eabe825f6978bf103f72f771ab75", + "0x7a5397945a42b48bf4e4ee9c21f985e9d9ccf82e57fdb87dc2e6046ed345d7ec", + "0x5477c93aa7e191fd8f76e1976387fc82460220dfdcee87f9ba8926f4e0ddf45c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x11414661E194b8b0D7248E789c1d41332904f2bA": { + "index": 78, + "amount": "0x01", + "proof": [ + "0xe669c364e80e5d60294a17d9590fdd12aadebca096784e89ec78ddda22c05034", + "0xb689c19b52f895a38750b1f653e015e69c3b78cdc452e8bbfa5dbe7bde5d3f43", + "0x46620257535f86b53d54bacefde5f7e5ba7d4ccaf37a80ee488adfb5afabf427", + "0x46903c3e0f26b709802c8a2743505337728e1f805b4f936ec91df4b3f43fcdb9", + "0x7a545b345b30e441bb780a4fca731a87b1e941b75518a9983a312194a9e7bd46", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1223f9446FFdB6b35C2Af3D81C0e7c0171965BC7": { + "index": 79, + "amount": "0x01", + "proof": [ + "0x94357beb4c7b1db7cb96a40eef39da755a166314a0a5785f5f2382d8cbc6124a", + "0x66672313e9c71cc3d855068625005307693a85d0f5f8f9eddf0637bfff66604d", + "0x65127a802606ae04f5ee9995d26ca3dfc8479c1a808782e60eea9ed7332ee2f2", + "0x6ebf988ef586adc2237357c1611e0a6bf7170af1257d42fb6ef98df1f5052439", + "0xea7c0076ebef0c429d544548828ff19d5600136801cc28845bdfa9990d97a058", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1223fB83511D643CD2f1e6257f8B77Fe282e8699": { + "index": 80, + "amount": "0x01", + "proof": [ + "0x1df73a6330d3bcf9920ab93991ad646def215a6b9b542f0de51b7268cf7a1f1e", + "0xe6e3d5d7d65a8285a97cb7f48ca8690869c862c7e5b3a356e4c2195630282403", + "0x02c2372e8c71ba8e5b843247d27450214c544f74b4dd4d34e7ba17d64e09a617", + "0xaaf60b5ecf22563f090c456c87a77833a8ecad31ad25f79ce590acdcb7f64b01", + "0x8e0cc5c13324dce3ab0f042d31a9db04afe0918f70e3f4515f43739791621c97", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x125955cd603650EB3b1c0cF000Ab78aD0213DDaF": { + "index": 81, + "amount": "0x01", + "proof": [ + "0x41388b4af130087adf6f747621ad2466a362c32097c38a4f3c5b622a52c0b7ba", + "0xfd22bfc81a6a21247d228d835e39e9a76330c90fcdbb9c6abfa551d616927a34", + "0x308e3c3f0424a4c813565e783cb4d79cc2927c1d11c780b46d52f0c53a01784a", + "0x3ae549d14256824a2b8db4d8292224eb9b3beda41a6712098d825d2a32cc6dcd", + "0x98ba92b6a1d3418a3c44b684c9f0dc2177f48d3a6b666334d112dacbb6f5acae", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x13B3A50F3947476eDa74FE191344524E2d2D28e5": { + "index": 82, + "amount": "0x01", + "proof": [ + "0xc2217c81687c68d8f9ebc5e13b62de527341140e176cfc441b0585ed9782cf44", + "0x10ee531aaddb92e26719ef6bed1a146b451fff0574746ae9ed53adebc2b2e467", + "0x31c626a13fd36bf9222fabb7f884eb7f6bbc58d99a42ea76aaf069282a6bfa97", + "0x65c5caf7f221e805a211309d005cab013498255a9343870184292835ae911371", + "0xcf22c1d43a94c7c6471efe1209a3b103ec0a9836b6c11fe8d2e98d18b2e9cb36", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x13C03641c376Bbd2113e7fDD02e92D0BBef72511": { + "index": 83, + "amount": "0x01", + "proof": [ + "0x4aaa84df9a3fca48a00bc3ec723b799d6a7d830d551470281f2bc7d9a19e400b", + "0x56789b290120beface5f1a313d463e3be8c7a7b01f372a61a84dfb3ff45683fa", + "0xf51571a8d5447a22467ef7675b2c9fdf62254f3d4938a09245fc084f4e588343", + "0xf94cc4240e18301aa3e9325f55d6ec2e2e84a181037fd49b69a29a1aedce082c", + "0x43f59a603c2458850547e5a84d47e61be843b4a3c814303ed1b52e1e4d37a1b5", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1436DbFfBDde71d16A2c4d23f9116c3158c4d984": { + "index": 84, + "amount": "0x01", + "proof": [ + "0x9a81bd6ce88fd1d5b08ec75ffae0849c7d13ce93d3c47d879dc175992cd6a980", + "0x82fb3c54e4280ff876c5e9087a1eaf27371b5a05cb7a1501f569488f3dc678d5", + "0x265c302052174e496eaf88164e054aa106d99c29ee696e11b9c7df66fbb1a01c", + "0x0209cc90d619e0e5f56081126d2ed4018391f3d9e1dd1238794235d656c68c9b", + "0x62ba7b58fd554e8be295bf9d4baf9eefd0b518ead5cb8bab321717a08160ae0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1462f0C35a3e48027aD72bEf4E3925Aa4fB4a14d": { + "index": 85, + "amount": "0x01", + "proof": [ + "0x8b62319070f9f15f25d1723dacb9b649a4800e8c27230912be2917df5248ee38", + "0x845212089b665de2d81bcc7f905c61a3f7c17bbc31a04509bf09ebd63ed26aa0", + "0xeab5b9106c246e423a3bad13324b91b16f3f43030108260127abad6f7f52e76e", + "0xe04deda4b0f0ea0bda4320a7f8e55700dc470bdcfba68775214ca25f30ccc348", + "0x8fbc13f50b0f82a781945a74ddd5c5abde0b4a8983852c66ecda77a68df50722", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x14Ce500a86F1e3aCE039571e657783E069643617": { + "index": 86, + "amount": "0x01", + "proof": [ + "0xdc5cf01d5daae47a4925e5953e4add9d3621f71adb0ac13fa58ed68441d3d498", + "0x685efb9d9308bf73ff6181b7306e16598ef4e74948e5e691e458154b8d8d382f", + "0x0e3f11231eabc58db4785530d98a166f67094f59b7d8140612cd5b4356e4db3d", + "0xc84beec6531767197744c2106caed4823936b1ceed7475952444acf832b57446", + "0xd8ba0ec6899e7ab5afd6774d7465b2ebc52e677b805f74deb131b1b243bae70a", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x14cfd6b71163360b2a176ea167c2800b2DEB8296": { + "index": 87, + "amount": "0x01", + "proof": [ + "0xa5ed2eb003b9b690bf31000405a6f138dafba267d54a165809e37fa197ee6eda", + "0xc4af8683d87f089204d6e24c965f84bca5121d5e247e19e4ca2b1c436e43f535", + "0x749ec840687b0c3028d9ebbc2bee7d5e4b09957fcc6d0764cc748253b597e007", + "0xff4bbb2da92e4f9e24f8d79cfebe3e93428702c14b9f4cc9993761fab9d19c9a", + "0x59d5a4275936eb4dfca0d17bab02b4a25bd4dc43ef3aa0e3515a07f7c0f68a93", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1540F6fA70c04E5a5daC6A134D9dD03Abd301B1A": { + "index": 88, + "amount": "0x02", + "proof": [ + "0x54b281bbbd40558d97bdcf7eb5c4b5c7338dd28a7e7dbbdc2f07beee87345288", + "0x5e884faed9d652ecdbeef8dcbe3007213a8c6607a1d23dc7c7ad2b55ad40ed4d", + "0xb38048ecbdb0d7a97188f59825c94f13ca314f4be11d86febd1cdf302e0326ad", + "0x9104efb4441e61a09b4e458e6b45f6759c37c20733b5823cc04f759cc53d5575", + "0x6ae25cafc683eaf0756d86c89deb0abecfbfd01e812ffbed4e7a26f11cb91f8c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x157fBaF0669a0ADd1dbE269101507b46bd43a7c5": { + "index": 89, + "amount": "0x01", + "proof": [ + "0xbda5521bd63b4d8b36c91b8a520fdfad543a9e72749ba61a2598ffeae37e2d20", + "0xba774ee7cfb4eb415c01e38c1f3f8b4d2bb5ccc4208962e2eb17dc2c23d27b45", + "0xb47c664b127e95ef186434a19e51e8c91952a09c8b6513f4afcf82c63bcec3b2", + "0x3886e44b7873439ef0a83b4119fca7dc640ee0f9551983449d038a076169bb1d", + "0xcf36a9c08620752945fec2c3138a9b0eaede19862d6c5cb3c0489e6ab3a443d3", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1592923D399Fc2F6A7ee416e776D5158E6d13B25": { + "index": 90, + "amount": "0x01", + "proof": [ + "0x03b029ec56e170dcba4b112f383a9b93ce1484b24b81afb38f5c8b37393a8a72", + "0x64408e702a90c56ee3139fe4bc3cdcc9899fe539ef782acad103b26f6edf174e", + "0xc9a2fcc0e974df7c3918b7b263d9c6dc39dfe6718696db40d299f59e058f7949", + "0x2be850b7e0b2b6c90dd3488b90e348653e541a9cd2983b235559153dffffe1d2", + "0x9be1155992502d2b75a54fc5b2a41d663a86f7d329faea1befa0e24965b01a56", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x15A15D5dCE42F98d7BE1D1a5DF6230de96A04346": { + "index": 91, + "amount": "0x01", + "proof": [ + "0x14b6e5e232ec84573c4c3217949f49bf46a4f6fd759ca8a9685e1fa9d97ef992", + "0xf9d7af9ba5ece49701dca05ac2748ebaac2ab1f6e47bb5e7af2d8c77d042f41d", + "0x6ad3e4f2caa71a096b05092a987778161c94be804760a6af684872b249faf74a", + "0xd4e406b94f7009e26e52781d8bbbf71780c9ab5d8d7b9162b8469ca115683ffc", + "0x6431c24d3d46ea6b0d1959c0de03265dc474d3e67139f2bedca26b5aab0c0c5b", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x15B9b0785d18Af9968AC12e26F70c9D5200A211E": { + "index": 92, + "amount": "0x01", + "proof": [ + "0x9137759903506d1f1708d7efbeb30ba0e9a504177e3d0d3388c55123bf3f3287", + "0xaeea21490325a3ccdb24ff2530c090bf62fec7ed45dca1c13565c4aff6891a40", + "0xad5c895abbeb22965da16b0fe557d3867fbef2fd9736aeb313fd9e3058d4bdba", + "0x0a650a18b5dc7e14051f590d1612c3614c677cc931a3bd72443efdbdec9b6fb6", + "0xa4e0ebcaa65c6595e7c7f0ffb89992e2b9cb58ac405c81aff220fc4b16ea3b6b", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x15fE8337a6E23629Fa09DC6e0F8b041D681ec995": { + "index": 93, + "amount": "0x01", + "proof": [ + "0xf77d20bf65f7080ec319545684e9ab64a13f52e0543bcc693e826d1dc521547b", + "0x9fb5f4a4bd513d564fa850ee9f32a558bdb7e894dcbf8b67ae342e594b785c7d", + "0xb68e26a6daede6ed892cd902fb2f19d6f490fcf8f0dc6a9c1fc42e9c75cb8ce9", + "0x11f5a22099e6617cfb9a813c15cac667d29fe00a5f0d1618572f9c1368ac6385", + "0x8e7f75ccc4d864471b1a7ec71efa29a4e8cc4761c26a6987c8043d9ca642a2a0", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x164a15E16D697c2F8aC77c2866441f411365D396": { + "index": 94, + "amount": "0x01", + "proof": [ + "0x3494878f9f10ef76b0ee72a6a07bbb559aa8921399400d9daeb63c63d4c91956", + "0x9ca6228324b6e39fa902ad430cf1a27bd84d4cc6a7ebbe3adb02c0283b384910", + "0x0d061c4a4ee6a211e679a3211e00807beb57846100abc7f5eebc13ff2b92ccdf", + "0x9c7a414e889956f4c85241ac1c103f8242a6795725b10a2a17d9a1d125767087", + "0x963cc7ad3f8f0ded379d05906b629df8cc616633784013c90731955d0b0736d8", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x16669C161e27521D96cBc9d5af37f24Fc70aE8ca": { + "index": 95, + "amount": "0x01", + "proof": [ + "0x7937dba3c52f5b781b1aa537b50241b9dff557dd0511780510da9fad6fcddb90", + "0x7d0117083b95e78fd1027c446d855489ff4ce1efc8dd32492e266cad463603a5", + "0x3cf840f671484c5a4854a9e7a16c73913cc5e1ae358e160566aa35e0ef06bd1a", + "0x9b12cab9303ffdb5818321d84969747034ab90e273c8fb6d0031d1f6e3e1f83c", + "0x80cf615f05f15e9ed665dd7df5d086fcb70ed5a5086e02db7c08752fcaab6507", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x16abea6bF03a8a90204632a0c7e8188064b0a1Ce": { + "index": 96, + "amount": "0x06", + "proof": [ + "0xee320c4a625eb1307955574af273a3d97fd5a7c031c95bb39a53ed592ee29ed1", + "0x765870671b1dbffda85c7d9df5b5d44b185943d93e3e939be1ddc037a995e2ee", + "0x87f9ab6301cfcfa1972d69c933df7d435beb9f98f524bff8460141fe4ae2233f", + "0x88222db835a579969caf99eebc6d7f986a78bc44f46b794a4319d01749c83a2e", + "0x6e496426985c92b04963088da4856230c781a975dbb5ce2d8eed77e7d2d4b58e", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x171741790d8a84D729Bc6b06C066b2Cb25aDA477": { + "index": 97, + "amount": "0x01", + "proof": [ + "0x28d624b71ed4bde7c8ef1686160e8ffd64f28e67fdaaf8b55e121388ebd3b146", + "0x339aa5e81863bffd265f632d3fc1cf781d9d2bf685449f05ff59e00283b2dc6f", + "0xc62b818bd2a34acad67723e97f8667eec6de397168029a2670ec2681852c4b26", + "0x1ff461854683a34317216055e65b6637346912d1739163d25c1a0b0a5f15c25d", + "0xe29ba79106b7b14c14912bb5fba509f27997ddbe5a7ebc941fa75e3475af4aef", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x183B6267cb9F985A8AA7Fc912672A21d644a4102": { + "index": 98, + "amount": "0x0a", + "proof": [ + "0x3b95bc6b1ffb4ec137860fbd7d4c55223ad922de4e48d9d013648a9541973a04", + "0xd47ffc9ccbeb4f6924016ee29a015a3b8fa1de8ba39b46488efbca12dfb0b6f3", + "0xbeb2c810887b1f03a89248c556855316973dd3f9f824dd7608a2162c3b2e6c6c", + "0x0f96aeb97a653e888416c064689ed19e2c4f980fba2ae619d0c47550168b385d", + "0xb5bb98883f5ea232108866e1400cd4067f34fc2d70605fd2c67051a6095af7f8", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1867aa355db059D649Ab84CeDd7F0403d11d6A37": { + "index": 99, + "amount": "0x02", + "proof": [ + "0x0963b5dc914bf5cd78e3dc5d78c25380111070f5b138c95158ed66a3880a9090", + "0x0f3d869910a29584f2bb769c71a685dbb4dbd507b4f91fb90373cca58fbd1efc", + "0x4c45a6beb436ef04cc6902dca8ec98a6004150388bd0a3f1f3e1e8d205a1e2a1", + "0xc50cae5631fa8cafae8224329322dbaebc117b278a8e07f29104d255198d88a8", + "0x4a36dc66177a8394f6b14fc9adbe4ad7e0cc2dead6acb72d80990e336fef8d45", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x187D6e8741Af35C45198EbeC83905eB23e742B15": { + "index": 100, + "amount": "0x01", + "proof": [ + "0x96be5b9a61bc769c691a7406ad7afde2efa88821dae9f7e23e26ff473d179c8a", + "0x4917c7a45d2e51f374f1f90b304fad3fee6aee02a1df1223086a532c4a075ca6", + "0xb575a968000894924ae64573326e1018adeabbc274265be52c946debcdd4eeed", + "0xb27289c273000ad0db5ed9acba0b01be05f672a2f40d51317a96231114834c95", + "0x62ba7b58fd554e8be295bf9d4baf9eefd0b518ead5cb8bab321717a08160ae0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x18aF3c70b0AF8534b47dCCa0c519D12570977D99": { + "index": 101, + "amount": "0x01", + "proof": [ + "0x562842075fb74c6a48975da6a11ac7d416946e5fe576f3caec0d97157026f8ed", + "0x3f9a3940905021f1f8b6b86941a1d2081d0d4fd2d0179e4b623586da99ad8581", + "0x782de94c988da2786f9e32de9d24aa87726a07cacc4ff5098224c6ef0c91f0d7", + "0x9104efb4441e61a09b4e458e6b45f6759c37c20733b5823cc04f759cc53d5575", + "0x6ae25cafc683eaf0756d86c89deb0abecfbfd01e812ffbed4e7a26f11cb91f8c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x18ef177eBe8891B1eadAd99C9f320bD75284C4E0": { + "index": 102, + "amount": "0x01", + "proof": [ + "0x918ff924c625d4bf010ae281557819d24c207cdf5413ac3075a460eff63e1bd0", + "0xb2de5832d2f0af0d6a33ff4f599abcd84f2133f0113f088ee81749d253b1eddb", + "0xad5c895abbeb22965da16b0fe557d3867fbef2fd9736aeb313fd9e3058d4bdba", + "0x0a650a18b5dc7e14051f590d1612c3614c677cc931a3bd72443efdbdec9b6fb6", + "0xa4e0ebcaa65c6595e7c7f0ffb89992e2b9cb58ac405c81aff220fc4b16ea3b6b", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x18f6511A67E14f02B95939A767A384423e66f43C": { + "index": 103, + "amount": "0x02", + "proof": [ + "0x658c056571a8baeed58b20397da4a120a2962121a451cf39d0b172343b58af43", + "0x9d3379dd89b837e80d954d49a78363365ad7ca622608809cb18a5a2d20375148", + "0xcea7df5853c7450e538101f09c77eec6b3f2998d90e30a8070f1e3c1de4cd6b0", + "0xd2ab54f5e70cde7ed6caa9591ebf0def0ee5d532bfbf38a4473c6ff488c1d82b", + "0xfe7d73c06bd76d1271e4b772b51e13505a812b7c919129debfd7d15fb5014d16", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1911e1bdC5a73a19E2cC1dA5Cb879f4a7e1c1C53": { + "index": 104, + "amount": "0x01", + "proof": [ + "0x2108011b385919d0b3a234d2767addec7e0c6c3c26253c4422efd72bc54cb11a", + "0x68ac79e6b0038449e7c6171e1abee8619718fbea94c1605fdca3ccaf599aa090", + "0x65c9c0c546d81a46cba9c8cb702c77ff47deec1dcd6f975abb3e5cfe8dafb0b0", + "0xc59577d42e813ea179264892414f1c8c6f09486aba6c8a1a1cfecbf6d1e7784d", + "0x6665ebe68e892e4e5135c09f9cdc379628aaa60a8ff322ed2ba75fab3b3a9cc0", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1918C175bBB4bb33E64E514350b22c8F3f7A5562": { + "index": 105, + "amount": "0x01", + "proof": [ + "0xfc5fe2fe56e5e67af13976cd8fbe5c530e1d41edb28e990c6c0add087414b94b", + "0x53f2003067f80e2b869e2ccb7123e5d153eeaeb600680ee6aaaa39ae2590b1b2", + "0x31f79c83b956e018904202cf4279226136341311c37e609a94eae5d4c39d8942", + "0xf7b15c813ccb2cfda0fad7314544180ed758b3ac0213d482dfeb48697c2a487a", + "0x938890418edfff03e5d8f0abce65769ab79b16db349d2869a477500717305360", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x194D5c4F2508bc8A2F4DDeFFD50d2b81D3749B88": { + "index": 106, + "amount": "0x02", + "proof": [ + "0x42c7bf82efd31f6eadf36386228edbc29c67ab1d18e39040223bccf20676f120", + "0x44f14a9ea34df8ddeb937fe125979d0f35427540b78c88e5637c509e4fdc63ec", + "0xa734a0bd47ea59109ab668778330ff5bec3b192c7fc158c8d946591e657bcae3", + "0x9e0106695419683e28012ebdf11113a020b4f76869c1e66a51206a84371b717f", + "0x38d4a740f3f99a827703ce6725923277f058619e98435b28078dc5b994e00a6a", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x19dfdc194Bb5CF599af78B1967dbb3783c590720": { + "index": 107, + "amount": "0x01", + "proof": [ + "0x76c32c2d5fff8834252f7f17c6350aedf9eb2d8408f5823d43bf99ea3de637e2", + "0x3d3331ec5b67cdd4c6e2cd551562b58a9285b063ecb4e34e5dae2c0eae067911", + "0x2f8ed4a6263c91d2dc6b5dbb2c00b52290fc594ce1c465e4bf2c33913536fd62", + "0x2542d5bed1352bb1dd1986da7e22c1f92c0eb7a7dead185e5100d7004e8e054c", + "0xb78cb1aa869958030ce4a14b5fff6309166225c83e0cdd2b91deb7b1639f67c4", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1C4e90fC8bdAdE442aeD58f8011db5A17A2E7199": { + "index": 108, + "amount": "0x04", + "proof": [ + "0xf426f86207815a34504ca5240ceaaedb8fbccdf126377648ad874954917fab0b", + "0xa5aa986edf9ff9a2895bf6dcdefd8f187b7ff65cedbd679dd4c79a609f408a03", + "0x9dbf8a188dd35869d18593fd709b3e786185f077d3f4c9439919ce6a3d6d5731", + "0x7caec6cdfba66dc7947ce7a10af67bf36737d573f70c5bcf73b71057ac86d1f9", + "0xed5c942adbfa1d9538c55e89e4a7ff4276f908ac558913b5f43dce424bab8e0a", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1C7c7b93F7D17a0FaaBfe6f99557C89493CcB9e4": { + "index": 109, + "amount": "0x01", + "proof": [ + "0x2adfb66954f0ee50f0c33b4db3a44d7530569b6bc9d625ceaba7466b8daa7685", + "0xed67150d4f25c766c8ef79515226a6142e6c2e84ccd39078ebf7263afa3315a0", + "0xf55ee0666a9187169654a25df74d4fda1a91ed9900daa14c5b2ca79408f70443", + "0x36710d40c48dd22c4c23311fe2998a569fb56756df4d8eda7bf12408489aed56", + "0xa43a1be4a3c4bbd4e28425f3172d3522b7e954d7cf0fc72a26d8ba7bea25f197", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1DC6e179B0aEc8a3Eb50027B871eF3473702bc2c": { + "index": 110, + "amount": "0x01", + "proof": [ + "0x020f0a8009bcceaca204e7a6244e304f31b694261f400279c63557dcdb6b9cfa", + "0xef8ed33b0380fa88ed37d439e93900b61eae6b8144c8ba1df2804352ef4dc1b8", + "0xa4fdfb9e13a8933dacaef17334dedd3721c4ff7bf3930be481e987c2b288d052", + "0x694db95f2efeaf59bc0b92d1736ca407eeca00ef7ad545f2c27ec99a059b74f0", + "0x9be1155992502d2b75a54fc5b2a41d663a86f7d329faea1befa0e24965b01a56", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1E1f3FF05B930131C4Dba2747114eb00E9a98B6f": { + "index": 111, + "amount": "0x01", + "proof": [ + "0xa33506897b2f5161bc7c38e70e514d82ae6df30154fd0708cfa6eedc105a1b8a", + "0x8f5bdb70827d32e1f57277667d8bd468cef83b4346aef4c06a3cd64f17138271", + "0x2951c6889bb57f842bbebd143d63e6a3223010b180cb5d4a43421a7db1a043b3", + "0x9d1cf6e9f51d85a77dd4eec2524ba22941ec238f140f4f63c1712d78c1e4c21f", + "0xdf701aa8bdb3ffefff1b359214087cc585fa0a0d40716a6635a8d2db4380dba1", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1E39385A820bfd932850df721B1Db373F47C7D22": { + "index": 112, + "amount": "0x01", + "proof": [ + "0x784abccb4aaaf69823721ebedde5f83c53ff783b5e5fa8c9de08ed2302e70ea1", + "0xc56e50468ed682ed17d28a29702296cc0dd88a20be097a35cb3699a31f3c3da6", + "0xd7a87e22dbf70420c67f3bd2ebe0a7a93c439db322f5dd2ad84c54df717933da", + "0x08cb8a426c97a85d30cf9308f5228aadeeb1f2c3f1f22bb2fd0d6c1a680a3ff0", + "0x80cf615f05f15e9ed665dd7df5d086fcb70ed5a5086e02db7c08752fcaab6507", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1E8cBBBfB827785ecC23dd0426A8907c7CDCcA3a": { + "index": 113, + "amount": "0x01", + "proof": [ + "0x1d412ace8e83e450fdad41ebcddd3039fee60df121586997d300e62cafc22f14", + "0x4afa0526d5b86d02950ac3088537313121d6f732cd0356d523df486f3818c955", + "0x1cdba9e91cea35b2840b706aed8319a24d18d06c2d7b29d63283aa5645e5a6cd", + "0xaaf60b5ecf22563f090c456c87a77833a8ecad31ad25f79ce590acdcb7f64b01", + "0x8e0cc5c13324dce3ab0f042d31a9db04afe0918f70e3f4515f43739791621c97", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1F427A6FCdb95A7393C58552093e10A932890FA8": { + "index": 114, + "amount": "0x01", + "proof": [ + "0xa101d9c20e268b185587b41d8f2759c77dc3d2fbb15244325ef7fe9fbbedb613", + "0x44020fd8a7c304ad693560f6aea9ac3cc1e6a6facca72a199857cfe68f190057", + "0xed1fedc58d0a592f61e92d2a8ab04ba2c92cccb2e77a5caf9f83f2e4f14db538", + "0x4fa24b2d1635e25dea497fe90d30db11d577f752b726d47caf1b4952bdf93c96", + "0xc36c52715656389b2693c145860adf3b1f3d4d24a139850b1fa5f2236456376e", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1F9C822097a6eDe8dEF937356863E37A18b97278": { + "index": 115, + "amount": "0x01", + "proof": [ + "0x5a99ba70caccde5feccd07de5326656b907ff3f5963e0afc8472337ec3c0f5b6", + "0x8feb836e6c91b900a2062e734ffe8864facfd489dd9a0d44c74a253b694a33a2", + "0x44e62419e6617508f01090bc15bf772f46d113e070bd339089cafb8752c6c104", + "0x31f1720e10e01b0c3f193ea7a34f44234d915ebd6c8260e1b72970bca0201b09", + "0x140105e3fa17ce783a651f2281967c53a37a748c29442efd53ee24d8a1cff6f5", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1a747eF9f07F0995fF2b62A680D91C3c64E8bc33": { + "index": 116, + "amount": "0x01", + "proof": [ + "0xe43123a99f3363a47eecd5c0da0479309615039bcdf93d245ef1353951fc086a", + "0x063478ee6e1ea794961e75204a82ec09aeae4d6e0001d581729cb36326dfcb9a", + "0x6cfbef2c974896a0631830fdf28466959c8202a21abfd2bb81bcaf67782572e1", + "0x372cbc91aed35f80f87f2c13bba747106e9ece94f8d166e828a5c70b321c5528", + "0x7968b2383e3b914ab3a36580b205f1449b51563630c77871f712e94743e3bf39", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1a8bFa2EB577BB8e81e55DCAdeE74205ff9a963E": { + "index": 117, + "amount": "0x01", + "proof": [ + "0xbbe5ed4df333688944f636bd0bce279b69fa2963c77981f9883542c7050c6320", + "0x9142e314087f2b195a4182069198042cbac7dd8dbdda2ef722a7c3ba50b5bd20", + "0x2be23c7221abc4f749899eaf8c4fed2a3ac3684b891e4cb0133f0be9d8b49ff7", + "0xdb334b0b3ac11eef22a51af7bc46c7a633665d404c70629bf6c429ed0b8d1ae6", + "0xcf36a9c08620752945fec2c3138a9b0eaede19862d6c5cb3c0489e6ab3a443d3", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1ac072E10Fb7a037cA4d81b0f063D93cA3cA6635": { + "index": 118, + "amount": "0x01", + "proof": [ + "0x1e749143b85a91dcb5f68fc5caf8ea8bf1a8343dbee5e09a2901aa8cf8a5584e", + "0x066beb648ebcc20fe8d63bd05cdfa8df8d8ebd93cd52c658d5318197ec394383", + "0x02c2372e8c71ba8e5b843247d27450214c544f74b4dd4d34e7ba17d64e09a617", + "0xaaf60b5ecf22563f090c456c87a77833a8ecad31ad25f79ce590acdcb7f64b01", + "0x8e0cc5c13324dce3ab0f042d31a9db04afe0918f70e3f4515f43739791621c97", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1b7c31284CC315E404E75d00Aecb785EE461539E": { + "index": 119, + "amount": "0x01", + "proof": [ + "0x7e08d7b014bbde2c0861b11a2c48c8b5933984b943bdae8bc3070a5f868f8175", + "0x7daa5dcf777e5abc497439e1fe5fdbf5d0f62c34b703ba211dd93f26d976d8b9", + "0x56bf94bfd25613c3b1c53d93baba2a4d76e076069333668d5ba3da9f1f69ce30", + "0xc7b7942da27652b608d4a505a59fef704f26c49f0c2a23709d80122b3afab5bb", + "0xe2050f6c95c616c1cfdb04f4b6d0afb5afa0fb464f767c38aba0f07df915a97f", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1bf7F23930b60AFc0A0F85D77bf9Cd8eafc2325d": { + "index": 120, + "amount": "0x01", + "proof": [ + "0xc8435e7617999e0f0ec7eaff41447d1ace7d7d1408223832a23e8501fbf83993", + "0x9425350b8131cfa1673b6fe8d04f90ffdcff25e015e4c94fa7ceafbadcbd6626", + "0x040429b9a444021a6ff7e6c6ecf5b7ad469b7bc2acfbfd2738ff037f2995c0d2", + "0x036edc84651a6e437d2aeddbd5e5d10d4911716f37c92c584d637f9f9ebb0dec", + "0x97fbe90108c9d6db20d511e4419e4ed044f589ef1f2a9f6539187bad21502f90", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1c3354d276b49fE8941a09b822a9100d50E88727": { + "index": 121, + "amount": "0x01", + "proof": [ + "0x77f322b8f7b94bcd8a8f4cf2acfb5c1e8992200ec3583f4abfa758ed44bee4b3", + "0xe9f35cf8f7a3d9836b30732828b7c2b20e233b2ca7f8ed6eb135552f1fd98685", + "0xd7a87e22dbf70420c67f3bd2ebe0a7a93c439db322f5dd2ad84c54df717933da", + "0x08cb8a426c97a85d30cf9308f5228aadeeb1f2c3f1f22bb2fd0d6c1a680a3ff0", + "0x80cf615f05f15e9ed665dd7df5d086fcb70ed5a5086e02db7c08752fcaab6507", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1cC6335f6dD86733fA316F6569690e338f43b527": { + "index": 122, + "amount": "0x01", + "proof": [ + "0xbdc9a8181954431d331b37e9a8c5d8d0f1f485644491884fd1f1003d1c20cc6c", + "0xba774ee7cfb4eb415c01e38c1f3f8b4d2bb5ccc4208962e2eb17dc2c23d27b45", + "0xb47c664b127e95ef186434a19e51e8c91952a09c8b6513f4afcf82c63bcec3b2", + "0x3886e44b7873439ef0a83b4119fca7dc640ee0f9551983449d038a076169bb1d", + "0xcf36a9c08620752945fec2c3138a9b0eaede19862d6c5cb3c0489e6ab3a443d3", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1cC972Ff969689873f8010bDD0Cf3dC30618397E": { + "index": 123, + "amount": "0x01", + "proof": [ + "0xbf46cce775df074d4ef5c06fd67b97f3072f36a5afdecc25acf78005110bb279", + "0xe37f7ef1706d6313d311cf1a70d91279eebcf121dd8d8a73dda9577ed484e35f", + "0xb8ba31195c91c8c313866172aa3210fabaf1ae5dc11c67181101d637d0e73050", + "0xde546e8389f64cf158f6546ecf18f3c473b0c5660810c1eba849db699f2c4883", + "0xbd7abdce9ec414fe47ea73146a2131622bdacb914ea6353abee1b0a149275092", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1cF0912A7087c6b2E496414fEC70832902b14f4F": { + "index": 124, + "amount": "0x01", + "proof": [ + "0xe54693c9a4c20aaa4634b270580d59a279ac529adecdbfb43afaeffcbe466d20", + "0x6809097d611115209e736cb5e30ef2f12f4e3424b70eca20ca114de2157c7ecf", + "0x8cfcd40e91f96163b5cf64d309e176e363224f3a7be5b7057c9ec3c6a7181408", + "0x372cbc91aed35f80f87f2c13bba747106e9ece94f8d166e828a5c70b321c5528", + "0x7968b2383e3b914ab3a36580b205f1449b51563630c77871f712e94743e3bf39", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1cabb60dE76aB8792d60Af36b06De0C006B09053": { + "index": 125, + "amount": "0x01", + "proof": [ + "0x093a7dace5cc35f5b3fee8ef23502e06282c6647b9fb469c8e15d8618ea23726", + "0x93e8f1b4da2ff8813f1b7c4b7dc1db73658754aa215c41ad9aab5d982079c1e3", + "0x4c45a6beb436ef04cc6902dca8ec98a6004150388bd0a3f1f3e1e8d205a1e2a1", + "0xc50cae5631fa8cafae8224329322dbaebc117b278a8e07f29104d255198d88a8", + "0x4a36dc66177a8394f6b14fc9adbe4ad7e0cc2dead6acb72d80990e336fef8d45", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1da75Fb0DA32653Fdab9DdecDb42F2ed61F8A28b": { + "index": 126, + "amount": "0x0a", + "proof": [ + "0x6cfa10f6d6961be4dde5d6b81a8764fdd27da5dc947f6af660640ab17bf1db08", + "0x5c36666e9d0093e7f3a0fd67531c35f22dcce83b8026a1e796f2509c2f5bec64", + "0x6739f7ef27695db5e41ccb568aa848d003419a94df0c5b9293106f211d362171", + "0x7c0de9d8e837704a5bbfc4993fa9b20e3f698f1b885a0b593d018e35bb790c61", + "0x1be60ce906d0d73954b2e1f2747ea1c9a23db0ad9345fa6801c551f1a39fa5ab", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1dd534D76b0EF9eE852ab53bB81eb5869Df7f788": { + "index": 127, + "amount": "0x01", + "proof": [ + "0x61bb4015b53eb91290c5af8f37d291c3c3237a589ad818c457d2986b227bf41f", + "0xc758d1936aeec3a77dcd8bbc4d50ab72cd803b158d31ad53a0686a69d7e06280", + "0xc7139805f0a4080488e635a7b81ed8c230c27ff6fa0f383174e4da67d2bc4f72", + "0x22784474cee51afee6127b1f3fb642ff75cdb40aeb505017bf6b1a1162a44c35", + "0xfe7d73c06bd76d1271e4b772b51e13505a812b7c919129debfd7d15fb5014d16", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x1fb858e4e40A07d0AAF4B5650c589E527A8582Bb": { + "index": 128, + "amount": "0x01", + "proof": [ + "0x0d9b9f8f48b576d668b9d36c7459a4e39e4dc3601fa650580078983fb8372948", + "0x34b76b90fde9e801828eaecf666db2619ed6ad0026e5af3e73f341f2f30365f3", + "0xcef2c8add76582c68d291ef22132fc17c35fa5b70f010e8c9388f4a93bba288f", + "0x037fa491e4b6fc74b9dccf3175d28aed9f5dacdb75dd0fc8e1154a0704619620", + "0x4bab2069d20a5d1d2f5ebdb61803a57609b7709eca9e925e31a7d14434af1326", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2000434e4af84b37C7B7B03B4De039DD1126599c": { + "index": 129, + "amount": "0x01", + "proof": [ + "0x3d00fcca9ac3834d2b3065fdc49433f7495cb4c5afd28e2fbe61787ba9c5b301", + "0xf2e2596a98448a420300c05555c61aacf9521b67dfb99418a9af35770c4586e7", + "0x7cad92e269fd399bb88a0e39909864292b3fbcd2d596ee1b941883a15cbe467e", + "0xaf86f597317f3202fff25068896658613bc0cbf9d7a66fd51e55c97f2358b8ee", + "0xb5bb98883f5ea232108866e1400cd4067f34fc2d70605fd2c67051a6095af7f8", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x201b5Abfd44A8F9b75F0fE1BaE74CDaC7675E54B": { + "index": 130, + "amount": "0x01", + "proof": [ + "0x06dd5de1b5efb15107899ee63567ff0a0eab06de907ca28e190fc66280a3284b", + "0x75aa020467f6536d0ea4c816be2e487e0d0c27fac89765efb6462ce21c1341b4", + "0xaa1e85f59373f7e7d78afd5cbb2e4e9873713a471b7ed5f4fc18db819e0c2cc1", + "0x16c0b121292408782518c2e86352704bdaa5fb42c434089ea6fc2adde27ce492", + "0x6e752d8572dc933bdf463f24751c7070d8aa74bb8987a5fe56dee3b0c9f53450", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2028579c7DddA2Af393904A9dedc5a42cac438Bc": { + "index": 131, + "amount": "0x01", + "proof": [ + "0x749f47f96369bd7c15c0efcff65c42e8879abd2bb5a5153b3d48257b188d51b1", + "0x2798fba9a260f6fb124666e8af7abfce9309b5dfdd278c348026c5673976ad32", + "0x1b96dde5d525085e1803041fc699ac898e6dfc685d023f0edffb1520d8a514bf", + "0x396e47c3a850c873832c034b62c0031de9378efa99594428607ab8c6bc01e27f", + "0xb78cb1aa869958030ce4a14b5fff6309166225c83e0cdd2b91deb7b1639f67c4", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x20675ff0C353e37E502906F7aCcC639dd8b51e8D": { + "index": 132, + "amount": "0x01", + "proof": [ + "0x8740ea322864ba5509c22f87ed57b4266b3eb4fef6d9e70686a0270b4018ae90", + "0xbdce07efc4858fce7924d176e8f3e73c3ee1f7cbc2ee9b5b1c47517dc76172f0", + "0x6bd30df1554552e0e9b030df3da576a8a2771bdb0e518021ef2f17fad6b2fe6a", + "0xdb5507911490bc1574fb624fe6bd570cc6afcd947118f0c9c38fe90a00ee8b29", + "0x9dda7d74fd49fdacbeb3afcd37c878516159fe4b594e491ff7ecbc80fd8d6808", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2067BEd542762D26E2755Ce7d8776728F3429f48": { + "index": 133, + "amount": "0x01", + "proof": [ + "0xfc470c185bbdfbf6f62d77c4518721b24d52554d59c1ea4721aae435d9f9b339", + "0xbb9aa2b40da00d58de10b82a81634ab95eb772f61293757de863a2d000c4fb18", + "0xa2bfc6b37e4189ddb762b679e4a5c9ece35447f0664935e074375ef5ac0ce2fd", + "0xa151a98046c68dc4de0dd4ca59fe7fff4ba692aa78310b499e772f0cf61a08d0", + "0x938890418edfff03e5d8f0abce65769ab79b16db349d2869a477500717305360", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x20F9E5a17b00350F1EAF9Ad18Bc5be0D54c0bc3F": { + "index": 134, + "amount": "0x01", + "proof": [ + "0x741d9964045f161c6dbc4f95cbc118fd903b4b9d22728a31efe657d1fa899bbe", + "0xf51b13bed964f4212984b491cf6c9c2bed75982fba859045e82e5ca612731115", + "0x36984f6b1b4a1a6d888f3fa91ccc133c7a4f0e096be3777975d3fde4090b511f", + "0x396e47c3a850c873832c034b62c0031de9378efa99594428607ab8c6bc01e27f", + "0xb78cb1aa869958030ce4a14b5fff6309166225c83e0cdd2b91deb7b1639f67c4", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x20a2A2CEF429D996C769a8dD5890Bb2b2FA30CfD": { + "index": 135, + "amount": "0x01", + "proof": [ + "0x9ca3b4279ff1cd39a3ecdb04a40e129f10a638cc53f13888f0a057a35145b000", + "0xca2821d5beb92f9642873e9ceb82d506320dad5ce984017d4118a116296817fa", + "0x0a6684890164794e3e646f48f9ca38abf68b10540785b90fb3834ade1e101d27", + "0x4e1a6e4b411d6f4beeb3ab0567980aee8895068f33d0f7cf833e4bc4887a1b83", + "0x0b385e4882f89784f506afafe6dd217c6ad9d142ccf58713e27961d25b2c6d0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x20aD2C30e30DD94b022aB98E8d445d0089f89540": { + "index": 136, + "amount": "0x01", + "proof": [ + "0xa7992ddccb8069f002d506efd6b57ac60de5b66516fc275fcfe0cb77561b8906", + "0xd56b555d818336cea18dcae1ff76d8d64f7a213bb9bc6e31fbf1d927baf3298f", + "0x31fc7a90e64fedd0c716849f9c3d85d7bb0f0af21a85776a85104ce4712fea76", + "0x21367d58d52b32234887e9e91e468488a647d2d7407cacfa709cd59618255499", + "0x59d5a4275936eb4dfca0d17bab02b4a25bd4dc43ef3aa0e3515a07f7c0f68a93", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x20cC956A257C658D7f86873cf31B68dD6A16FA74": { + "index": 137, + "amount": "0x05", + "proof": [ + "0xd9685a5238895f719ea6dac94fcb13d59726ba3b2e8a3c4d00561a82acfcf993", + "0xb17f19e1ae2c0f1932e2ddd1cc42dab762ad9ba67bbb7221e37f7d8471e5dc14", + "0x9dffadac20c132cf7ca3085a1eadd324aefc93eb96b7e6507e8e3ff06ba89160", + "0x539804c7bf7a9b6235d14df5f64369e5a3ba52daf4ce320d3134eb569c42ebaa", + "0x57a1600e1002b648fc38956dc1d2f34be5ee3f6cf170c73bd27c43b2a01e45db", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x21501E2E89921f468936af455D3CC8b3094A1B6F": { + "index": 138, + "amount": "0x01", + "proof": [ + "0xfd32568563b7ad45d604afcbfad6ed664ba6df4fb8d2d223b423310010952fb7", + "0x7be7868b8dc3c4702434fb982f4d3c5fde1d840d056ba6f423e837874ed4383f", + "0xa7b1364c89574d145647fe0631d469a646bcc060519ae25e959ecafa4f17d9bd", + "0xf7b15c813ccb2cfda0fad7314544180ed758b3ac0213d482dfeb48697c2a487a", + "0x938890418edfff03e5d8f0abce65769ab79b16db349d2869a477500717305360", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x21639A426a07498C4e7157BA909f92dA2D57cE87": { + "index": 139, + "amount": "0x01", + "proof": [ + "0xdcf2e09fad23cbfc4ef571c24e1fc3de02391673340db52054db8bc408e9efcc", + "0x685efb9d9308bf73ff6181b7306e16598ef4e74948e5e691e458154b8d8d382f", + "0x0e3f11231eabc58db4785530d98a166f67094f59b7d8140612cd5b4356e4db3d", + "0xc84beec6531767197744c2106caed4823936b1ceed7475952444acf832b57446", + "0xd8ba0ec6899e7ab5afd6774d7465b2ebc52e677b805f74deb131b1b243bae70a", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2171A99F482FF6048aC59f7D01891F603aa5F370": { + "index": 140, + "amount": "0x02", + "proof": [ + "0x9532a11dc7e105f39eb0858e437bff0eeeb855be7b512dcf0c511591aad6c6cd", + "0xf189869ed4cc615f4b5c374a77c9dec40714e9965dfbb0caa2919e5e69fb8389", + "0x1e8f6edc1f9dfa901b23584d944d29352277c21bd90680f8bd4cc7247d86dd9b", + "0xb27289c273000ad0db5ed9acba0b01be05f672a2f40d51317a96231114834c95", + "0x62ba7b58fd554e8be295bf9d4baf9eefd0b518ead5cb8bab321717a08160ae0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x228c1334fc57Eb6E02EcC448E749a041124321c1": { + "index": 141, + "amount": "0x11", + "proof": [ + "0xfc8e78c05ae20576590491596e7061c87a905194ab036f1edc5e15b0478d16da", + "0xf1e7edb9c90e910978cd903f50046aa421aa45ef67439f8d70c7caabcee849f6", + "0x31f79c83b956e018904202cf4279226136341311c37e609a94eae5d4c39d8942", + "0xf7b15c813ccb2cfda0fad7314544180ed758b3ac0213d482dfeb48697c2a487a", + "0x938890418edfff03e5d8f0abce65769ab79b16db349d2869a477500717305360", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x22e3f2C7b800F04227FD01075618725C211E2F4D": { + "index": 142, + "amount": "0x01", + "proof": [ + "0x97cfc873c8ccf7fa158b1b34c4c7f2f324eb7e3c7b6815c7bddf98cf0b20f081", + "0xd9a4f82d0ecb4a87e98eccc2fe9603a032e2174c62c7237f3c0dec6622d24ec5", + "0xb575a968000894924ae64573326e1018adeabbc274265be52c946debcdd4eeed", + "0xb27289c273000ad0db5ed9acba0b01be05f672a2f40d51317a96231114834c95", + "0x62ba7b58fd554e8be295bf9d4baf9eefd0b518ead5cb8bab321717a08160ae0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x241d4cBF51c08a1F1Ad6b4D091F96C75A6e98C5d": { + "index": 143, + "amount": "0x01", + "proof": [ + "0x93b7602d67b89e0869d2ca232c3cc2fdcf2d299d36d4ab616184bac88718f71e", + "0x0cf3571f41808535d0f25037fe2644ce6e90e556619b94ba28f805f35191b1fd", + "0x75bfc221d8f7e7fad04c48ba5ad53c5e62ff5db03c3799cd4e3b45e76de5d2c9", + "0x6ebf988ef586adc2237357c1611e0a6bf7170af1257d42fb6ef98df1f5052439", + "0xea7c0076ebef0c429d544548828ff19d5600136801cc28845bdfa9990d97a058", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2481Fef92F6358A410f4B42a7672f23CaC514c2A": { + "index": 144, + "amount": "0x01", + "proof": [ + "0x6a0d1b70656128872303aeeaff075c0934c4ba46e58e11b75cbaca1c570bbc6f", + "0xfe1ecd3f8cc7a1a01aecda4933fef22f9aa17eff1ae0adc7a02019bbfef8d000", + "0x1390b60f90b43662c35607eef4b6d21963963777720b34f19533e009d75b03e4", + "0x283f6032b7beb32fcc6ac4b21c9941360bce453787f78b6251c38e3890b83a8f", + "0x1be60ce906d0d73954b2e1f2747ea1c9a23db0ad9345fa6801c551f1a39fa5ab", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2530CA07Bd3d5dc07B73B54b19152cA02Da84aB3": { + "index": 145, + "amount": "0x01", + "proof": [ + "0x21fe8697f638f2f9f07f9ce0ded816182be9ec70d3d5718e0576f64061ccb524", + "0xa640b527974b8ab9419d85004f68d1bc23dbec6fdc16c4db2198d649c05481b7", + "0x65c9c0c546d81a46cba9c8cb702c77ff47deec1dcd6f975abb3e5cfe8dafb0b0", + "0xc59577d42e813ea179264892414f1c8c6f09486aba6c8a1a1cfecbf6d1e7784d", + "0x6665ebe68e892e4e5135c09f9cdc379628aaa60a8ff322ed2ba75fab3b3a9cc0", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x258Ac32aD0B0806c9eCc9d2CC58DD7f66314b2b5": { + "index": 146, + "amount": "0x04", + "proof": [ + "0x30594cd92b6f29de33680cf34ea83d81cac1c777f9400244162a71bc1db0ce4b", + "0x0bb680215febc2981a0324aebfd2aa9bec236997a200749e08ddbf283572c109", + "0x877e3afc33780706a52d195b5d99278bc7864ecda90d6ce301c78748b13247db", + "0x7fb8279a3bf6834ff5de6f30e4ebf74889d64cf70547e9c78a27d7fd86516478", + "0x4325701890e79e85b41231157c1ced07357ce871ed6fb4f233c2f82c38bcf4bb", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x25AEf0C0E3D0B6D099e8Eea6f368b82F654d548E": { + "index": 147, + "amount": "0x01", + "proof": [ + "0x5424d6e19c34f8c060d847147455495a301afdc16b5ab71a57eb0bd82a87d632", + "0xa1653af0002041626972a3030cbcfb735a6100f8a33d4a3ca3dd6d4720f5e27e", + "0xe13a3f7e9464f63c11cdf4d34aff17ba3b16eabe825f6978bf103f72f771ab75", + "0x7a5397945a42b48bf4e4ee9c21f985e9d9ccf82e57fdb87dc2e6046ed345d7ec", + "0x5477c93aa7e191fd8f76e1976387fc82460220dfdcee87f9ba8926f4e0ddf45c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x25C6fE5005d5cf4C7e665A9056B06856248E4f22": { + "index": 148, + "amount": "0x01", + "proof": [ + "0xbfb7149a4bd3c5c641d18a5ffa4ad190e33f1ed5282e5a4b0d9ae30a63f108d9", + "0x3422bb231d6de7355dee1651cad8e5f95296f28469acb86488dd38766b38c3bd", + "0x069a6e27761402124e6864e9c64d9cfd9c72eb95dfc4360c4741e8871195b5fd", + "0x56b8291821908612de8ad02adfee632a6221773b416cedb3db9fd4f3ba5d30ff", + "0xbd7abdce9ec414fe47ea73146a2131622bdacb914ea6353abee1b0a149275092", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x25cC5677C82453ea26642F7A3f733C6006c31011": { + "index": 149, + "amount": "0x01", + "proof": [ + "0x28eda7f087575bdc80b26143aa60701aed2a27c7ad7212366931feee0cbda03c", + "0x339aa5e81863bffd265f632d3fc1cf781d9d2bf685449f05ff59e00283b2dc6f", + "0xc62b818bd2a34acad67723e97f8667eec6de397168029a2670ec2681852c4b26", + "0x1ff461854683a34317216055e65b6637346912d1739163d25c1a0b0a5f15c25d", + "0xe29ba79106b7b14c14912bb5fba509f27997ddbe5a7ebc941fa75e3475af4aef", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x25fFF4689be582515Ac968CC85E9B6d56076a297": { + "index": 150, + "amount": "0x01", + "proof": [ + "0xa03c70cd65167f99b1bc63f37dfe75617504a3d2434e94f647784340caca6cb1", + "0x44020fd8a7c304ad693560f6aea9ac3cc1e6a6facca72a199857cfe68f190057", + "0xed1fedc58d0a592f61e92d2a8ab04ba2c92cccb2e77a5caf9f83f2e4f14db538", + "0x4fa24b2d1635e25dea497fe90d30db11d577f752b726d47caf1b4952bdf93c96", + "0xc36c52715656389b2693c145860adf3b1f3d4d24a139850b1fa5f2236456376e", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x260078A583b26a52A1052EFDD0C9DB8a8cDcC177": { + "index": 151, + "amount": "0x01", + "proof": [ + "0x4093fbe2568911d2f7cffaf26c21076a08118ba2ab4a6792e1421858fe26d093", + "0xe93564032181ca4661779509fcdd747ffcae63e6750202b2cc89bf0d59fc7902", + "0x6cb469a96723651e405715162b9903adfe081b56ef3c5c27f903302a7ba044a3", + "0x3ae549d14256824a2b8db4d8292224eb9b3beda41a6712098d825d2a32cc6dcd", + "0x98ba92b6a1d3418a3c44b684c9f0dc2177f48d3a6b666334d112dacbb6f5acae", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x261cE4c4ED3bA4DC49CcE906B2A5f1666b2a8d67": { + "index": 152, + "amount": "0x01", + "proof": [ + "0x58ba09914cbd791d08678b4403ff6e5602deeb389ac19982c6d39aef2e139f13", + "0x76e86ff6ebe71556f8a31c670ca1f187e44babd68d51a629caf896709e37ba0e", + "0x136170c6f928bfc56e43011f019f3a590b74ac414acde4927d918d53fd5e8ef8", + "0x5190cb032ba95080f88929faf2eabe8bd342a53206176fd2c3afcbef4577ab71", + "0xf9f105f90db6fe2970fb4e03b35654f9b69375879c783d3f1700e04b2e2f925b", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x264571c538137922c6e8aF4927C3D3F681399E50": { + "index": 153, + "amount": "0x04", + "proof": [ + "0xc8da00b54b8a1d6081e5ca9d1fa5aa6c937e3c92f802cc301606566830a73530", + "0x1e392297b0fc9beb554c93adde9a167b28fe120c9a33cac33de0afeecf14d5dd", + "0x906c494d7d3c4c5f521930d1042cfae9154fc6b37e57ecec673d01e269ef7429", + "0x1f4f9d2e01bb8c804693d53134cf046798ee2607f0aa015ff42b474e23cf7ed2", + "0x97fbe90108c9d6db20d511e4419e4ed044f589ef1f2a9f6539187bad21502f90", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x268993C1923Cf4d6db408f5109A53FCf17ed4039": { + "index": 154, + "amount": "0x01", + "proof": [ + "0x35615dec1547c9b28ca1b6fe6bd5bc55d198e44529291038c8dedd9588f363d0", + "0x6b40523ff477c4390138063430fea98fa0ba7f09d4db26469dc279d084fe0ed0", + "0x82aad805335c91e7011dd8396f6c0293becb55858091bc89dd18a07093b2dd7b", + "0xedd365a7e73c5a47a076899344b760df86cdab5eb6566dcce5b550be9bbb5324", + "0x963cc7ad3f8f0ded379d05906b629df8cc616633784013c90731955d0b0736d8", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x27368Fe5F2ED172CDDbB1E70219a7D2C0c3fA970": { + "index": 155, + "amount": "0x01", + "proof": [ + "0x9df0106d199f761861e1e4c8ebfe6fe1d7962ff93678973394baa0e6f9f45848", + "0x3ce8e30840ba8c220899d7f89b36dff5f18103945b33bf9d748d5e7c8d40150d", + "0x8b2d67a4a9f2f8b679f7d72eda0998f5c76a314b4711b6f34f4158126ea31f89", + "0x2710311af5d5c72181aeccf7f1e36c3065b1ac40ab236128e22d5cefe5ca9032", + "0x0b385e4882f89784f506afafe6dd217c6ad9d142ccf58713e27961d25b2c6d0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2771cc14865Ca8AaA32E99a30A40C6632c1888a0": { + "index": 156, + "amount": "0x01", + "proof": [ + "0x61248f460d67e5174e8018536bff2dfe0da5a942e574ae82b3fe63d4a2e07333", + "0xf4f866a6450895e5ec47b30e6f17f2371a56c903366767677bba74b6933d86f0", + "0x11c7f0494b8c0020c72e25c40dc03744caf95a5fada2bb6b4c5a083bb072f5f1", + "0xd1cbda0650121cdf56f6e9fac417e3ddbcea9364da64e4e29c3e50fa61aa56bf", + "0xdfdb156cb5d2b90a5253163570fe08739b17ab3fc383c79eb041c1d1a667fe84", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x277c74f45724945b2066F305fcb5a609312390E2": { + "index": 157, + "amount": "0x02", + "proof": [ + "0xf78cd95e3dd8e9d8b80973a0f7515dc7d8e3dbe32947633979d3fb38c1808c0a", + "0xa7bc4f20b49093786623053d8eb39b029e2c70f654bd48090c7b98c639e4a678", + "0x9bc46200f73af0c38de14df3f6eddf911056a5df16ad70b6582fcd96bb7e45d3", + "0x3aebe8d88cbaf4043e28b3d6aad9a1f79bda4dbadcd2f685785a58d155fbcc50", + "0x8e7f75ccc4d864471b1a7ec71efa29a4e8cc4761c26a6987c8043d9ca642a2a0", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x27c27151F9BC6330B767BAb8dCADa11A253ccb8c": { + "index": 158, + "amount": "0x01", + "proof": [ + "0xf8407aa9afbad5185376f9d27ae4e859fc4b8d2fa133071750bce47c0611d661", + "0x4a623cfbcfcbe221e8a159248d990832cafdc103aeba88ea631fb97edce82695", + "0x9bc46200f73af0c38de14df3f6eddf911056a5df16ad70b6582fcd96bb7e45d3", + "0x3aebe8d88cbaf4043e28b3d6aad9a1f79bda4dbadcd2f685785a58d155fbcc50", + "0x8e7f75ccc4d864471b1a7ec71efa29a4e8cc4761c26a6987c8043d9ca642a2a0", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x27f58415BF431a34790826335ed10F780DdDA7D3": { + "index": 159, + "amount": "0x01", + "proof": [ + "0xbc36174d217b77393b47f4f0434b373c219d8b3bc33ed06c52e3575b0f1fd4c7", + "0x2b5fc998bf7bdafdd979d9b2dc22d08155090c5a0c5eb6adf9054dad8bf1831d", + "0x2be23c7221abc4f749899eaf8c4fed2a3ac3684b891e4cb0133f0be9d8b49ff7", + "0xdb334b0b3ac11eef22a51af7bc46c7a633665d404c70629bf6c429ed0b8d1ae6", + "0xcf36a9c08620752945fec2c3138a9b0eaede19862d6c5cb3c0489e6ab3a443d3", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x280677A1F47484544c1f02764d667B46FC37E41a": { + "index": 160, + "amount": "0x01", + "proof": [ + "0x9d26fd60c1d21aa7e699908089e64136e44cd70f2d7a38c7151354c1e03f4aa5", + "0x9328b04a1f2ec75cab2cd704d50fee1066b62fdf28fa706f82acfd6fa3c135c8", + "0x8b2d67a4a9f2f8b679f7d72eda0998f5c76a314b4711b6f34f4158126ea31f89", + "0x2710311af5d5c72181aeccf7f1e36c3065b1ac40ab236128e22d5cefe5ca9032", + "0x0b385e4882f89784f506afafe6dd217c6ad9d142ccf58713e27961d25b2c6d0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x280dEd1b7e430BeD0Cbb0Aace452Fd2ADEf2b581": { + "index": 161, + "amount": "0x01", + "proof": [ + "0x53a72dae554c43ea2f63d1fc34383d990bb8b95f1aaf43f2e0f2b66c7e3792d9", + "0x7afac21ac2d930fcf47949be2e43e5cb949155599b2463700f8c686b2e91e23c", + "0xe13a3f7e9464f63c11cdf4d34aff17ba3b16eabe825f6978bf103f72f771ab75", + "0x7a5397945a42b48bf4e4ee9c21f985e9d9ccf82e57fdb87dc2e6046ed345d7ec", + "0x5477c93aa7e191fd8f76e1976387fc82460220dfdcee87f9ba8926f4e0ddf45c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x286060cD2e24E0bd0814a83e3621c4ed6D5e2466": { + "index": 162, + "amount": "0x02", + "proof": [ + "0x3d277efe96dd18ef8086b617a7e34f88ca7d7f751201c388abdd389c80cf7314", + "0xf2e2596a98448a420300c05555c61aacf9521b67dfb99418a9af35770c4586e7", + "0x7cad92e269fd399bb88a0e39909864292b3fbcd2d596ee1b941883a15cbe467e", + "0xaf86f597317f3202fff25068896658613bc0cbf9d7a66fd51e55c97f2358b8ee", + "0xb5bb98883f5ea232108866e1400cd4067f34fc2d70605fd2c67051a6095af7f8", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2868A996089EBEe1Ed1D9E56a373398A907c2dA3": { + "index": 163, + "amount": "0x01", + "proof": [ + "0x430a59a75924038d76cde6800af2b570f5967ca5e9d786d2f63381fabc9b4f8f", + "0x5c099c23f6c0f1edb9c7670c98c8e9ef3d3f6d289d5294a254f8ecd446c49e69", + "0x11143bf2cd84ebb9924b71d24ab1df210835583a66325b911ee5fca2778d0f13", + "0x9e0106695419683e28012ebdf11113a020b4f76869c1e66a51206a84371b717f", + "0x38d4a740f3f99a827703ce6725923277f058619e98435b28078dc5b994e00a6a", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x289922fBBfBd38472D7e2A1652B33b834f7c0E49": { + "index": 164, + "amount": "0x02", + "proof": [ + "0x1c06c342fe0b60976f4e73737bdf30558800f4f0e266adea1cdcb51adc9e2913", + "0x4dab60e00ecfbe3b5d05610c9f2bcf3c22925c724b3890c6e2b15ddb5e57cb2f", + "0x7eec595c69d6c1d1d1d8dacd93ff7c8b18c1968069bdea1797a90eeecc155ade", + "0xc2b85fb7fbdedfff6c0826f89cbeff5a93f827eeaec8b16d80424b138de956db", + "0x8e0cc5c13324dce3ab0f042d31a9db04afe0918f70e3f4515f43739791621c97", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x28AeE851E7b65A46b71DE302CFfEeB2c557847C6": { + "index": 165, + "amount": "0x1a", + "proof": [ + "0xb6ee0035e8fd9feb6f558209cbd7c0aa491065f675bc4231909645879cb1ab7d", + "0xec07ef0f0314b6d06604b4578ce01aa3d06ddfc4df44a188c5077de166dff521", + "0x2370bc3e49aeead81a8f59e3d80747fc9da94142f3be3098f2b9504a9dc4fd7b", + "0x841ca200e81dde455c9bb72802b7b377b46a9d6779eec08b07e61939b8d43c1b", + "0x529f1b48ab616d4dd60f663753a7779d8ec25952bc8c34df4aa96347bdb0d542", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x28C01B64F2492D82fd58FEECF8c71603c769BB4A": { + "index": 166, + "amount": "0x01", + "proof": [ + "0xab5736e6979d06307b0e35cb6313615e1f94ef0ce7f1bbd201148f5702ecee37", + "0x372462dbeb6f261d343ec5bb98bf18b9a0823c925379516bd354cc27fe1c8a5b", + "0x8d09decc88251c44f7a49a4b85d4449eb023b2742a6cd38b9c5de1b9936589c6", + "0xd7f4836e54488e91267fda42072073873c17b5d47a5a1cb5374c07d89c92ff21", + "0x32636a5315ca425c602832f925f24426ea5aec9939c73d1b2a6fcdace85ecae8", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x292b78a5AD6214971c0ec79Cb9d7eb3Cf20957Fb": { + "index": 167, + "amount": "0x01", + "proof": [ + "0x3664bf60d602869f4c5fb5dbbf050c3072e23bbc7eb22955f3e4fb45934aa96c", + "0x50188a232294bc0e5397947305d1c580ccd8c734563f462ddf7fb69e1e6baa4a", + "0xb4e3d624b4c9069a7dbee8548a7744c0c011fbd5381a1988549f867ddd3672a7", + "0xedd365a7e73c5a47a076899344b760df86cdab5eb6566dcce5b550be9bbb5324", + "0x963cc7ad3f8f0ded379d05906b629df8cc616633784013c90731955d0b0736d8", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x293e93abC12Bd925B31Fb33C2e84BD7127C3D513": { + "index": 168, + "amount": "0x01", + "proof": [ + "0xf9d70302bb07bbb72a7f9b96345d14fba1c758468c33c9f13eafd84690b3d9d2", + "0xc3873e2cb05808b5b81ee973cf8875e2cb2da21687773e7ab16918643a1e9a43", + "0x3708d8178885b9269e803b79a4e0463134629db473cf8c80861afeae7084931d", + "0xa151a98046c68dc4de0dd4ca59fe7fff4ba692aa78310b499e772f0cf61a08d0", + "0x938890418edfff03e5d8f0abce65769ab79b16db349d2869a477500717305360", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x2965b4b8226F2E5e9c790cabA9EE40bB2A3Ae411": { + "index": 169, + "amount": "0x01", + "proof": [ + "0x10b05729226895742944270e7e780ae289fc47e007ff6c6ce9a218751ddf788d", + "0xa5d3a666e6b30869d8f3e419c5cb5209ea59f83374b005af111715d233915de9", + "0x58fc0f95394c3d85af39af4ef41b7b5365fdab351fc36f9bff4ff8482e4ecce6", + "0x2eb27b26c39f3350831b9042b1a0e6295ae6da1b11f07f10b4a83da8dc66b536", + "0x4bab2069d20a5d1d2f5ebdb61803a57609b7709eca9e925e31a7d14434af1326", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2993E1D02b11377f44455AEdc618C705acbb0591": { + "index": 170, + "amount": "0x02", + "proof": [ + "0x8890857a964d426d94f4c89be65e65ada4a49b5cb5e9b6fb59e107bd96964cd4", + "0xcdbd23a21efcdb7333f3fe35459410b0d684d893849da5a8460e96b5c6be5b7a", + "0x33a345c594edaf8461f1610783c243a81449ec27186711a2d756f2e892ac478b", + "0x16f452fd982f0f4e3fe20a4b2fdefc9226e8d1db4c0b29793acf9535b6c65c66", + "0xe4fc54838dec16cd3ac94713f191dc41ac7f5e070180d4843c9aaaf9c71ce29f", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x29Cf6897873D264823570baf5fe79e0b918C2ebe": { + "index": 171, + "amount": "0x01", + "proof": [ + "0x1800cd870e5b59f98a0148b6f9dd0190c1bbe1236bb37d95b9e727b2e7b701ed", + "0x47a9f68dfcbca0c181297b013ef82d78dc1dfc0138770082411f36c1d724bbed", + "0xd5460b9cbd07eb643394af0ee8ffa7d20c13c474c42f8d3f770490047dfc42ec", + "0xd4e406b94f7009e26e52781d8bbbf71780c9ab5d8d7b9162b8469ca115683ffc", + "0x6431c24d3d46ea6b0d1959c0de03265dc474d3e67139f2bedca26b5aab0c0c5b", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x29FACEEc357d9747Fdc909908332007868cb0380": { + "index": 172, + "amount": "0x01", + "proof": [ + "0x2b1bf094538267b6f237131964ad223acf271c279961f8fde53f53c1c86fe375", + "0xc56bdd4b88359658a37d61f564798baf08875bcfccb501fe44bfd18164acadf4", + "0xf55ee0666a9187169654a25df74d4fda1a91ed9900daa14c5b2ca79408f70443", + "0x36710d40c48dd22c4c23311fe2998a569fb56756df4d8eda7bf12408489aed56", + "0xa43a1be4a3c4bbd4e28425f3172d3522b7e954d7cf0fc72a26d8ba7bea25f197", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x29aD1044141A957E16168E29a7c449A012AA0D5a": { + "index": 173, + "amount": "0x01", + "proof": [ + "0xfede354336f2fe0d36b0601bb4ce988d78bd00660d0e8db217df8eb8bdf505f0", + "0xc9b2f7dfd9fb48559029d5027b617be4c0d10fb84f122769eab605723bfb0c4e", + "0x228366240da7e1e50c9fbbf0d83ef3aee5be6b101fa2d9de2745bc568f3857bb", + "0xd234d050330272d515ab9d9de470961bb799874daa015afb8d313d5141c5e8eb", + "0xa0af5121b49fc7ea34ad1f4c8308fd6e51803abadb614d1f15f8c87bf9fe29bd", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x2D0e9e8197c541704EAd0AEB35Ef5F03dC35bC6D": { + "index": 174, + "amount": "0x01", + "proof": [ + "0xc1ecce93a6a2a8b22c6f1de1cf9ed163ec8a84692776981612a6514a4b8ddd0a", + "0xeb89f66c33f972131f05457d09c65012a4a07b743f98b336bcd8031dc6161b3f", + "0x71e3366d76c55a2318750b2a51d86a41babf197eaec484325789436df87b8918", + "0x56b8291821908612de8ad02adfee632a6221773b416cedb3db9fd4f3ba5d30ff", + "0xbd7abdce9ec414fe47ea73146a2131622bdacb914ea6353abee1b0a149275092", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2E15a9900Db9469aEA37807FC5b9413D2234E59c": { + "index": 175, + "amount": "0x01", + "proof": [ + "0x2c8f10540782dfacba18902068202f5ef562c982fe119d0d3a26d0c508e28038", + "0xab5b019169f5ab38f7196d7cd6c96fe89ca012f385ef7d24412c29193bb860fe", + "0x4463b6536e661f9a88a746064d45ba478e857effdf8bd2e7636f7fd61b93acaa", + "0x71674724de34865e988a846825d9f937ca48ef7322279591194ca7d40d8ee995", + "0xa43a1be4a3c4bbd4e28425f3172d3522b7e954d7cf0fc72a26d8ba7bea25f197", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2E45e558f76eb181176a61B6207e94DD77316aa2": { + "index": 176, + "amount": "0x01", + "proof": [ + "0x4f933d591345679a91187e2b3abd6d0f038b6ae46875d09d464aaf6c4aaed228", + "0xf0952fbd6b81dd2889aaf53103fcf949885e18dc3e92dbcaed57051d365fa9a1", + "0xe823abd564575edaba5671df2299c869d599b76d50814c956babb2392af273b8", + "0xde9fcf6a43c240e1d4c7ca780516b34aba68d02c35c5ad3090d1ba1aa8d40999", + "0xcc9986a7987738d81db64db86f583aed4fde214b766f55d0f15a876c8f790fb8", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2EEcBa66581512087181895b0dE8d5FaA3Db21e5": { + "index": 177, + "amount": "0x02", + "proof": [ + "0xa3e44650e184b262dacd7293e3c4de9b7cef3c38d30102daa467a99a7686671c", + "0xe610ec6f5d17c7c4632d467433a0265acd8a5474f9f6371826d0f2fb920f267a", + "0xe9c518193f61e187a919aad09e78c1cff35aa13804b131d81f50f7740479a903", + "0xc677cbee79568f65b4882bd20044555e2bddfb473bfa6749d1d07caa3dd6fd2b", + "0xdf701aa8bdb3ffefff1b359214087cc585fa0a0d40716a6635a8d2db4380dba1", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2Ea631BDa7f9Bb50b441C7d627f0a89D1fEe0Ebc": { + "index": 178, + "amount": "0x01", + "proof": [ + "0x73ffb7990983eed9cbe41606fad4368aba53852fcf05982264de2a93be0c5e88", + "0xd919d00f8f99817d7acb40512e59dfaa25e6d93bb8db81521771273bcaa8e359", + "0xd4cc5cd424ec4a17ab20cb4944d11cc81c6d34f1f8242f75b4f4111a721a2141", + "0x0dcce906ec5827bcb3dee3fc162b46bcd945486f9b95e6d9175120ea721c3e19", + "0x7abccb934a7f719fa80b9a5d3157e99d45ee17a391abf85d4f60839dbf3769cd", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2F9677016cB1e92e8F8a999c4541650C80C8637A": { + "index": 179, + "amount": "0x01", + "proof": [ + "0x81fdc9e51797bbd5c2475778fcf4225a15425bcaf2e9ed5c4564dcea2b54f4b3", + "0x6551e77778689e9477074f8f5acc7acf96e86b0b80626a3ed7a23f2d9b11d85b", + "0x37b7ec084798f5f5573cd70b4c713808bfabeec65ce54db1c9c6e87b7642d9e8", + "0x13c4723f9c83e02f8e5d7f08a17afc4776844c18a0189a9fcccd2702d623254a", + "0x891a74fec62a569bdbcb44171dedc1926c5cbe5d803c0c17ff419a861e9ee5b3", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2a0059610c92842DC2eF84aF76b244C28687e647": { + "index": 180, + "amount": "0x01", + "proof": [ + "0x8dda9ea3295a54d80fc918fff5e7172378afdaf8afb5503458a122d085074280", + "0x2ef90a79596d02d1b760abfd4fee820b144bef7c0323bac4c9d032212a6c2907", + "0xdf6cc73a467552881abcfe25d30eb0b4a6ee65fb03e1f816f4e39315a3ce78bf", + "0x7217bacc0b5fadfdc27aef27f3baae246ba909c02961594a63bb24f24958cc4c", + "0x8fbc13f50b0f82a781945a74ddd5c5abde0b4a8983852c66ecda77a68df50722", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2a51187822e5A148D9779b3bE007b09b7fc7a83e": { + "index": 181, + "amount": "0x01", + "proof": [ + "0x1ab751fd1d7115e26f2e3898440c4ce2806316ee1983f5d52c34c59e1748a848", + "0xe9608ec4e28b0a72b750e7a535f206af5c9b5a72e05dcbdbe3c4ac2f74f5fb94", + "0xfa32f82efe11ffd2403c559b1ec3e3004c40156be97edaa5050d9a8a56426e05", + "0x6b5b18bfb5c7b8de5b52219b51a21b6ff6e22d5cd7a147d521bbfac13cd7f7ac", + "0x93994074bdd819d668a79fc2c79be23cb074a679cd3fe03940945d4c6f9fa9b3", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2a6A8B9fA287Bbfa38c0159CD09E485a9C6D2A98": { + "index": 182, + "amount": "0x01", + "proof": [ + "0x787874d0a69d627b2265f81d1a48d5c52cee0b2eac3ad55148305896c317a003", + "0xc56e50468ed682ed17d28a29702296cc0dd88a20be097a35cb3699a31f3c3da6", + "0xd7a87e22dbf70420c67f3bd2ebe0a7a93c439db322f5dd2ad84c54df717933da", + "0x08cb8a426c97a85d30cf9308f5228aadeeb1f2c3f1f22bb2fd0d6c1a680a3ff0", + "0x80cf615f05f15e9ed665dd7df5d086fcb70ed5a5086e02db7c08752fcaab6507", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2a8600bBDAab254A2F8A8E00912799295C3DD601": { + "index": 183, + "amount": "0x0f", + "proof": [ + "0x60a8ea78e87d61ccc5344ce8fe85b7a5ace818dd3b8bfa19482ad7f9a52188af", + "0xf4f866a6450895e5ec47b30e6f17f2371a56c903366767677bba74b6933d86f0", + "0x11c7f0494b8c0020c72e25c40dc03744caf95a5fada2bb6b4c5a083bb072f5f1", + "0xd1cbda0650121cdf56f6e9fac417e3ddbcea9364da64e4e29c3e50fa61aa56bf", + "0xdfdb156cb5d2b90a5253163570fe08739b17ab3fc383c79eb041c1d1a667fe84", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2ab8afFBD2E90FD508200cDd6Ad6DC93Fe93fE91": { + "index": 184, + "amount": "0x03", + "proof": [ + "0x451a37713b00fa2940a52a0420ba01b9192e7b05a434ecc7e0007ff8e98f26f2", + "0x4bdebf74ae5bea3e62fa046ed0e6852222b97f367fb121cdc5159a2aec87950a", + "0x11143bf2cd84ebb9924b71d24ab1df210835583a66325b911ee5fca2778d0f13", + "0x9e0106695419683e28012ebdf11113a020b4f76869c1e66a51206a84371b717f", + "0x38d4a740f3f99a827703ce6725923277f058619e98435b28078dc5b994e00a6a", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2dBC54D6993a1db9BE6431292036641Ec73E8C70": { + "index": 185, + "amount": "0x01", + "proof": [ + "0x1bf6927cbf9da03267dceb791137fdab8c191aec4f499ab96d8253cfdb889bb7", + "0x4dab60e00ecfbe3b5d05610c9f2bcf3c22925c724b3890c6e2b15ddb5e57cb2f", + "0x7eec595c69d6c1d1d1d8dacd93ff7c8b18c1968069bdea1797a90eeecc155ade", + "0xc2b85fb7fbdedfff6c0826f89cbeff5a93f827eeaec8b16d80424b138de956db", + "0x8e0cc5c13324dce3ab0f042d31a9db04afe0918f70e3f4515f43739791621c97", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2dE640a18fE3480aa802aca91f70177aDA103391": { + "index": 186, + "amount": "0x03", + "proof": [ + "0x6926f5209f8b85603400820c721efda022c0806ee8b16a6f341b5aac5bbf52ee", + "0x575ec01ee64e98b94f27e1fd440fca1882e62cb73e7a79621e65156ce71fdb78", + "0x7745a5c31086c993a46c6a7ae6582a5b091fbe9bb854ab5d75a56c332e82c2d0", + "0x2b5637be96c5474a58c9ffbe0539171817312be59bc8b7c71e23242dd20afa66", + "0x245190f95f5e09d43d1da7e9757fa066be1942b52f7e4962cbbe6a5f2e0981bc", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2e2dBDa311F6b34a2a17fCDCEcFf86597c6bDf40": { + "index": 187, + "amount": "0x01", + "proof": [ + "0x03b8355132b9b903c9c4fa4464e80c8afe98d9928dc99b5d4ab506a809b0c681", + "0x64408e702a90c56ee3139fe4bc3cdcc9899fe539ef782acad103b26f6edf174e", + "0xc9a2fcc0e974df7c3918b7b263d9c6dc39dfe6718696db40d299f59e058f7949", + "0x2be850b7e0b2b6c90dd3488b90e348653e541a9cd2983b235559153dffffe1d2", + "0x9be1155992502d2b75a54fc5b2a41d663a86f7d329faea1befa0e24965b01a56", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2e483D373a827645100f7eD3003eC22bFBc83A3F": { + "index": 188, + "amount": "0x01", + "proof": [ + "0xbca3c9dd7c8f172908e123ba7ed0a50e9ac050c1c679356dc2c23b7aae8dc50a", + "0xb17e98ce8dad0ddf08271ec2497a3fe0011f9f409537bb4781b30248e5e1845c", + "0x8afb93098421e3e4b6478f7ea0a2cf7b3f942d556afab74785ace4a5071dee41", + "0x3886e44b7873439ef0a83b4119fca7dc640ee0f9551983449d038a076169bb1d", + "0xcf36a9c08620752945fec2c3138a9b0eaede19862d6c5cb3c0489e6ab3a443d3", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2e4c9FB11938Defea7c9E4CE9aAce540343999D3": { + "index": 189, + "amount": "0x01", + "proof": [ + "0x4592cc5f17e1d24b3622f90b65715e9b941cbf7a0b74d80c61e7a6b9045eca8c", + "0xac69380d16130db62e002944909f097c1380e942688fc22ed06938efaa3d96f2", + "0xca882a67ab86b0ef4e7ddca27b5df90183d6545fa0466cfeba52e7d10412db29", + "0x7327dd8ef29607aaaef9bd84ab3718158a620b3e164df6976909aaef215117f7", + "0x38d4a740f3f99a827703ce6725923277f058619e98435b28078dc5b994e00a6a", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2eD849173c7a54F45f849675A71B62c0c83246D9": { + "index": 190, + "amount": "0x01", + "proof": [ + "0x64cff86947b3e31b05f591306e6b8a2d0b3f0f89d720c1020834a78c1b7a914e", + "0x79cd4d0ac20e8003057deb4e3e5f3e9ff0fbe9cda84a4230079382bee6def353", + "0xcea7df5853c7450e538101f09c77eec6b3f2998d90e30a8070f1e3c1de4cd6b0", + "0xd2ab54f5e70cde7ed6caa9591ebf0def0ee5d532bfbf38a4473c6ff488c1d82b", + "0xfe7d73c06bd76d1271e4b772b51e13505a812b7c919129debfd7d15fb5014d16", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2f43e98067B488f2Fbb8465cE5f6dA1552d339C1": { + "index": 191, + "amount": "0x01", + "proof": [ + "0x5324769ad41b051da7d1086b016731d89d3cb6da7d3d183454bd9692b51c551e", + "0x336e04416f4d2dd04036b5afd331d9f724e2aec654ce7a8d813515b413e9225f", + "0xa21540ccaf175cc840a18d1224f8d3683c9d069bd5ea2c3bdcc7b37a61191f98", + "0x7a5397945a42b48bf4e4ee9c21f985e9d9ccf82e57fdb87dc2e6046ed345d7ec", + "0x5477c93aa7e191fd8f76e1976387fc82460220dfdcee87f9ba8926f4e0ddf45c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2f5f10D8136A986Df4943C3b4C335032268d3789": { + "index": 192, + "amount": "0x01", + "proof": [ + "0xd29d0a04c90bf97003b6f1ad394b6a06cd097c5131b972bbdd74056850e10d68", + "0xc6347ceafd79572e1b99b2f102fe259dfae790b392c5333a5744dffb65f90f54", + "0x3ec622c30c179a8f226f3181e0bf4aa4636a1725cf1861d7cef1a8edcb079b0c", + "0x41e64ddeb2fc55a967472c34897707f35a7b74171d5a7d21351e62fd45ccae94", + "0x7e73f337249898d15604f7c330d90e36da04007407404a4b4276d5fe3083b929", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2f7552Dd5C8F2AA17aea87387a8667C7619F4c0F": { + "index": 193, + "amount": "0x01", + "proof": [ + "0x05d9c0b8a795ae0ee25e18cf58012e34bf349b9324e8b2212720ecfcef0137bb", + "0x75aa020467f6536d0ea4c816be2e487e0d0c27fac89765efb6462ce21c1341b4", + "0xaa1e85f59373f7e7d78afd5cbb2e4e9873713a471b7ed5f4fc18db819e0c2cc1", + "0x16c0b121292408782518c2e86352704bdaa5fb42c434089ea6fc2adde27ce492", + "0x6e752d8572dc933bdf463f24751c7070d8aa74bb8987a5fe56dee3b0c9f53450", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x2fA08Fcc7e6FAf795417c3A73189939c7a818817": { + "index": 194, + "amount": "0x01", + "proof": [ + "0xdd93f3e53fb424d2e2b694fca8256bdd2bb54545bf3df0b9b430e09d4aece37e", + "0x219c8ca8f20acbb6200dc31e1fee1aa9997717563eaa34e2cf9331a1ef595181", + "0xeffafc2bde50804ba4e5e2909025d61329f3df3401c7029f57fe93a263cdfa73", + "0xc84beec6531767197744c2106caed4823936b1ceed7475952444acf832b57446", + "0xd8ba0ec6899e7ab5afd6774d7465b2ebc52e677b805f74deb131b1b243bae70a", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x308Bff328370FC4a9683aB9fCd79A21be6dC5eE4": { + "index": 195, + "amount": "0x01", + "proof": [ + "0x376adc73e1c44730acf3af995f6149d2b6686029e7a3e796eec03e98a5208929", + "0x01b5d3d3307b3d19e28dad9cbb2a624895297ca5653d7edb4d4f1073c1967e42", + "0xba70c400dd80e4274e96080abd494fc3d055f32a6397ae40d812707e3922a8b7", + "0x26d5243ad79c6ff0365171b12c8ef795d8c977a57cace1265e53f8b7326c312f", + "0xdc998377cfbadb1c2d77196acc69c259bcfcc6de58df7f5aeea2780a288f2509", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3096496352530ab645326d13da0723599Cdb8175": { + "index": 196, + "amount": "0x02", + "proof": [ + "0x8af74e6ffb6e19b74f05bdfad476a6bdb2a30f32ad0f3c4bc784ab03f0bc817c", + "0x66f977d5e1dfcb7bd97f6e37835fbe791e6d0daee4f0c72bb998bca8aeaa68ca", + "0x62b2963c1057263f03a882a1c74c6dd227168b925fd226563d397200dc561e0e", + "0x0c15cd0e5fb4411c59b182f983d4322f33d3be8bd2c5425b705021fa316a402d", + "0xe4fc54838dec16cd3ac94713f191dc41ac7f5e070180d4843c9aaaf9c71ce29f", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x30D1b089a594AEDd553e0961d2e5dDF29f69dcC1": { + "index": 197, + "amount": "0x01", + "proof": [ + "0x0577b5df2ab57225fb9819468f294d64fe32ce1b478f73f2d8593800a1892606", + "0x42c5f3acaf4f94511c0f3f4a1e44998db049884754b804e8eb70ff681db14584", + "0x42e42c172851a01dcca036d4a1ac633d24b1e05844cd3c0ddb1534c3c30a1710", + "0x16c0b121292408782518c2e86352704bdaa5fb42c434089ea6fc2adde27ce492", + "0x6e752d8572dc933bdf463f24751c7070d8aa74bb8987a5fe56dee3b0c9f53450", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3195c3F94154364E897711e501e104f40D8e23fb": { + "index": 198, + "amount": "0x01", + "proof": [ + "0xc45e3d39e34fa5db7a4622cc023e0258acd669a6a7a47cf2f7b163cba5cbd583", + "0xa5de5e56fa567b318aa22a6212bbe256c05d18f8c78ae1cad177efc01f132d7c", + "0x1c0c126d67f3347f6eb5a3e70bd23a4f895f18b6418e58068e703bb374301b5f", + "0x99930015299a0435807ebbffcd0957a02cf6631c31c05ff8ed9a165cfa4bf8e6", + "0xcf22c1d43a94c7c6471efe1209a3b103ec0a9836b6c11fe8d2e98d18b2e9cb36", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x31E985b4f7af6B479148d260309B7BcEcEF0fa7B": { + "index": 199, + "amount": "0x01", + "proof": [ + "0x9df84236c30a39832c2270d554f6f4bc31933068182f900aadf52e3ad373c141", + "0xbd5066563b0f07b0bcd1391846fcf78c20b799e36a594302f59213eb6de38384", + "0xd32dd306d1f42a39806611081f48b9b83cb4608e909a84d098d91b13868c6029", + "0x35b38a743320b292e89d9164e2c2e5018fa2478f9a132ef65671c9bacfe611e9", + "0xc36c52715656389b2693c145860adf3b1f3d4d24a139850b1fa5f2236456376e", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x327b9dEe1830F8201efa751fd96F7B1aD0b300A1": { + "index": 200, + "amount": "0x01", + "proof": [ + "0x6c7600a37a83cb5881434f3cb3722e7337f427c78b68bed565a9c60e3c19ae61", + "0x29171de8e69c0df7038ea595c755f1fb3a103106e457d750228773eaf0b99954", + "0x9d1bc2241ac02056b61650ad7cae67788655e09d14f6f80d511bc28bd1f815ee", + "0x283f6032b7beb32fcc6ac4b21c9941360bce453787f78b6251c38e3890b83a8f", + "0x1be60ce906d0d73954b2e1f2747ea1c9a23db0ad9345fa6801c551f1a39fa5ab", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3303b6AED6F306A6d7cf5e8C8956bEFd8F1Bd2e2": { + "index": 201, + "amount": "0x01", + "proof": [ + "0x6f1f4b5ce3e78de13b90ccea8f9730fd2873dbbbeb328be3ef1dd35f99154cee", + "0x29631c831019ea827b2fd230493a9694459e7a5f510754332b5dbf2b4b2ed3b8", + "0xca0621c350e7f4c10764a38942c3df34cc262e74fd6d9d2f4434fbf0443dbea1", + "0x7c0de9d8e837704a5bbfc4993fa9b20e3f698f1b885a0b593d018e35bb790c61", + "0x1be60ce906d0d73954b2e1f2747ea1c9a23db0ad9345fa6801c551f1a39fa5ab", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x33255195e4DF44CF7bc3e8926733396B0CA340E0": { + "index": 202, + "amount": "0x01", + "proof": [ + "0x87a9f143370a93f90726dc468c194157948349cc6b4e58883ff77fa36f1c4999", + "0x97e25993ad013625283866c50748df765ff71b428a032233b2207624c1e4f798", + "0xf2b143b8e4bb24b0f6133a57083058573afbf3f2d5a88213d4aef21a33017990", + "0xdb5507911490bc1574fb624fe6bd570cc6afcd947118f0c9c38fe90a00ee8b29", + "0x9dda7d74fd49fdacbeb3afcd37c878516159fe4b594e491ff7ecbc80fd8d6808", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x334A8271E45184D0fCE0090739684b6CAbc099a8": { + "index": 203, + "amount": "0x01", + "proof": [ + "0x894e2ba30e742def3f12088fa935c3f3efdb2a7675b11dc6331769cf4125c15d", + "0x822d4f4a856b42a89d2f85351b0fda4ccbd91ae86142a30869bce8083f1125eb", + "0x955d9858f13d562b2b223301c8206ff82e44d35786e621872e8a0ddcd2c8af96", + "0x16f452fd982f0f4e3fe20a4b2fdefc9226e8d1db4c0b29793acf9535b6c65c66", + "0xe4fc54838dec16cd3ac94713f191dc41ac7f5e070180d4843c9aaaf9c71ce29f", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x335c0552eb130f3Dfbe6efcB4D2895aED1E9938b": { + "index": 204, + "amount": "0x01", + "proof": [ + "0xc8158cf51990b10a9fd84690b85da31ef67a5fe43ee996039d38221d6e11dfb2", + "0x2ec1a43157568ee3f71eb3db2134b0beb5dcb531e5f86ddbe72dca4e015746ae", + "0xe4ac80d26c77ba89058dfefdaff6c557a8b7b9a413abd87f4e1ed3224c0d25a2", + "0x036edc84651a6e437d2aeddbd5e5d10d4911716f37c92c584d637f9f9ebb0dec", + "0x97fbe90108c9d6db20d511e4419e4ed044f589ef1f2a9f6539187bad21502f90", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x339dD90e14Ec35D2F74Ffea7495c2FB0150AF2Ba": { + "index": 205, + "amount": "0x01", + "proof": [ + "0xa8572a6126da7c2d84a1d26452e116e405ac92bfe99c8b86ebe646e387966a54", + "0xe507eddaad7c3ee6ac6ab729bdb2eab63539051b2560f65e1914e4ab56e61aa8", + "0x94d660904dde29f38b66932719fbb6b3f61f23334c6bed78753e9db544ffe1da", + "0x68141ce9c9d3196b1db61f6e6c902aa8569304d1613ec750ac0ffed8af2bb113", + "0x32636a5315ca425c602832f925f24426ea5aec9939c73d1b2a6fcdace85ecae8", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x33eBB62DC9ddBf6B8F3C0efdF5BccC2e7AC60211": { + "index": 206, + "amount": "0x0a", + "proof": [ + "0xaf88d3bdd69e1f35b47d4c88487454ecf0687d2658220ba351ace9259a70ebba", + "0x8bd3f7ec81a7ffadad31481a11e4fa679bb5140c3c9205a799eb0579ed1e5817", + "0x9bce549829c21177902c8beec5ddfffba1cacca3b9853a79de10a2978d74fe13", + "0x577f81e56558cea5cd9d5160218e718fdbd9b124f0dd5499c3e14a238415b645", + "0x72373ecc225af245878bc638c49c8901db1430b7210a3008231acc8f8118d2e0", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x33f144Aa851e9e55b042f46014bb4F737Bc777BF": { + "index": 207, + "amount": "0x01", + "proof": [ + "0x92feb8202052e8d14709992eaf647ba1e3a7f2df0e83234c207060a1644dd0a8", + "0x11da34f4ea9b53698d8ebf0d92cfc6166436e04c4d2c8da6c846fbfebf5873b1", + "0x416fc24a2fc25ba59a366a12617fa61dc7d155780e7b0cf47d4beaec91fb9776", + "0xeb79377abd71cdb891e1379260c8fb1947760c17e28c7168ccd62f5d772f861a", + "0xea7c0076ebef0c429d544548828ff19d5600136801cc28845bdfa9990d97a058", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x340eFe9BB2383d463313e7D988dDEA6B52B27B0b": { + "index": 208, + "amount": "0x01", + "proof": [ + "0xd2436d91c1e617fb27fdee527c27cb2515e74844576af08b961e242ef6685a42", + "0xb809b86810658c031224356a60cd7a7da6c33bf718356a0e795010fdd7a63d9f", + "0x3cded42477683fe44d3b53da8af7372eebcf3f7b5d0c072544d9d80a0220aa0b", + "0x41e64ddeb2fc55a967472c34897707f35a7b74171d5a7d21351e62fd45ccae94", + "0x7e73f337249898d15604f7c330d90e36da04007407404a4b4276d5fe3083b929", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3477823dc687e24147494b910b367CC85298DF8C": { + "index": 209, + "amount": "0x01", + "proof": [ + "0x47be660de89e088c1353e9b9ffe68136d526b22c1db5049a0e017f21d7b16b96", + "0xb9baadc0797d79ff8f40903bdc5c0ed125727204adda4de67988ec84199044d1", + "0xc117d5a519f6e0f840872df99b897139406abd328261f34a6e382399bddb5bca", + "0xa5e8bb53f83c3715772cbf32d53d2e1c1c9b5abd0d51618f0e2ec2960d9a33b8", + "0x43f59a603c2458850547e5a84d47e61be843b4a3c814303ed1b52e1e4d37a1b5", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x34B97dF76e99123305b2e5F04500c95f432e663e": { + "index": 210, + "amount": "0x01", + "proof": [ + "0x1a5928e23a89fddefde6c41239d5f00a4fd78039e60eefdcc165515b721104bc", + "0x7ae87d7a29876f3cd8cac0feca7f681d230c6a6655459c0842b1eac0993607da", + "0xfe66f2955b7edabb48cb9446e3380701b161ec72c61f6ea4206263931d17ec7e", + "0x6b5b18bfb5c7b8de5b52219b51a21b6ff6e22d5cd7a147d521bbfac13cd7f7ac", + "0x93994074bdd819d668a79fc2c79be23cb074a679cd3fe03940945d4c6f9fa9b3", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x34D9C63944c871F698E5aBa2E8FffE064a937b37": { + "index": 211, + "amount": "0x02", + "proof": [ + "0x27bc154c09a015aa75b6fe0168098f7faa971e370fc6ed3e982e5487e666e250", + "0x3b55f29e6b8a42379cd8e8306f4d52325d77ad3e3654473713dc048ecdcdf301", + "0x937839ce24bd273187bcd1af0328a690c712a30e57af8e26d0ff2c9c1c709da2", + "0x1ff461854683a34317216055e65b6637346912d1739163d25c1a0b0a5f15c25d", + "0xe29ba79106b7b14c14912bb5fba509f27997ddbe5a7ebc941fa75e3475af4aef", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3503fBFac34974ca8F8c1688C597aAa08fFE97Bd": { + "index": 212, + "amount": "0x01", + "proof": [ + "0xa4369ed9c3b8eb9c95e39aee8740a38a7471c9e61f5cb3f2312454aa447eae4f", + "0x13eed6a0e176efe8128f983a64f34211969ae86a2f13b9c2bcb11cd3cb255fe2", + "0xe9c518193f61e187a919aad09e78c1cff35aa13804b131d81f50f7740479a903", + "0xc677cbee79568f65b4882bd20044555e2bddfb473bfa6749d1d07caa3dd6fd2b", + "0xdf701aa8bdb3ffefff1b359214087cc585fa0a0d40716a6635a8d2db4380dba1", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x35831dD1B909058c06d1A81d652bAE40C10F70Df": { + "index": 213, + "amount": "0x02", + "proof": [ + "0xf4a0731672e50135d6959d191b55b34c129dcce7310a1365ec0b819461bf4337", + "0xade8d41148f1cd920291c4dd68b68a72acee43e11b776574010473e9d96ef929", + "0xb0010d722b0a6ca31a164d69fd41792020ef08e55c137f9e16186b7da6a1b655", + "0x3293f41caca9649b5e2565aa9f9ba63bf7c621850061b0b1b6af864bbfb07389", + "0xed5c942adbfa1d9538c55e89e4a7ff4276f908ac558913b5f43dce424bab8e0a", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x35a1A0B5CE63afDB03E5bbF95B7278AaB6BBbC56": { + "index": 214, + "amount": "0x03", + "proof": [ + "0x032c33a9d9a5236a479ef00b0d050dd512eae8129c4678c85290c23ccf05a00a", + "0xd6702010f79e4804cc549aee31f21eae323920b7067d9d2161c8c5e240bf76e0", + "0x473c279a80efdd22e0652061508704656dccd4cfb6e1c6c4e5d7b17c2a8e4eaf", + "0x2be850b7e0b2b6c90dd3488b90e348653e541a9cd2983b235559153dffffe1d2", + "0x9be1155992502d2b75a54fc5b2a41d663a86f7d329faea1befa0e24965b01a56", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x35c3cCBbFcD78F2B3581260c5464A74e58D27049": { + "index": 215, + "amount": "0x01", + "proof": [ + "0xf51e7f1ada9f1dcb9a95f16c59451e8577d3db9f9b18a48c6e3ba8388950774f", + "0x33803b1d0cfd390a713164332790dbb55114507a79bbe1034649973fe4b6226b", + "0xfd0268e900a7c1ec041037fe894fcabcd46c99724b846e568ccd38d01ea0b2e0", + "0x3293f41caca9649b5e2565aa9f9ba63bf7c621850061b0b1b6af864bbfb07389", + "0xed5c942adbfa1d9538c55e89e4a7ff4276f908ac558913b5f43dce424bab8e0a", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3631401a11Ba7004d1311e24d177B05Ece39B4b3": { + "index": 216, + "amount": "0x01", + "proof": [ + "0xdf89bfc74e60dee4a57c174c8db44925d25b1f8d1428da8af889b28e126be5c3", + "0xc600b81b925f70134b23cd4d85751355b23c441e5bf5760e1a7da8c1a3146e8e", + "0xb9a7fa3b7b5b9da3469420f2d9c4c74da6b2dea922f5543ccc924907c91aaa0f", + "0x60dd57debe01b07f2150f54d637bd8f574df12ac003a445ad012509f5b619671", + "0x966715df220dfbe5e11392b257b61b64c18178d1825b654f95f67d7c9558a2a2", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x36aB2c824FCc7e4EC8dC2805bdA069d9d8b54c95": { + "index": 217, + "amount": "0x02", + "proof": [ + "0x76b8b2cda61a52bbf1090349cde3de9a3c85031afdce677aed57b4f26730ed60", + "0x3d3331ec5b67cdd4c6e2cd551562b58a9285b063ecb4e34e5dae2c0eae067911", + "0x2f8ed4a6263c91d2dc6b5dbb2c00b52290fc594ce1c465e4bf2c33913536fd62", + "0x2542d5bed1352bb1dd1986da7e22c1f92c0eb7a7dead185e5100d7004e8e054c", + "0xb78cb1aa869958030ce4a14b5fff6309166225c83e0cdd2b91deb7b1639f67c4", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x37Bb4B96baF8A91cb97877cD7Cd30914b398aa87": { + "index": 218, + "amount": "0x01", + "proof": [ + "0xb9ac1d93edab48e5833cbcbe54ae9b014d2e560ae76a35a62e8e2be194519712", + "0xa3defd41de9e21a5eff42dc10d21461c2c17c7aadc6fe3a007b43bd80b235fc1", + "0x46523762bcf4ed5e79e15cfe2edb66750ed12adc7f6f405d6e19ee3580efdebd", + "0x4f5594402e5d778ad5cd48b93173f203af8e62306714d707dc5f989e11faa170", + "0x83e262e483a6f2ff9f4df14637dbbdfeddf0c6b0b4ca462c4375d29a3521e052", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x37e887ce9f6Fd3c9A050332FF20ECE27D0f0A8E4": { + "index": 219, + "amount": "0x01", + "proof": [ + "0x7b6b9f940cf1e4418553b65694c7177f458621f0d116658ef3b2b1558a163806", + "0x839ceec5b6fe1a21ae420c1924b51de25afb51ce6d517ebae262ca9672873a21", + "0xbbf16f648b89bf5c912677dc67e477a51ede03df7de459ae6574a364b5f12c66", + "0xc7b7942da27652b608d4a505a59fef704f26c49f0c2a23709d80122b3afab5bb", + "0xe2050f6c95c616c1cfdb04f4b6d0afb5afa0fb464f767c38aba0f07df915a97f", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x38148eCC2078dA7f65E6233DDA28eFaf4C51E96F": { + "index": 220, + "amount": "0x01", + "proof": [ + "0xc7a162440b40352cf6d95e1aca5fa409d657b28326a72f77414178f6a49fd707", + "0xce20e2ce6e6d69622450f3ed50b2230b0d0af94185588c000469352bb152a017", + "0xe4ac80d26c77ba89058dfefdaff6c557a8b7b9a413abd87f4e1ed3224c0d25a2", + "0x036edc84651a6e437d2aeddbd5e5d10d4911716f37c92c584d637f9f9ebb0dec", + "0x97fbe90108c9d6db20d511e4419e4ed044f589ef1f2a9f6539187bad21502f90", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3816B86959B510AC85d3a56178242e1D8c208848": { + "index": 221, + "amount": "0x01", + "proof": [ + "0xcfccbec4126944c0f27b5eb9a9bf13a50a34d113f0db02f603fa26d53568f7d9", + "0x5d055356ced4e10b8976ba076c2fbd99736886f69869e724ab4afb0d5dcd3c20", + "0xda6a400b1d206393ae5c21fe289d6b139252aa072673d47cca7709e41439c7e9", + "0xcea68af505202af90a0679269376e373d9ceca250970bcb6953e0f30f5dcfc7d", + "0x85ada07677b521b0dd2e0d60f51f92f7b1217f46e36379a5afa5a74fd5c87a5a", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x381c57356B68fa4CCfb9804003034b0477cF56dc": { + "index": 222, + "amount": "0x01", + "proof": [ + "0xbbbe68731d8577a1055c120326d33edcab647c207038db28993e3d0bbb4bb43e", + "0xe8abdd64909c625ba1ee074a24af6939d962f4e53e9b1e45e3b645ccfbd04fbb", + "0x676a4419b79ede64c5f134c84c12f5fa1724be03db300147c6ce62c8a2747911", + "0xdb334b0b3ac11eef22a51af7bc46c7a633665d404c70629bf6c429ed0b8d1ae6", + "0xcf36a9c08620752945fec2c3138a9b0eaede19862d6c5cb3c0489e6ab3a443d3", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3864571217aF4877960B2ef0E8A55c6AE263FC82": { + "index": 223, + "amount": "0x02", + "proof": [ + "0x6bd9c6eb1c0d4c383120c56f022b37b2201e3d3452b5929acdcbb2bccc421773", + "0xfe9ac72de3812ca5d81e38cb720c0a6ae32a5026a19a351f4a81a581f9c3a3c2", + "0x1390b60f90b43662c35607eef4b6d21963963777720b34f19533e009d75b03e4", + "0x283f6032b7beb32fcc6ac4b21c9941360bce453787f78b6251c38e3890b83a8f", + "0x1be60ce906d0d73954b2e1f2747ea1c9a23db0ad9345fa6801c551f1a39fa5ab", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3888F5A94560D6af334c82DC5D94C134870f9E78": { + "index": 224, + "amount": "0x01", + "proof": [ + "0x664f6fc0a620f07f6322721ee9ae9f67b784ee8dd08a6ae3a3295bf39b074d2a", + "0xfbe15ec8abd0c306b1b03386edbe3c180fd84fe76020dda49887719c7446b125", + "0x9feb249fa051b9c4d2179c5c0a8ed76334b875245fb0c811161d3bc057ef51ab", + "0x5fee000564bb97bedb499d3b5c01f147f4e4ad76f5f6443565804721f95dcda3", + "0x245190f95f5e09d43d1da7e9757fa066be1942b52f7e4962cbbe6a5f2e0981bc", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x38A7d735Aca3c939F189a92f41cC1F34da2907D5": { + "index": 225, + "amount": "0x01", + "proof": [ + "0x335ae6b5ac8c599266a0a80f6a5dd127e0a04750a2d499ca111121046f2531eb", + "0xee991f9d916caba88413353602ea6bbc0a227642f7d3405f16a01948480d2756", + "0x2ceb10a8fdb6b89453aa45138287aaa29f977b0aca5b8c98dcc42bdaf69fa298", + "0x9c7a414e889956f4c85241ac1c103f8242a6795725b10a2a17d9a1d125767087", + "0x963cc7ad3f8f0ded379d05906b629df8cc616633784013c90731955d0b0736d8", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x38caF2D24A26a7F14000860198642e6Cae834764": { + "index": 226, + "amount": "0x02", + "proof": [ + "0x45a6e58daf4bf9e27c633514b2130ce3c8fd476158d9b52dfaf979949f20cf4f", + "0xac69380d16130db62e002944909f097c1380e942688fc22ed06938efaa3d96f2", + "0xca882a67ab86b0ef4e7ddca27b5df90183d6545fa0466cfeba52e7d10412db29", + "0x7327dd8ef29607aaaef9bd84ab3718158a620b3e164df6976909aaef215117f7", + "0x38d4a740f3f99a827703ce6725923277f058619e98435b28078dc5b994e00a6a", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3909899a6eB22a59890DE400241fb74389A680Bd": { + "index": 227, + "amount": "0x01", + "proof": [ + "0xc976791d77b8ab93002afff1ce6309471f2bae5a7c46d6cbe0781f0c0e20286f", + "0xc8c7b3b0ecdba6665a7605b904bec7c7da98c3aa20cd783dc262daadd15cc021", + "0xbbe257abf6239029d7b9473e959941b7ffd9cc84496254335d553ed2f9334fd2", + "0x1f4f9d2e01bb8c804693d53134cf046798ee2607f0aa015ff42b474e23cf7ed2", + "0x97fbe90108c9d6db20d511e4419e4ed044f589ef1f2a9f6539187bad21502f90", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x391891Af67E29D97E61E30C3036a0874F5Da411e": { + "index": 228, + "amount": "0x03", + "proof": [ + "0xf938a543bf725a9ced42d3e063a15ff191cc9492edbaebd1748c8c2694522f0f", + "0xf844c56b74173490eb513b4a77ac6240738ddcc89e2096443dcf07aa60bb1691", + "0x4bf5a604b9a09c347e1aa7d41b0a7679a3e791ff15d6e96a280af113935ff733", + "0x3aebe8d88cbaf4043e28b3d6aad9a1f79bda4dbadcd2f685785a58d155fbcc50", + "0x8e7f75ccc4d864471b1a7ec71efa29a4e8cc4761c26a6987c8043d9ca642a2a0", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x392365d5954A9b8Bce72cC6b55BC206120145220": { + "index": 229, + "amount": "0x02", + "proof": [ + "0x696d05b307182bcbbd7df2eb77a93c24151823b6e763fb7eb42ad7cfd812d83f", + "0x7e8e084cbbcf1e65803b8cdf743917a79bbfac97e7dc638fd22cd422862a9c03", + "0x7745a5c31086c993a46c6a7ae6582a5b091fbe9bb854ab5d75a56c332e82c2d0", + "0x2b5637be96c5474a58c9ffbe0539171817312be59bc8b7c71e23242dd20afa66", + "0x245190f95f5e09d43d1da7e9757fa066be1942b52f7e4962cbbe6a5f2e0981bc", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3942Ae3782FbD658CC19A8Db602D937baF7CB57A": { + "index": 230, + "amount": "0x01", + "proof": [ + "0xc86011b34b1067c93f5dac32c5c1473933963e1ad5c0e3f7bdfa46615eea056c", + "0xaba5806e44586fc162ab10144b8116fb6e5ed7e6b923fc457b203479a68c05ca", + "0x906c494d7d3c4c5f521930d1042cfae9154fc6b37e57ecec673d01e269ef7429", + "0x1f4f9d2e01bb8c804693d53134cf046798ee2607f0aa015ff42b474e23cf7ed2", + "0x97fbe90108c9d6db20d511e4419e4ed044f589ef1f2a9f6539187bad21502f90", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x397eADFF98b18a0E8c1c1866b9e83aE887bAc1f1": { + "index": 231, + "amount": "0x01", + "proof": [ + "0x1eeb963db2a7ea1509925937e30ec1b943f074854b5a2a94c1376dc21dc92aa1", + "0x1116f0c67ce5efe4b4f7d12b998bc63753b3211b6de2acf65031bb791bfac4cc", + "0x8fc8a67860c71618ec1d12e3c31e1c3661720c696a607f77c198be36067f576a", + "0xc59577d42e813ea179264892414f1c8c6f09486aba6c8a1a1cfecbf6d1e7784d", + "0x6665ebe68e892e4e5135c09f9cdc379628aaa60a8ff322ed2ba75fab3b3a9cc0", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3A409EfF50A47aEeF294E3f0BB3874490dD99abc": { + "index": 232, + "amount": "0x03", + "proof": [ + "0xca3ffcbb93a6050c3834082b56af0b7c606e4a4d773fc2214bfc01fa1334107a", + "0x7b4c6d333fad478f8a08a5e68345ba6284b894495a474ff212b8a2e7c01c3baa", + "0xbbe257abf6239029d7b9473e959941b7ffd9cc84496254335d553ed2f9334fd2", + "0x1f4f9d2e01bb8c804693d53134cf046798ee2607f0aa015ff42b474e23cf7ed2", + "0x97fbe90108c9d6db20d511e4419e4ed044f589ef1f2a9f6539187bad21502f90", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3A8173cB3b6D6E02d849Ce280DA129D91AA9E68c": { + "index": 233, + "amount": "0x01", + "proof": [ + "0xef446d4b0154b4fb43385515c4cf6bc0fe1f7b5993bac0501e1addd9cfb1780a", + "0x02cde154319925ca4fa9b0ddbd9e11ea6cf4a205e11465c0c51f4bcc3fac8e86", + "0x8b6f824fe42a7f1d9f569625e32995ee98e15b37301a2c7063fe65c4ed0c6e78", + "0xfbd5cea7e1eb5806f6f82efdb0e881576ab386159b1b3ff7402e4bf56a947d8c", + "0x58340ed8edb441d787ada6b1aaf2b1e42912724e1f0f7887cde9253262aa0534", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3AF30b956F1737005B6e3146dBbd35B70F30Df91": { + "index": 234, + "amount": "0x03", + "proof": [ + "0xf33d79dbf46a4c450edacd652e59ebf203f3169a2bad02d27b5d2395e0fbca93", + "0x73cfecf81f8519a867ee3ee6f6f5edc70d8198efc0ec8d4be34516a10c30a333", + "0x9dbf8a188dd35869d18593fd709b3e786185f077d3f4c9439919ce6a3d6d5731", + "0x7caec6cdfba66dc7947ce7a10af67bf36737d573f70c5bcf73b71057ac86d1f9", + "0xed5c942adbfa1d9538c55e89e4a7ff4276f908ac558913b5f43dce424bab8e0a", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3B737ba85aA1a022651A0E596a3e18f856442D7E": { + "index": 235, + "amount": "0x02", + "proof": [ + "0xaf3fd7ba5ec752b6e8cb46b331a6333d372b263eb32ed94eb3283b58e7d6b252", + "0x884dd9c990148c637adaacee9e32655aef34b57be5e027180f902bdea3294f9a", + "0x9bce549829c21177902c8beec5ddfffba1cacca3b9853a79de10a2978d74fe13", + "0x577f81e56558cea5cd9d5160218e718fdbd9b124f0dd5499c3e14a238415b645", + "0x72373ecc225af245878bc638c49c8901db1430b7210a3008231acc8f8118d2e0", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3BBB4418C0A4d89BCb10042091C19D730e7E8Ed7": { + "index": 236, + "amount": "0x01", + "proof": [ + "0xd2ac315f67c7f054f9a7283596b295313578121d67087614c35f82952405e7e4", + "0xc6347ceafd79572e1b99b2f102fe259dfae790b392c5333a5744dffb65f90f54", + "0x3ec622c30c179a8f226f3181e0bf4aa4636a1725cf1861d7cef1a8edcb079b0c", + "0x41e64ddeb2fc55a967472c34897707f35a7b74171d5a7d21351e62fd45ccae94", + "0x7e73f337249898d15604f7c330d90e36da04007407404a4b4276d5fe3083b929", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3CfEcad11f3DE1c2d67EC6FDF7fecdC38676F2C7": { + "index": 237, + "amount": "0x01", + "proof": [ + "0xf9c3882640869d7e326aab3d5eb8e59e10b3bc0f9ba809d12c64820cc81e66f2", + "0xc3873e2cb05808b5b81ee973cf8875e2cb2da21687773e7ab16918643a1e9a43", + "0x3708d8178885b9269e803b79a4e0463134629db473cf8c80861afeae7084931d", + "0xa151a98046c68dc4de0dd4ca59fe7fff4ba692aa78310b499e772f0cf61a08d0", + "0x938890418edfff03e5d8f0abce65769ab79b16db349d2869a477500717305360", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x3D1a5C7C73d49845aF0b4681C236bAc92a2B2e11": { + "index": 238, + "amount": "0x01", + "proof": [ + "0x3c048962f338cc90ff649d6a6e25618d19e8a734a3257d68b13b3204d9972873", + "0xa06cde13b1bbf2bedb4ba3c34cc18c4cd81a80642d76795a73f7b6889b1de1b9", + "0xbeb2c810887b1f03a89248c556855316973dd3f9f824dd7608a2162c3b2e6c6c", + "0x0f96aeb97a653e888416c064689ed19e2c4f980fba2ae619d0c47550168b385d", + "0xb5bb98883f5ea232108866e1400cd4067f34fc2d70605fd2c67051a6095af7f8", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3D666eAA93980035755F4CBC96EEE9C22CA7e101": { + "index": 239, + "amount": "0x02", + "proof": [ + "0xd34503c8900a791184acf2b4b1fe5f711b2499bb7b1bc38187933f311f146c0d", + "0xf205429173ff3206db22866262af56bce196a1f03f8462a2af5e24401468cbbc", + "0x3ec622c30c179a8f226f3181e0bf4aa4636a1725cf1861d7cef1a8edcb079b0c", + "0x41e64ddeb2fc55a967472c34897707f35a7b74171d5a7d21351e62fd45ccae94", + "0x7e73f337249898d15604f7c330d90e36da04007407404a4b4276d5fe3083b929", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3DAc271d1B36A434880C527A678B6487AC9C1F8c": { + "index": 240, + "amount": "0x02", + "proof": [ + "0xfb0126969524cb33a85e9e2dedfce2cd05258423cca5ac00672eb1ffa7ce15ca", + "0x579f20e9e1d029b8733f777de11d92106a52ed5ffe80b41abdad04f1c7994a7b", + "0xa2bfc6b37e4189ddb762b679e4a5c9ece35447f0664935e074375ef5ac0ce2fd", + "0xa151a98046c68dc4de0dd4ca59fe7fff4ba692aa78310b499e772f0cf61a08d0", + "0x938890418edfff03e5d8f0abce65769ab79b16db349d2869a477500717305360", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x3DE025CF38E843490388a761540bD3F155249873": { + "index": 241, + "amount": "0x01", + "proof": [ + "0xd8e671e3297ba105e652020aa99d23f9ed75a437f30415828e307df324cc5b9e", + "0xdb07be86a0e5d42b4e40902901be148f366c533c1de45a64750e06d31ea21108", + "0xe5131f39e8805c0037f27f127ffa4446b615fb4b7a3617c4bc555a5d8c3944ab", + "0x539804c7bf7a9b6235d14df5f64369e5a3ba52daf4ce320d3134eb569c42ebaa", + "0x57a1600e1002b648fc38956dc1d2f34be5ee3f6cf170c73bd27c43b2a01e45db", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3Df047d6fFe88D5309859CeBb1bD9A3E19338FCD": { + "index": 242, + "amount": "0x01", + "proof": [ + "0x421b2cc91c4e6d1dc7ac3150b14b832015369c982d720f705d613fdce9d65a36", + "0x44f14a9ea34df8ddeb937fe125979d0f35427540b78c88e5637c509e4fdc63ec", + "0xa734a0bd47ea59109ab668778330ff5bec3b192c7fc158c8d946591e657bcae3", + "0x9e0106695419683e28012ebdf11113a020b4f76869c1e66a51206a84371b717f", + "0x38d4a740f3f99a827703ce6725923277f058619e98435b28078dc5b994e00a6a", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3E067baD76736b9d782a106d02b5E2efDC1C43E5": { + "index": 243, + "amount": "0x02", + "proof": [ + "0x3bc734f21bc10f53818bf6ca5bb0975c31560a7921057083f42e2bcb919cede4", + "0xd47ffc9ccbeb4f6924016ee29a015a3b8fa1de8ba39b46488efbca12dfb0b6f3", + "0xbeb2c810887b1f03a89248c556855316973dd3f9f824dd7608a2162c3b2e6c6c", + "0x0f96aeb97a653e888416c064689ed19e2c4f980fba2ae619d0c47550168b385d", + "0xb5bb98883f5ea232108866e1400cd4067f34fc2d70605fd2c67051a6095af7f8", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3Ee1C068FC9653489A5d03ab925047EFeeb4Bc26": { + "index": 244, + "amount": "0x01", + "proof": [ + "0xb6a76cc63df153e1dd4bf9a154043f30b527292d54b983c54a1c37b0cc2adcfd", + "0xe4526e937dad465c204fa88891d630722d9e6d3e97e7eabc336351d4f30490c5", + "0x2370bc3e49aeead81a8f59e3d80747fc9da94142f3be3098f2b9504a9dc4fd7b", + "0x841ca200e81dde455c9bb72802b7b377b46a9d6779eec08b07e61939b8d43c1b", + "0x529f1b48ab616d4dd60f663753a7779d8ec25952bc8c34df4aa96347bdb0d542", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3F3Bb838be5d2Bc7805c1455562A4542137B169a": { + "index": 245, + "amount": "0x01", + "proof": [ + "0xb51dd70bc088301eec05b8f453caa23c8869f168ea52a5729ff0e51a005a5538", + "0xf255d9f07f49c020c87f9c2e38fd9b6b80ee8838ad6e066424cc604cd7f983af", + "0xb2ed6280151caa17489d6fb4598efd9034b403611c60ec584929ae6e4dd1f3af", + "0x575d2e3f9c311244d801f96a2b4f9fc9666f8793f898d400d71e121add7f872f", + "0x529f1b48ab616d4dd60f663753a7779d8ec25952bc8c34df4aa96347bdb0d542", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3b468Fc2E44b544CeEE893eb241D0aB30361a538": { + "index": 246, + "amount": "0x01", + "proof": [ + "0xe2f4bd7ad2a27246ed9345c459f0e0fb87e45565efbb859634fa0ac195091839", + "0x9fc3007c8b07f92ed58d487e689454caa871f76c502f3205f64cb5b42602e66c", + "0xe245c0cfce194010f5d1ba4d1e2acebcbce7ee3beb09abd2da7ac09a58a6c76a", + "0x1bd24f0c1d9a337a197e1feb80905be5821f1e64457aba030d18aca78646a08c", + "0x7968b2383e3b914ab3a36580b205f1449b51563630c77871f712e94743e3bf39", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3c229864378b3B0adF98aE247Ca33986AED8EC1E": { + "index": 247, + "amount": "0x01", + "proof": [ + "0x941c342c1f8ea0384275a5885ceaec23e57b503cc28d8cdc60d6c6bae492be35", + "0x74c533b7fa0735fd933986ca7fe1ccfd029b4c093241467a5c239155dc1a54cc", + "0x75bfc221d8f7e7fad04c48ba5ad53c5e62ff5db03c3799cd4e3b45e76de5d2c9", + "0x6ebf988ef586adc2237357c1611e0a6bf7170af1257d42fb6ef98df1f5052439", + "0xea7c0076ebef0c429d544548828ff19d5600136801cc28845bdfa9990d97a058", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3c8c14CB40dE7f15e0c4472F875b58Eb65cE1C3e": { + "index": 248, + "amount": "0x01", + "proof": [ + "0x625f531fe5024efec49b694b85a2c5fe9013795c53dc6a5139cfc9cb063566c5", + "0xc758d1936aeec3a77dcd8bbc4d50ab72cd803b158d31ad53a0686a69d7e06280", + "0xc7139805f0a4080488e635a7b81ed8c230c27ff6fa0f383174e4da67d2bc4f72", + "0x22784474cee51afee6127b1f3fb642ff75cdb40aeb505017bf6b1a1162a44c35", + "0xfe7d73c06bd76d1271e4b772b51e13505a812b7c919129debfd7d15fb5014d16", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3caA37c9c1C7cbc2259BC4cb28d180Afd87a736B": { + "index": 249, + "amount": "0x01", + "proof": [ + "0x903284a1fec323110f38ff4c16b38f67580bb94799acff9f81fbace1dcab1127", + "0xdd35a8364b39efe0ff47f199e8600ed4ea2861d0645092a22de6be4736d0fcb7", + "0xef1d4406d91ca16cad3c2ae3fcec81605fde6f08b915d8de8717673e99c1746a", + "0x1a6147d096056583b570a6da72277e79d6ef31519ab9cdbd2d1115f5eeb94a46", + "0xa4e0ebcaa65c6595e7c7f0ffb89992e2b9cb58ac405c81aff220fc4b16ea3b6b", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3d09FaCB91EbF3CE40675d684374Bcb7056fcaD8": { + "index": 250, + "amount": "0x01", + "proof": [ + "0x03b9340b81538ce98a3ef9de6ad1931e88294aa273ad937805b630817754f3f4", + "0x7d6f848972693b2380fd40104e619ae07ba94d0d68be7f7a26a277a832d3154a", + "0xce425cf8478bb52919447ea20d7a544c17358dee3ce6498f1cae3e3f0f173aec", + "0xf48849b03cf9b334d4dc7a6911b922272cb1a72dc4223db35fa6c699461d5f16", + "0xb18758ddf98cdeec3d020c2379717281f5c0fa0133be7d006f7f753c756da43e", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3d4cB719da1C1E7604c5B41DD2Ed4F9EcEbdE059": { + "index": 251, + "amount": "0x02", + "proof": [ + "0xd195c5e08686907a17ba4d97687355ce6d0e509a901dd9c2c422e2645ccd8eb4", + "0xd89cb7f045b5b24e579216c7ec90a43a96a6ebdafeb26b08f47769dd973a8e5a", + "0x290beee419f0613b459c711e5b28028d47a7d1917c0eb36c686bdc2bb4991683", + "0xd549250cf81d453ab878cb87d004bd56f5975ca86398b00d651f71d522925a30", + "0x85ada07677b521b0dd2e0d60f51f92f7b1217f46e36379a5afa5a74fd5c87a5a", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3d75461E299280abc77fBEc6C6B39960F7A7CEad": { + "index": 252, + "amount": "0x01", + "proof": [ + "0x33f498e49743ea0c1764e7d78aa05fb6dab75f00c1e5bb2ba153e9bf69b1054f", + "0x89914286a870c5d0b51ccc03413505f08a95629f4f42c1192fa7c18ba61d3fa8", + "0x2ceb10a8fdb6b89453aa45138287aaa29f977b0aca5b8c98dcc42bdaf69fa298", + "0x9c7a414e889956f4c85241ac1c103f8242a6795725b10a2a17d9a1d125767087", + "0x963cc7ad3f8f0ded379d05906b629df8cc616633784013c90731955d0b0736d8", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3db4DcbD65E3879Fc3EcE583d0bd216062FF33E5": { + "index": 253, + "amount": "0x01", + "proof": [ + "0xec3fa848b9ace333d2c984a4479173279f2d0d912b3fde9644fc8fce5eb0bd60", + "0x5b1269b8944ee3ab1144f2f68294d642f03859fc772cdc849524947d49b1dace", + "0xc7a5709349e5e5daa302cf7bffba9d9d810a658db5159793c0ed38096beebc0e", + "0x338979409b1c886a92a48a505a3f0b093231b3d66119d999f9bcb41baf89c59d", + "0x6e496426985c92b04963088da4856230c781a975dbb5ce2d8eed77e7d2d4b58e", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3e92836A6b3d51b98b78a3DC976D52e39c9003bA": { + "index": 254, + "amount": "0x01", + "proof": [ + "0xa5bc5b99fca781f2732d21a00982bf0c185d6a40e4d24c2bac1b7a1b367a0ec3", + "0x5b77b626b64a03ff54b858bda2812b9cbcd776c9ec4bd6206d29a7fa1c13fb7d", + "0xa1721ee66f5b33fb1491876c9638c9e321f4e9e99e92b69903d4c3b0954511ab", + "0xc677cbee79568f65b4882bd20044555e2bddfb473bfa6749d1d07caa3dd6fd2b", + "0xdf701aa8bdb3ffefff1b359214087cc585fa0a0d40716a6635a8d2db4380dba1", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3f4c81bB05E8056ad609091F3e4821E0DF8cbf05": { + "index": 255, + "amount": "0x01", + "proof": [ + "0x45b2d8cb089e6154d8a5477e59f7d8f28c3129cc518c7f5b773a1c464bcc1237", + "0x97c775f7baf06411d34f1581e91c8e0966e8ea8fe92fceb8db9067005537537a", + "0x2bdf090ce3f01130e644c85626d9e4c382cc0c53fa0abf14823a72643b52ec85", + "0x7327dd8ef29607aaaef9bd84ab3718158a620b3e164df6976909aaef215117f7", + "0x38d4a740f3f99a827703ce6725923277f058619e98435b28078dc5b994e00a6a", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x3fA99Ea896f716D0cFBe370A8f6bEc32a880F6dC": { + "index": 256, + "amount": "0x01", + "proof": [ + "0x2d39b874ae8daa326943ef88d8a5978edada2e38b7e5c35fa8a5b68d06a49c0a", + "0xfdf8763b78a0d5a586d35123aea4d38f8350ce78adc5d43e06aef4b7a46f447c", + "0x7459c50ac266878a3e428777040add9dd05d3119fa6ca0893dfe78b87af16a58", + "0x71674724de34865e988a846825d9f937ca48ef7322279591194ca7d40d8ee995", + "0xa43a1be4a3c4bbd4e28425f3172d3522b7e954d7cf0fc72a26d8ba7bea25f197", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4066643f04859fa538Ba8EAa906C197c57e4e3e0": { + "index": 257, + "amount": "0x01", + "proof": [ + "0xedcd751c336e0c26a91a1515f1c9102fcc4fe7b9ffac53673bcf5c8ac0835e91", + "0x5246e03ede7c4f11729527196e0ca2938b6a5d1248a0f39c4ec3f76e4095df7c", + "0x0f1c6c7aaffd63c4e9f25ab9cced8d3f13972b255c9fce8cf940b54f7722fafc", + "0x88222db835a579969caf99eebc6d7f986a78bc44f46b794a4319d01749c83a2e", + "0x6e496426985c92b04963088da4856230c781a975dbb5ce2d8eed77e7d2d4b58e", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4085e9Fb679dD2f60C2E64afe9533107Fa1c18F2": { + "index": 258, + "amount": "0x01", + "proof": [ + "0x9df34f98e014d3a56e3304a0780560bcc4a734322628cd7fb924d8e8f27376e2", + "0x3ce8e30840ba8c220899d7f89b36dff5f18103945b33bf9d748d5e7c8d40150d", + "0x8b2d67a4a9f2f8b679f7d72eda0998f5c76a314b4711b6f34f4158126ea31f89", + "0x2710311af5d5c72181aeccf7f1e36c3065b1ac40ab236128e22d5cefe5ca9032", + "0x0b385e4882f89784f506afafe6dd217c6ad9d142ccf58713e27961d25b2c6d0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x40D806cf859fDA82d9a6d79e1D85d23B9D34C99D": { + "index": 259, + "amount": "0x01", + "proof": [ + "0x9b897f61cb0e5e7fad2e2c9430bdaa6c5fa8afa949af437f66ba9ddabb8ed8b7", + "0x8c5e98c974561c22a3fb219e028f124672bd06d4831d97d21c4839d9aaf36be9", + "0x5f131578ec5ee52b28c08fe064f728891f9d0f557e3b97ae62418e9efc1ab06a", + "0x4e1a6e4b411d6f4beeb3ab0567980aee8895068f33d0f7cf833e4bc4887a1b83", + "0x0b385e4882f89784f506afafe6dd217c6ad9d142ccf58713e27961d25b2c6d0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x41F6e96FA35b6DD35044E171E0f6d163A3A77F53": { + "index": 260, + "amount": "0x1f", + "proof": [ + "0xebfb4eb1dd195e0fdbdde8986664ee536c42b6fbf1a2d81f2fa3acf91c4f2228", + "0x371965ce9f8412c1254b74d648ea441e40a1f09b6e053522ec33c791ed931a3e", + "0xde0c48888840a3a312e45aefc38e872d11021fbfb1c21f69dd0002cc3205c985", + "0xa6bb3b2aef22e52a1e0052bc5777bac639d24ffe832889b483d829660c1bbc1c", + "0x3ac4ae4a4697e2400113df3bd55f84456aff86925f45224af80fd8af20592214", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x423a5635eD36EB13e8CB4522B188645E31B18270": { + "index": 261, + "amount": "0x01", + "proof": [ + "0x5c465dafa33a1648f1c4022cd19a11c61bb52beb9f9d709799a49fae99f44394", + "0xaf8a6b5e57f607d9abff5e1c158cac38e624b13a570e6b2bff0aa98bc384e973", + "0x747693e41d14ef24bc2453cf37d950f88e7f694e4fdd7fef48e85a35e7221968", + "0x4bbd36041ce4968e3db3409953e198317c2cb3811d91f8fc5a98ba5c581d59e5", + "0x140105e3fa17ce783a651f2281967c53a37a748c29442efd53ee24d8a1cff6f5", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x424411F75609375CDbeAD866A8e26615E8281802": { + "index": 262, + "amount": "0x01", + "proof": [ + "0x64348610cea5535e68cc46fc16146ab34e6f742a3ff8b0f506f45b9a9b000f4d", + "0x5844cb72495f4fca3d8067551b02520bc93ecd7253d2b23394cd0848326b47d2", + "0xbb9d492cdff2f5113de60e7e37bb69fd0a5139cac96538ff8fefb20c479105bf", + "0xd2ab54f5e70cde7ed6caa9591ebf0def0ee5d532bfbf38a4473c6ff488c1d82b", + "0xfe7d73c06bd76d1271e4b772b51e13505a812b7c919129debfd7d15fb5014d16", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x42499a97ca2a4df25d2c84BF81bF540e1806625c": { + "index": 263, + "amount": "0x01", + "proof": [ + "0xbf7bfca5aa714be6d81a221c65d1de2b509a0669cd25a9e3fa31cb0f209460cb", + "0x3422bb231d6de7355dee1651cad8e5f95296f28469acb86488dd38766b38c3bd", + "0x069a6e27761402124e6864e9c64d9cfd9c72eb95dfc4360c4741e8871195b5fd", + "0x56b8291821908612de8ad02adfee632a6221773b416cedb3db9fd4f3ba5d30ff", + "0xbd7abdce9ec414fe47ea73146a2131622bdacb914ea6353abee1b0a149275092", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x428700E86c104f4EE8139A69ecDCA09E843F6297": { + "index": 264, + "amount": "0x01", + "proof": [ + "0x30fb215a41c80d9bc973aa29f5a466bd8f9f021680af6d51fc024aad91830958", + "0xcbe695b3a12ae5889bef0525be3bebef1f076ae65086879df4d6138e923e0838", + "0x84397224dcf960c935f9f1d840b696834d2c96bc90fb990bf0e58178e4151092", + "0xb74deb44e6419575dd75ff4fb4c2cc26c6f8bccff72ef47a08f3f27e13f3de40", + "0xd6d09ea62a0a0959d8a1f1cbd849b805597a75fe443bbbc4d5e2555bf8225437", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x42898CEF6a2E62849E1Ac0293E8295659a66be8f": { + "index": 265, + "amount": "0x01", + "proof": [ + "0x9427638dfa60fd088d7a7d89fb2643084de770d255be17649f3bfb98c8554cee", + "0x66672313e9c71cc3d855068625005307693a85d0f5f8f9eddf0637bfff66604d", + "0x65127a802606ae04f5ee9995d26ca3dfc8479c1a808782e60eea9ed7332ee2f2", + "0x6ebf988ef586adc2237357c1611e0a6bf7170af1257d42fb6ef98df1f5052439", + "0xea7c0076ebef0c429d544548828ff19d5600136801cc28845bdfa9990d97a058", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4314D6c3bC17A6Ca9f928AE873a0f800eBec0162": { + "index": 266, + "amount": "0x01", + "proof": [ + "0xb57848376ad82ce7b6408474fecd52499274cca729f980abba59b9073590c448", + "0x5d919e51debf483fa3159cf633ae39a13dfe16d4c45d13c1d4ea5db1dbd217b1", + "0x180e1c5787d5d2cb7c3d1a878f6ef656de538e76593c3a78aa00ca9ac631f7ff", + "0x841ca200e81dde455c9bb72802b7b377b46a9d6779eec08b07e61939b8d43c1b", + "0x529f1b48ab616d4dd60f663753a7779d8ec25952bc8c34df4aa96347bdb0d542", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x433663f1258376f0C7aec8fbC5CC81292e921527": { + "index": 267, + "amount": "0x01", + "proof": [ + "0x9826f7c30cf3a53d246a14936ff71c8f4bfeaef2c76abcd213268b9106e5b690", + "0x7b6add6566648546e7727259f67c2b0b34ed116e3e06da7a83de5761884fb361", + "0x8b0939c5da9a4351dcc809a063b8226bb4eef5b67c44f5015340b9723d256a41", + "0x0209cc90d619e0e5f56081126d2ed4018391f3d9e1dd1238794235d656c68c9b", + "0x62ba7b58fd554e8be295bf9d4baf9eefd0b518ead5cb8bab321717a08160ae0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x448749280160D2126053330fa7a18f893943C455": { + "index": 268, + "amount": "0x01", + "proof": [ + "0x8eabd8397fb65f1c9ebfe09c110a26fd1e332605bfd6e9bc4d4dc6ae67f8b5b5", + "0x80550099b7442c77221445552d3764ecdc31c24959798fb3f8611dcd58a0fbe3", + "0x71bf6e85247d9d89451b82be9a28d64d19071fd3c122e3bcc6db9f470fb854d4", + "0x1a6147d096056583b570a6da72277e79d6ef31519ab9cdbd2d1115f5eeb94a46", + "0xa4e0ebcaa65c6595e7c7f0ffb89992e2b9cb58ac405c81aff220fc4b16ea3b6b", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x449e56bd89bD12faE88515501A6e0CD50d8a0Cbf": { + "index": 269, + "amount": "0x01", + "proof": [ + "0x2361011ecca6ae97397a672d0eca328f6abf555d8d8cc3d9092d29d29ad07a0d", + "0xf95b157a24d2bf26d67af175c56062d0b2a7cfe93a61a4a5dd0070331b260f68", + "0x3f50362d7d3bf3f3f84413a1792917e070daec36794eb4cb6cd5dd3720a2ae19", + "0x7076b49e1dda289a132a67f2f0be7b87522da84294f2302ec4d61300a0630b79", + "0x6665ebe68e892e4e5135c09f9cdc379628aaa60a8ff322ed2ba75fab3b3a9cc0", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x456D9fD81B1b5eE7ccED435366E8032c93c1E04E": { + "index": 270, + "amount": "0x01", + "proof": [ + "0x58d77cebe74d8f30ca4bfb0460f44ee2c6c41b504fdb4b208ebefaa5d5d73f4b", + "0xafa897eb3992378b60da47cce9d93aaf41c389cf48f7bdce168e37187933cdc8", + "0x7c23f4640cb3e1bbc8e7fda85d8fe777fabe673ab4467b36de7f64c25eef8b5f", + "0x5190cb032ba95080f88929faf2eabe8bd342a53206176fd2c3afcbef4577ab71", + "0xf9f105f90db6fe2970fb4e03b35654f9b69375879c783d3f1700e04b2e2f925b", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x45C2700a0b0e84FffFfC74dbe4Ca415BC940F93d": { + "index": 271, + "amount": "0x03", + "proof": [ + "0x3271efb504026a422ca3130db8aa4d575133a2ffa0b05f88e58b9c90ef8b3f18", + "0x6eb82aca8c25ed06e3730d00db4e59f0b68b528127b4c6f35791f94d58ff3d85", + "0x0cb9cf742e620c55a260b746926eab12f725e11bfe56426413054bc3c2d83746", + "0x721f15749c8ad9759a4a7d682519f25f59a5bf74daab7275c00bac9f0ddc323d", + "0xd6d09ea62a0a0959d8a1f1cbd849b805597a75fe443bbbc4d5e2555bf8225437", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x45a5068955fCe555922009B90a8F13bcA8F1547C": { + "index": 272, + "amount": "0x01", + "proof": [ + "0x812dea9ea98cd07977027dd1ef0e0c746de5d5f31c773b50715d3200e157d491", + "0x37443bc3035e1948ecfdca559717df33fdbf1cd1f5a1c6e6beb51703df7fedbc", + "0x37b7ec084798f5f5573cd70b4c713808bfabeec65ce54db1c9c6e87b7642d9e8", + "0x13c4723f9c83e02f8e5d7f08a17afc4776844c18a0189a9fcccd2702d623254a", + "0x891a74fec62a569bdbcb44171dedc1926c5cbe5d803c0c17ff419a861e9ee5b3", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4616d82B7f92692600Dcef35E24926905b265eD6": { + "index": 273, + "amount": "0x19", + "proof": [ + "0x1cfde82fdd1bb7153458160f3f5a3936a5c6043dd57cfa95474c8dbc6bc936a3", + "0x367fe41342aea0d28e1794ed9398d6527b09b14ac4222e064ba29a38f2dd8ab3", + "0x702557a325e5dfca211cf992bed4c7d6442ba5a9ca061e69640a79660a822710", + "0xc2b85fb7fbdedfff6c0826f89cbeff5a93f827eeaec8b16d80424b138de956db", + "0x8e0cc5c13324dce3ab0f042d31a9db04afe0918f70e3f4515f43739791621c97", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x461e76A4fE9f27605d4097A646837c32F1ccc31c": { + "index": 274, + "amount": "0x01", + "proof": [ + "0xf4fc81df6a0aca2416686f145317760eac2a53176f17a01fd0e4239f4785ef1c", + "0x21bfd7cf8be8f35b289a19da561622b0c5a0e8b4d6dd7f83653f275eee8f94d5", + "0xfd0268e900a7c1ec041037fe894fcabcd46c99724b846e568ccd38d01ea0b2e0", + "0x3293f41caca9649b5e2565aa9f9ba63bf7c621850061b0b1b6af864bbfb07389", + "0xed5c942adbfa1d9538c55e89e4a7ff4276f908ac558913b5f43dce424bab8e0a", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x467e20bD74Bbba59dc6C88B3A975fBC381FA2441": { + "index": 275, + "amount": "0x01", + "proof": [ + "0xb51dd3726c9a45ef45da25dac66c18f8ff0f75fd97930487adfa0420d2bb1041", + "0xf255d9f07f49c020c87f9c2e38fd9b6b80ee8838ad6e066424cc604cd7f983af", + "0xb2ed6280151caa17489d6fb4598efd9034b403611c60ec584929ae6e4dd1f3af", + "0x575d2e3f9c311244d801f96a2b4f9fc9666f8793f898d400d71e121add7f872f", + "0x529f1b48ab616d4dd60f663753a7779d8ec25952bc8c34df4aa96347bdb0d542", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x46847c1bE6CCf8CB2510A88896559152AE11e83f": { + "index": 276, + "amount": "0x03", + "proof": [ + "0x3f5c3906c16cbddc3156555014622e7ceffbb082d447c89b3247e503a60a2b27", + "0x7363075fbf25a3fd6c7617804466902fe5d3bdd5e9e32bf273be4f74fbdaa9ab", + "0x8f2a101ee77b78dee9cb982af71dce833445b338ef84d162c17a123bd6df03bd", + "0x2b5ad2a01fbc178584e521e2b2e5c612407bac24dd9bf0c452060b71384720b6", + "0x98ba92b6a1d3418a3c44b684c9f0dc2177f48d3a6b666334d112dacbb6f5acae", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x46de3Ee9e2281B05bC9a9293509c30D4c72448e4": { + "index": 277, + "amount": "0x01", + "proof": [ + "0x0b56185393d6a8af1ed034306f78ac02dacd4cf95eed94c7fe86dd9fef81463a", + "0x4f58d6143f73fb3a2d5821d44aca4ce7cbf936068923669d604272d59f5f005f", + "0xbfc26260b7e6983f90908bd7c4dce14d82539f1d2bdee73c0034e9382a6e10f8", + "0x979cc6c181e08190bb233f0cf5b0f7b487d9aadc675c9326a9af9732d3369d45", + "0x4a36dc66177a8394f6b14fc9adbe4ad7e0cc2dead6acb72d80990e336fef8d45", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4708348B44A39B26f5C50e6fe6587F415f0D266b": { + "index": 278, + "amount": "0x01", + "proof": [ + "0xc030b28d12dd05173dc63b1d3fea5f8ff78e6626e4e53a5bb19302f68db64b97", + "0xa8051827245bd1e0f7083bea29ec26d994ba088cc2f443d4ba44a2ee63434ef2", + "0x069a6e27761402124e6864e9c64d9cfd9c72eb95dfc4360c4741e8871195b5fd", + "0x56b8291821908612de8ad02adfee632a6221773b416cedb3db9fd4f3ba5d30ff", + "0xbd7abdce9ec414fe47ea73146a2131622bdacb914ea6353abee1b0a149275092", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x472c65FbDc6fCE820dE62dB4C85A21C52082E929": { + "index": 279, + "amount": "0x01", + "proof": [ + "0x79d32747d1197c3e50cd6efd95e483fa60a170498d4c009a508b8fb362f2b73e", + "0xe4a4ad90c7bdfdb5a0929ff6be47c865ea09a2dbdddba5424d80eb56931e710e", + "0xc2cd45a5ba91a5bddaf5f5a2e4e6330f109e68b673e248effe74f853055b5f9d", + "0x81cb79cde32d282b43e0e438fe2b6758f17fd2d569d10c780c800d4c492134d6", + "0xe2050f6c95c616c1cfdb04f4b6d0afb5afa0fb464f767c38aba0f07df915a97f", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x478A049c3dc97fCc3BA8a27Adf3D10a883F3F5Fa": { + "index": 280, + "amount": "0x01", + "proof": [ + "0xe4b36e0dd60242076f2c3a58714f5dfd008988eb03a2c4058601303f3c5732c7", + "0x007137c0db88ab5a14704769ff1022f9cdfc635654535e5c778106d6519453c4", + "0x6cfbef2c974896a0631830fdf28466959c8202a21abfd2bb81bcaf67782572e1", + "0x372cbc91aed35f80f87f2c13bba747106e9ece94f8d166e828a5c70b321c5528", + "0x7968b2383e3b914ab3a36580b205f1449b51563630c77871f712e94743e3bf39", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x479Db4DaC1F196bcEB97d52E99C3f4959d93B18B": { + "index": 281, + "amount": "0x01", + "proof": [ + "0x79b825de7ce61d220d2bb8bc32398e66bc0058c4afb48d9d0b22a53d7330c5d0", + "0xe4a4ad90c7bdfdb5a0929ff6be47c865ea09a2dbdddba5424d80eb56931e710e", + "0xc2cd45a5ba91a5bddaf5f5a2e4e6330f109e68b673e248effe74f853055b5f9d", + "0x81cb79cde32d282b43e0e438fe2b6758f17fd2d569d10c780c800d4c492134d6", + "0xe2050f6c95c616c1cfdb04f4b6d0afb5afa0fb464f767c38aba0f07df915a97f", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x47E998E1acca48e6977bb6626c88AD4bA4776028": { + "index": 282, + "amount": "0x02", + "proof": [ + "0x0e2f4bd8ff3be975a8ae148ff373a4b9695aef2fc3ac77e1199978adeea1170a", + "0x34b76b90fde9e801828eaecf666db2619ed6ad0026e5af3e73f341f2f30365f3", + "0xcef2c8add76582c68d291ef22132fc17c35fa5b70f010e8c9388f4a93bba288f", + "0x037fa491e4b6fc74b9dccf3175d28aed9f5dacdb75dd0fc8e1154a0704619620", + "0x4bab2069d20a5d1d2f5ebdb61803a57609b7709eca9e925e31a7d14434af1326", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x480730d281b4739Da8a760c26D4a10f0cA61B8ac": { + "index": 283, + "amount": "0x02", + "proof": [ + "0x883ae49abc6b4e4ed15d133bb882fb6fb808e0aaa4c04475d370845beb70a528", + "0x862b72ffc0bfa563cacf0989fb22d5df29d68045f7ed433db932a0e34fb5da17", + "0x33a345c594edaf8461f1610783c243a81449ec27186711a2d756f2e892ac478b", + "0x16f452fd982f0f4e3fe20a4b2fdefc9226e8d1db4c0b29793acf9535b6c65c66", + "0xe4fc54838dec16cd3ac94713f191dc41ac7f5e070180d4843c9aaaf9c71ce29f", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x482c7F6217292d40452b68897c8265d49f20A511": { + "index": 284, + "amount": "0x02", + "proof": [ + "0xe3e9851fe89bba085807017bdd2ff1c5f3a6a9b093f723c70b4baa42b49b1ddb", + "0xf2be2b502be1c1d29aa15870257bffc304001f94c2e1c56290ebe86e74cbfb92", + "0x567f8f869bafb76cdb1e5c86291783cf3bb6dc604902df31bd0f815d38e36ed9", + "0x1bd24f0c1d9a337a197e1feb80905be5821f1e64457aba030d18aca78646a08c", + "0x7968b2383e3b914ab3a36580b205f1449b51563630c77871f712e94743e3bf39", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x483846f18E7662445575FFd4186660aF80834C5B": { + "index": 285, + "amount": "0x01", + "proof": [ + "0xe651030e6529b3fabbe55bdeaea95ee48b01d7a8cf8e9daca257d5f25f4e6296", + "0xb689c19b52f895a38750b1f653e015e69c3b78cdc452e8bbfa5dbe7bde5d3f43", + "0x46620257535f86b53d54bacefde5f7e5ba7d4ccaf37a80ee488adfb5afabf427", + "0x46903c3e0f26b709802c8a2743505337728e1f805b4f936ec91df4b3f43fcdb9", + "0x7a545b345b30e441bb780a4fca731a87b1e941b75518a9983a312194a9e7bd46", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4839460F05b2a8fC1b615e0523EbC46eFba75420": { + "index": 286, + "amount": "0x01", + "proof": [ + "0x63fe8f2c7284938956bb03ecdd25a2c9983c7986f8ccf19e223f1324e85b171d", + "0x75744793836c7a312b9c37404505990c5c4256d38b41d7cda64bb1c9b716aa33", + "0xbb9d492cdff2f5113de60e7e37bb69fd0a5139cac96538ff8fefb20c479105bf", + "0xd2ab54f5e70cde7ed6caa9591ebf0def0ee5d532bfbf38a4473c6ff488c1d82b", + "0xfe7d73c06bd76d1271e4b772b51e13505a812b7c919129debfd7d15fb5014d16", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x484AdfdA2B22B76109087bFfFcB1D120F8e045A9": { + "index": 287, + "amount": "0x01", + "proof": [ + "0x3c8d8348e9f92dc2be0b38b7e27d00fdb432306fa6902042291321c6f8243ef5", + "0x5982477f9dabd22fa394e30cfd71211bbabf93aae7cdc3bc365fa560eb10f929", + "0x7cad92e269fd399bb88a0e39909864292b3fbcd2d596ee1b941883a15cbe467e", + "0xaf86f597317f3202fff25068896658613bc0cbf9d7a66fd51e55c97f2358b8ee", + "0xb5bb98883f5ea232108866e1400cd4067f34fc2d70605fd2c67051a6095af7f8", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4890ae58845CEE70b04f7b54dD2d4BbFd8b697D4": { + "index": 288, + "amount": "0x01", + "proof": [ + "0xe3031b1040de109605b70d98778141b6b1a549a2627a210f857224faf24497f9", + "0x9fc3007c8b07f92ed58d487e689454caa871f76c502f3205f64cb5b42602e66c", + "0xe245c0cfce194010f5d1ba4d1e2acebcbce7ee3beb09abd2da7ac09a58a6c76a", + "0x1bd24f0c1d9a337a197e1feb80905be5821f1e64457aba030d18aca78646a08c", + "0x7968b2383e3b914ab3a36580b205f1449b51563630c77871f712e94743e3bf39", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x49468F702436d1E590895fFA7155bCD393ce52aE": { + "index": 289, + "amount": "0x02", + "proof": [ + "0xd526023d74af56b5318e937ab7519962e84cc77699b8a8d5dcdfc436d4b85f30", + "0x20c42b90e3c72ff03126a70d7fe423736d587aa60a80686081b6b0aada676c69", + "0xcf4b0a8be134a824cf199271e2b48b713aa95add1e71d8db714ef711f58a2265", + "0x295b1cb76b1ce79cd1280bb1130a4264534288edb4c264d45d4ab36dd72b36ca", + "0x7e73f337249898d15604f7c330d90e36da04007407404a4b4276d5fe3083b929", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4968B9b71fC5238F75939299a70DC03ba7002377": { + "index": 290, + "amount": "0x01", + "proof": [ + "0x69d0c6a8eb6a67119fca2d2f9f37adeda2d28b40ecce142d1f3fd81727965ab9", + "0x7e8e084cbbcf1e65803b8cdf743917a79bbfac97e7dc638fd22cd422862a9c03", + "0x7745a5c31086c993a46c6a7ae6582a5b091fbe9bb854ab5d75a56c332e82c2d0", + "0x2b5637be96c5474a58c9ffbe0539171817312be59bc8b7c71e23242dd20afa66", + "0x245190f95f5e09d43d1da7e9757fa066be1942b52f7e4962cbbe6a5f2e0981bc", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4985496569C9a5CcF8B612cB40ba8f4B94A44534": { + "index": 291, + "amount": "0x01", + "proof": [ + "0xba637ad23e47ee264e33cc5f0fe4fb1aca2ac1581b148f7fb53b195ca3b15cdc", + "0x54bca3cee45869ce5e39ed9e4a737f77f180f84015517ac17ca1b667f9b46a0f", + "0x99c1bfc876cf5982f012ca12995034d51b946a2ba47a506495fe65b361451d8d", + "0x6a8275b9d29aafc6358bf9f174b96a6a2561ace2c21d2edeb2a14975f0d9b0c1", + "0x83e262e483a6f2ff9f4df14637dbbdfeddf0c6b0b4ca462c4375d29a3521e052", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x49D2db5F6C17a5A2894f52125048aAA988850009": { + "index": 292, + "amount": "0x01", + "proof": [ + "0xb099e4b04039b41589b7263d72e04ee513f8091c0eba1597b9e94b3d55598827", + "0x09aa1457f64cf20167615ce9721d6ca4816d7022d04b6fec48cfaff3742124be", + "0x861b6a9fa4a9a59b3537e811eda798dcbe95d882461afb4d7e9391162a287d45", + "0x49f4781ffbed71f831627c02425eed106f4714988055f5e0978de46ca35b3ae0", + "0x72373ecc225af245878bc638c49c8901db1430b7210a3008231acc8f8118d2e0", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x49D599E73e16572cf9E65266da00D12c64d70F83": { + "index": 293, + "amount": "0x01", + "proof": [ + "0x1b276be77deb260602af56d9fddb7f71ff67c4fe02eb15be3240775a9553ffa1", + "0xea005bf24d9b0efdde9111776e63d08196407f392930ea92268d65f6d54ed1f1", + "0xfa32f82efe11ffd2403c559b1ec3e3004c40156be97edaa5050d9a8a56426e05", + "0x6b5b18bfb5c7b8de5b52219b51a21b6ff6e22d5cd7a147d521bbfac13cd7f7ac", + "0x93994074bdd819d668a79fc2c79be23cb074a679cd3fe03940945d4c6f9fa9b3", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x49d33037Fb37bd8f4A4817BF425540c2D5E4d30E": { + "index": 294, + "amount": "0x01", + "proof": [ + "0x35256e977ccddbf67c8aecda3633c33786143375fc0f7c0948392890710d0f94", + "0x6b40523ff477c4390138063430fea98fa0ba7f09d4db26469dc279d084fe0ed0", + "0x82aad805335c91e7011dd8396f6c0293becb55858091bc89dd18a07093b2dd7b", + "0xedd365a7e73c5a47a076899344b760df86cdab5eb6566dcce5b550be9bbb5324", + "0x963cc7ad3f8f0ded379d05906b629df8cc616633784013c90731955d0b0736d8", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4A7998DF2Cd16815271bb6b7d3aE7EB30f50a73a": { + "index": 295, + "amount": "0x01", + "proof": [ + "0x5e2699bf54691220b8c0cb62d41e498cc29bf635bea4c1a3a500603b295a0bb8", + "0x92b972a819593b4f9ee01ab9472121e0662188640a60977985e4a7d716563b63", + "0xc8194a78aa356d611f6bbcbe346bc7a996ca8addbd55a10d6fe06d7320b2f492", + "0x4bbd36041ce4968e3db3409953e198317c2cb3811d91f8fc5a98ba5c581d59e5", + "0x140105e3fa17ce783a651f2281967c53a37a748c29442efd53ee24d8a1cff6f5", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4B78e19f34bDB0B2AE16Ad9888Ae1E3cA5998D2c": { + "index": 296, + "amount": "0x01", + "proof": [ + "0x8377e311a1805965d18b7391be2619fc96fc3351bf8355df7b9d043c4fe02d18", + "0xc0f3feeaa2e0c1f96f57682c3681c383d91522fc2d625de91138dc693b4ce03a", + "0xc1327fd5c0d304512764186ee58b613917e50f9a632100c058142561a8ca2611", + "0x02cef8ccb3c7906e41a7ed9d223c95f320f2860a3d5a5dc4598d02362970eeec", + "0x9dda7d74fd49fdacbeb3afcd37c878516159fe4b594e491ff7ecbc80fd8d6808", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4C1CAA47D4c7a6971D19Ffab7e82C206D9dd55AF": { + "index": 297, + "amount": "0x01", + "proof": [ + "0xd74d67a0448ac0fff1faff8ac8fc067971583ee20134c43a62ac5578cd9259ea", + "0x731d6d17fb186464deb9cc1244045b51347f9522b715e17c628f1418489278e2", + "0xc38008defe51c0239555c45ec16a876cbbdd254e08722230d0d69a1db6d54953", + "0xd382b6f12ac3804a083f91e50c5b4faff460036b8bbe9e3c74b4468370b346f2", + "0x57a1600e1002b648fc38956dc1d2f34be5ee3f6cf170c73bd27c43b2a01e45db", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4C956623424394c5Dc4fd71F04BB28EE117b496F": { + "index": 298, + "amount": "0x03", + "proof": [ + "0xe74730df6cc0710d592de179c37a998f7a58cf8deb7e4bf0bf31952b413d6e7f", + "0x72635e189dab9f4fd2eef5f000bce9dc96019fa030df20d034be4d0fe69ac086", + "0x1a4492318b217e4bf203e535736df5d575d869a4d6eed45535f3a69b1bc59f98", + "0x6029ed468a13d48547faf514f4c29ae1fc65bcefd1ecd17c26aeef29ec044356", + "0x7a545b345b30e441bb780a4fca731a87b1e941b75518a9983a312194a9e7bd46", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4CAe5BED586f6E73Ae54EbD40A4AC4eD2c477C34": { + "index": 299, + "amount": "0x01", + "proof": [ + "0x9fd8ec1c935dca6cfbca8bba6d172cb10c6ec19999768a03964e7f15b7a96322", + "0xdce185db93ea364b2cbd2fa79a267a698149ae21d035953168d02bc6d76332b4", + "0xed1fedc58d0a592f61e92d2a8ab04ba2c92cccb2e77a5caf9f83f2e4f14db538", + "0x4fa24b2d1635e25dea497fe90d30db11d577f752b726d47caf1b4952bdf93c96", + "0xc36c52715656389b2693c145860adf3b1f3d4d24a139850b1fa5f2236456376e", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4DAe4864681deA2c5b8CF9b29a9EF55B28e29fc0": { + "index": 300, + "amount": "0x01", + "proof": [ + "0x02ea2f9b8d2aef752a86269e8a6101608c5111da2053ecf7a8ff13be7a251e82", + "0x45f99d5aba828408aa25cab921c5b8d1eea54a12e7257217bec57eaf987e3243", + "0xa4fdfb9e13a8933dacaef17334dedd3721c4ff7bf3930be481e987c2b288d052", + "0x694db95f2efeaf59bc0b92d1736ca407eeca00ef7ad545f2c27ec99a059b74f0", + "0x9be1155992502d2b75a54fc5b2a41d663a86f7d329faea1befa0e24965b01a56", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4DbE965AbCb9eBc4c6E9d95aEb631e5B58E70d5b": { + "index": 301, + "amount": "0x05", + "proof": [ + "0xaa2a1f5ea420f3ce4b5c42c10b797aba536e63450c0d7d695ca347367102ef15", + "0xe3cf7ff7415e2a99867984e1688a54275b875cebca9be08e1914bc2a1b2ac98f", + "0xfdae30148a910307864676cc680c0e41bb79c5b095c34c725c285354af84e7d9", + "0x68141ce9c9d3196b1db61f6e6c902aa8569304d1613ec750ac0ffed8af2bb113", + "0x32636a5315ca425c602832f925f24426ea5aec9939c73d1b2a6fcdace85ecae8", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4E32EBe322b4743aDc6c27f8B66fCD4D539F2045": { + "index": 302, + "amount": "0x01", + "proof": [ + "0xffde5e1c55046f2b8fe662b648d27c14552cc68e5b25c874532487d8ee137b1c", + "0xfff736e6cf8464e999e5be3671aecd92ac16c016efcab51e32f3df364a8e73af", + "0xb401b90c19bb8b2496a8fd979f240a923c20b7f409845d553fd2ad67fe7ed89d", + "0xa0af5121b49fc7ea34ad1f4c8308fd6e51803abadb614d1f15f8c87bf9fe29bd", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x4E66C4FDc45A05a3df9b0b868288b878EF94df67": { + "index": 303, + "amount": "0x01", + "proof": [ + "0xee50b7c4f654dd516bd4e9200108d5a8758f0a65b03b9944394deee1680c1383", + "0xa321537092d4c7524a40ba1944dc98d90da4a775200897b7d3cfc79f7a8d9e0f", + "0x87f9ab6301cfcfa1972d69c933df7d435beb9f98f524bff8460141fe4ae2233f", + "0x88222db835a579969caf99eebc6d7f986a78bc44f46b794a4319d01749c83a2e", + "0x6e496426985c92b04963088da4856230c781a975dbb5ce2d8eed77e7d2d4b58e", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4E9B67c36c904F0d1a700cFc70A311d5A5852E14": { + "index": 304, + "amount": "0x01", + "proof": [ + "0x4d9186578b2f82ae791669e3debff9c77652c3d1c712ad7b01d5289b9d3b1df3", + "0x4c3af5cb9ce3e2a2b30cee148ab664e24bf31dbc4a45bf1573d7f262dc48617e", + "0xc9b824e8443131ec044d11642590dda66ca265300328d8dbe4689483b562b29e", + "0xf94cc4240e18301aa3e9325f55d6ec2e2e84a181037fd49b69a29a1aedce082c", + "0x43f59a603c2458850547e5a84d47e61be843b4a3c814303ed1b52e1e4d37a1b5", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4Ef8E913e1A182984256EAbB5DebCf09D2AaddaC": { + "index": 305, + "amount": "0x01", + "proof": [ + "0x2a4f430599ecc1ca16cbb0cda2ca27568773efe3cf20e5a2816e89fa54df31d1", + "0x2b9ac8a58419cd916c053d21623bcce9944655930b577d24647136c40eac20b1", + "0x76ac0e61f5fb8527ae23175c183589d51da559dacc49211473b64d81eabda65c", + "0x36710d40c48dd22c4c23311fe2998a569fb56756df4d8eda7bf12408489aed56", + "0xa43a1be4a3c4bbd4e28425f3172d3522b7e954d7cf0fc72a26d8ba7bea25f197", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4F7b201294EDf99D707BB138Db3b5bb2091D6845": { + "index": 306, + "amount": "0x05", + "proof": [ + "0xe8fc5ef40d26b3f1e2287b16e0086240f0a26a86ebcae651ba97615afa822481", + "0x2f192b17ef358123b3875dbf7d351a6e43c9a6355261b9b9458df4b2564259d2", + "0x4c4c1774cd1fa5133abdc712ac7336a6ec726c09e58e3dacc97192f36b62378f", + "0xa26acb471e2d600bf69b92e87438242435f7a1ed8e490016e5305ddbcea64c2c", + "0x3ac4ae4a4697e2400113df3bd55f84456aff86925f45224af80fd8af20592214", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4aDBf598Af825B14DB8C0c8fb4B3eD8b898e6364": { + "index": 307, + "amount": "0x01", + "proof": [ + "0xbb0c322ad5c543ed8e628ce21129a613d334d6572ff71a490988bc1c75fe5943", + "0x09dacaccfeaec0ca86146e5b4dd908ef816bc3cf613f1e55bdda1a89b39d301e", + "0x676a4419b79ede64c5f134c84c12f5fa1724be03db300147c6ce62c8a2747911", + "0xdb334b0b3ac11eef22a51af7bc46c7a633665d404c70629bf6c429ed0b8d1ae6", + "0xcf36a9c08620752945fec2c3138a9b0eaede19862d6c5cb3c0489e6ab3a443d3", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4b463a48C299A0D8C21708e800E14b8FE4992e6c": { + "index": 308, + "amount": "0x01", + "proof": [ + "0xe9e874fa1011486f0330aaf4179360ed93970ba873e04fe3b2beaf6d5e3d8115", + "0xeaf8e0fcb535b52d11d83081a07860de2138906e55058295490b5bc3dffa9738", + "0x63334732b85124845e0586f19e798fe9b282285142d8b7ff24128a88ae98de7b", + "0xa26acb471e2d600bf69b92e87438242435f7a1ed8e490016e5305ddbcea64c2c", + "0x3ac4ae4a4697e2400113df3bd55f84456aff86925f45224af80fd8af20592214", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4bD120e887Cc82285AFF8408DC208eD32B132Bb3": { + "index": 309, + "amount": "0x01", + "proof": [ + "0x3e7521c16a81293ddd6bd0969a5856320d75a5e031280123ce4f3702ad0f89c5", + "0xb6e6281b7df56810176d16d01e79bd305e47c7b0e7f749d0dc6a1423c144bf03", + "0xbf879dd33cf8e5652f6897331b6d0be05a0d269a02431e4143f50adfeec86fb8", + "0x2b5ad2a01fbc178584e521e2b2e5c612407bac24dd9bf0c452060b71384720b6", + "0x98ba92b6a1d3418a3c44b684c9f0dc2177f48d3a6b666334d112dacbb6f5acae", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4bEc0c9b41343773C6a36e8f8136BF06019D00A5": { + "index": 310, + "amount": "0x01", + "proof": [ + "0xcef8bcad5645d22b3b924274d84ba7a2cae1eeb5fe3d575ac975df12d39c7346", + "0x3dfdd67bd589ff08ccdc2e53bdd42b21a0c8811622386bda99933b059d28ed75", + "0x13ea6405c1facec923a61440b64632ddc4351c954b3e5915100fe378a0664a58", + "0xcea68af505202af90a0679269376e373d9ceca250970bcb6953e0f30f5dcfc7d", + "0x85ada07677b521b0dd2e0d60f51f92f7b1217f46e36379a5afa5a74fd5c87a5a", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4be707DF3D526f523866510Cf5250BEd7674375A": { + "index": 311, + "amount": "0x01", + "proof": [ + "0x680a98a35665a285cab64904336d5c1047879f746a893bd81fcd934b94cd169b", + "0x205f0c0ca16f55170c0661751a1e5df6422be81517d44622e0cc3498177d4687", + "0x12739444750a786d216e7862d022a412d833ffcaf4cf4f6b1414e14f4ff27db5", + "0x5fee000564bb97bedb499d3b5c01f147f4e4ad76f5f6443565804721f95dcda3", + "0x245190f95f5e09d43d1da7e9757fa066be1942b52f7e4962cbbe6a5f2e0981bc", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4c0DC41E82a9da9162bE29B379687C648AEe4388": { + "index": 312, + "amount": "0x01", + "proof": [ + "0x802d7b2d386953ac0143b361cb56d859c62e4741c5c2a6b79c47065d3b1c0282", + "0xda7a08361527692b975ddf8c69bdb8901089049f8d8ec813655ab8f38559ed82", + "0x5ada5cfebfc9093074af257daae2c61d27b871598065cd29bb9a6790903c5c37", + "0x138bee476bd8ce498e2985571c0fd10b392ab6afd8c1bc3ddfe5859f552044ff", + "0x891a74fec62a569bdbcb44171dedc1926c5cbe5d803c0c17ff419a861e9ee5b3", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4c1bcC8F570e9F98Fab0eAE6b14F4df6E90CB8F7": { + "index": 313, + "amount": "0x01", + "proof": [ + "0xaff75deed82907735aa56f51b9fa18c140cbc18ed627a93fd90d5ac581458e96", + "0x8bd3f7ec81a7ffadad31481a11e4fa679bb5140c3c9205a799eb0579ed1e5817", + "0x9bce549829c21177902c8beec5ddfffba1cacca3b9853a79de10a2978d74fe13", + "0x577f81e56558cea5cd9d5160218e718fdbd9b124f0dd5499c3e14a238415b645", + "0x72373ecc225af245878bc638c49c8901db1430b7210a3008231acc8f8118d2e0", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4c5cFC9D7417572E604f3449cA22A3BCC02ad558": { + "index": 314, + "amount": "0x01", + "proof": [ + "0x8ca3c32ae955ba7199700b78ffc92c906372e1e4b8913caaeae92bc91f654e24", + "0x76ac387e248077a9d14055824f94933207c3417fb65ad9be71b47383d2dd8ac9", + "0xe1eadcfc59183c7853b885552d4ed0af4a4691e55309e8d127f67718d28a68db", + "0xe04deda4b0f0ea0bda4320a7f8e55700dc470bdcfba68775214ca25f30ccc348", + "0x8fbc13f50b0f82a781945a74ddd5c5abde0b4a8983852c66ecda77a68df50722", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4d65151cD05f43F9aCbEdBe4182b02445A93D7CF": { + "index": 315, + "amount": "0x01", + "proof": [ + "0x70d1939954d20fab8369402b552af9121dd4a32b9e899cf922c5c8e9792b9b31", + "0xa2dc3924d587b21d1726f4d92731dcaa995e9165f4386e4af38be93bbffba08e", + "0x8be860722f0612e38d1e8acd51cfab2cbcb140685965dff7de6f05ef66a544e5", + "0xfe79a6356c4cd9282dab3a598f859bdcecd04fcb915a9edd66380a81697af3bf", + "0x7abccb934a7f719fa80b9a5d3157e99d45ee17a391abf85d4f60839dbf3769cd", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4d72a61647afdECd607dF768F08e0bDBF4AbC85a": { + "index": 316, + "amount": "0x01", + "proof": [ + "0x8575ff55687b31c6e37e087c02572837ce89fbc72d50d7363d917abee8f8fbe1", + "0x199abc3952348c45f42cff88fef339c1f9b3ad7bca996eaf4d0c3fda33ff3fe9", + "0x6bd30df1554552e0e9b030df3da576a8a2771bdb0e518021ef2f17fad6b2fe6a", + "0xdb5507911490bc1574fb624fe6bd570cc6afcd947118f0c9c38fe90a00ee8b29", + "0x9dda7d74fd49fdacbeb3afcd37c878516159fe4b594e491ff7ecbc80fd8d6808", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4e8EF2e11A8056A75b0aAc2d313202Bea4016eB0": { + "index": 317, + "amount": "0x01", + "proof": [ + "0x135e0e24cee6c3502fcf391c0f47963fc2f99ed935f4293d16f7a83e14ad2441", + "0x3cefdc6cffe7478184d2ea755a7568ec03d8e12362a5cad4206b454a8c75257e", + "0x5517cea35fc2ef88c454c0abde49cce58c62d4d8057d3493875f1024ae1a58fe", + "0xdcab737bf32fe2edc99f37725a5c46b3f4c2b142298388f08a1bc983981697d3", + "0x6431c24d3d46ea6b0d1959c0de03265dc474d3e67139f2bedca26b5aab0c0c5b", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4eBf55228579DF2EB6Ba59DED18c13f3891f39fE": { + "index": 318, + "amount": "0x01", + "proof": [ + "0xcd544ba406c6489e12e147a6efe78bd56b84c2a7be9a74983ea752b249a3d390", + "0x365d7d83f25aea48a71a7a436d343267244129ba2c8b087bdc3adb272846604c", + "0xe8a6478d83d6e44010f2e45c5e73a005e8a6798d300da5af9760a1a7319a59f2", + "0xef33e9da5226ecbab5796a616b47d5f4223c729722fba46a5cf043b7bdc381ce", + "0x2e78635a0ed4a14dadd872d564c5dd2afc4f21b0307932d27d4471c48082b7f3", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x4f4758914ea2C70D869fFCed0eA5A81Eac1D879b": { + "index": 319, + "amount": "0x05", + "proof": [ + "0x232909d5c2501ffddc7f1d21d4e637ec38f87112f4b7d382a56c38e10a28f7f0", + "0x34d5730d425d1f6bf8ca2fb63a0b6942edcec42c19183c4f2a43b7368fbb5cd6", + "0x3f50362d7d3bf3f3f84413a1792917e070daec36794eb4cb6cd5dd3720a2ae19", + "0x7076b49e1dda289a132a67f2f0be7b87522da84294f2302ec4d61300a0630b79", + "0x6665ebe68e892e4e5135c09f9cdc379628aaa60a8ff322ed2ba75fab3b3a9cc0", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x50Ad452DD4434E547c88262a00f08517743B4c02": { + "index": 320, + "amount": "0x01", + "proof": [ + "0x5315e64ca5e923f93a080ce23f9252262ac6306950498c7eec326fef13771996", + "0x336e04416f4d2dd04036b5afd331d9f724e2aec654ce7a8d813515b413e9225f", + "0xa21540ccaf175cc840a18d1224f8d3683c9d069bd5ea2c3bdcc7b37a61191f98", + "0x7a5397945a42b48bf4e4ee9c21f985e9d9ccf82e57fdb87dc2e6046ed345d7ec", + "0x5477c93aa7e191fd8f76e1976387fc82460220dfdcee87f9ba8926f4e0ddf45c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x50F27CdB650879A41fb07038bF2B818845c20e17": { + "index": 321, + "amount": "0x02", + "proof": [ + "0x89d22365f957f1afc65398d1ee1e95c8a14421d62cead1e319b048c8aca00abc", + "0x5c3bf72d1c17d5703c71b8ce6c9c73e08ed23562c707cfa92268545dfedd55a8", + "0xaf004a51521001e3a2257071c94b92bf3ca21deaabe3c3482b0ee37b2ab2fbbe", + "0x0c15cd0e5fb4411c59b182f983d4322f33d3be8bd2c5425b705021fa316a402d", + "0xe4fc54838dec16cd3ac94713f191dc41ac7f5e070180d4843c9aaaf9c71ce29f", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x50f12171C76C8E78B37170b2fa483B9d18F4Dc6e": { + "index": 322, + "amount": "0x01", + "proof": [ + "0x6f5c3fe0e8291c4a8ec242087c68121f75a9434fcf818ec3a88731c6701660e4", + "0x29631c831019ea827b2fd230493a9694459e7a5f510754332b5dbf2b4b2ed3b8", + "0xca0621c350e7f4c10764a38942c3df34cc262e74fd6d9d2f4434fbf0443dbea1", + "0x7c0de9d8e837704a5bbfc4993fa9b20e3f698f1b885a0b593d018e35bb790c61", + "0x1be60ce906d0d73954b2e1f2747ea1c9a23db0ad9345fa6801c551f1a39fa5ab", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x514314904EA85Ad3eF6df1d1030537453a4310A4": { + "index": 323, + "amount": "0x01", + "proof": [ + "0x9018ab78fb4f8ad3aef3ac60af0632b9e79c2f0ae3f32720fcf9a5e122a80ace", + "0x891a6ab73a892bb29b6aca07841d16d6180b4f12ce3b74b3add5e926d04aaadf", + "0xef1d4406d91ca16cad3c2ae3fcec81605fde6f08b915d8de8717673e99c1746a", + "0x1a6147d096056583b570a6da72277e79d6ef31519ab9cdbd2d1115f5eeb94a46", + "0xa4e0ebcaa65c6595e7c7f0ffb89992e2b9cb58ac405c81aff220fc4b16ea3b6b", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x51539c1e1e62b510Ba565E3D1aCC32Ab530F0471": { + "index": 324, + "amount": "0x01", + "proof": [ + "0xdaed992b0b4b81c6deb951cf82f545ffd9fbee0724040bd63a6dc6a4dae7ec6e", + "0xef33961067e67291172ee5009aaca63fd8997b0fe7859746ead185acd9e89cfc", + "0x80779d16ab6f1d2f1a5df7a70354491bac8b36d2f137ab7274b9fa248eb57487", + "0x3cc86f19d7ab5abe54cb84f21d19174b3158c792e08130d0d4f813b822ec451c", + "0xd8ba0ec6899e7ab5afd6774d7465b2ebc52e677b805f74deb131b1b243bae70a", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x51c60c3cd234430A238f33559D8d4aA646741820": { + "index": 325, + "amount": "0x01", + "proof": [ + "0x0f737ede958d0bd533fa10328c817044972895bf1e7bd3e07c9970624adaa6d5", + "0xa5d3a666e6b30869d8f3e419c5cb5209ea59f83374b005af111715d233915de9", + "0x58fc0f95394c3d85af39af4ef41b7b5365fdab351fc36f9bff4ff8482e4ecce6", + "0x2eb27b26c39f3350831b9042b1a0e6295ae6da1b11f07f10b4a83da8dc66b536", + "0x4bab2069d20a5d1d2f5ebdb61803a57609b7709eca9e925e31a7d14434af1326", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5221E4a2e1faCe94Bf61d7b6D8534D66D633bd01": { + "index": 326, + "amount": "0x02", + "proof": [ + "0x043e1e938cab9044b85bbc80ec6d279c15e243ca2608df58f6bd926867ced641", + "0x81c21b814aeebf34dae43431dec6fc8fa7d9b823553bcc000812a76486259649", + "0xce425cf8478bb52919447ea20d7a544c17358dee3ce6498f1cae3e3f0f173aec", + "0xf48849b03cf9b334d4dc7a6911b922272cb1a72dc4223db35fa6c699461d5f16", + "0xb18758ddf98cdeec3d020c2379717281f5c0fa0133be7d006f7f753c756da43e", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x52D4d46E28dc72b1CEf2Cb8eb5eC75Dd12BC4dF3": { + "index": 327, + "amount": "0x01", + "proof": [ + "0xbe6365b1b25b6972a2885ee68bfb6d5f5674125e5b6393b03c9424f1c12d0679", + "0x414bbbb883d903a8f82d7965dacc34f2cf3fd42e7c76c5d9433f028fb5515d8a", + "0x81438df7a27c7be027c254bdd75d2f0fd663816eed20147a4ff92559013874ae", + "0xde546e8389f64cf158f6546ecf18f3c473b0c5660810c1eba849db699f2c4883", + "0xbd7abdce9ec414fe47ea73146a2131622bdacb914ea6353abee1b0a149275092", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x52F6F62B124195a78F9304C83473f932c502195E": { + "index": 328, + "amount": "0x01", + "proof": [ + "0xab0efb88de3be183ae48ee27e5fd7aaf08c478730671927dcd2f038dbb4fe084", + "0xa15e189886ddcb5c066beb8935e0591ef17452ba42bc2af450f5eef9545795b5", + "0x8d09decc88251c44f7a49a4b85d4449eb023b2742a6cd38b9c5de1b9936589c6", + "0xd7f4836e54488e91267fda42072073873c17b5d47a5a1cb5374c07d89c92ff21", + "0x32636a5315ca425c602832f925f24426ea5aec9939c73d1b2a6fcdace85ecae8", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x53838F753505018BD929885363D53A2AC892E0F9": { + "index": 329, + "amount": "0x05", + "proof": [ + "0x6132f3216db0462192b41ce8c30214db1c7a186535a88a6f339c2981dda3d27b", + "0x29efb108fbae46c2d17bcbd3e95fd3a32a70c89bee19d6ffcc8f682855d6edac", + "0x0d0aad0eac33ef90a443928440ec8982d70996c767cc18a515c491ce4412a27e", + "0xd1cbda0650121cdf56f6e9fac417e3ddbcea9364da64e4e29c3e50fa61aa56bf", + "0xdfdb156cb5d2b90a5253163570fe08739b17ab3fc383c79eb041c1d1a667fe84", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5389477e84b4B7e693940a135BF0C1928d232840": { + "index": 330, + "amount": "0x01", + "proof": [ + "0x90acd513ab453c10f43ce7f93157829aea34bf6dd16d801a4cd54ed0e7ae467f", + "0x8c6873c2a888fc4c2a07af4dab22058285b817378603ff3ca6a025998eaeaaa4", + "0xe08ba4e5ddf5c7b3ab07672afdf53c0a975a407af8a156203f47781efabe266e", + "0x0a650a18b5dc7e14051f590d1612c3614c677cc931a3bd72443efdbdec9b6fb6", + "0xa4e0ebcaa65c6595e7c7f0ffb89992e2b9cb58ac405c81aff220fc4b16ea3b6b", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x53D8adae895d92c4e5a190356A2eae74A75ef774": { + "index": 331, + "amount": "0x01", + "proof": [ + "0x9a15379e88a8cb2fc3d45938000674b2b488e29d70e8c66e534a7ba842cbd02c", + "0x980ad86e05c35240bd248bd776953d4ecc33730b9e47830fc99b866ae044f726", + "0x265c302052174e496eaf88164e054aa106d99c29ee696e11b9c7df66fbb1a01c", + "0x0209cc90d619e0e5f56081126d2ed4018391f3d9e1dd1238794235d656c68c9b", + "0x62ba7b58fd554e8be295bf9d4baf9eefd0b518ead5cb8bab321717a08160ae0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x53aFEB120eDCE5D778caB7DE76d34F5Fcd92C7d0": { + "index": 332, + "amount": "0x01", + "proof": [ + "0xc2cd8998d57736c8715a0c73362ede77bd25e80d3bb40cfc9976110a786fb80f", + "0x10ee531aaddb92e26719ef6bed1a146b451fff0574746ae9ed53adebc2b2e467", + "0x31c626a13fd36bf9222fabb7f884eb7f6bbc58d99a42ea76aaf069282a6bfa97", + "0x65c5caf7f221e805a211309d005cab013498255a9343870184292835ae911371", + "0xcf22c1d43a94c7c6471efe1209a3b103ec0a9836b6c11fe8d2e98d18b2e9cb36", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5444C3377842568E5cCd77Df6F8b26C2c2eF3878": { + "index": 333, + "amount": "0x01", + "proof": [ + "0xdc1275f967efcd6c53d18ec1f1466fdee4a38dcf310ee657253cf0d9539a8299", + "0x030497abca81e76b8f6fac09dbb62f9c6dccc0fbb9d8c36885fb6b494eab57c6", + "0x0e3f11231eabc58db4785530d98a166f67094f59b7d8140612cd5b4356e4db3d", + "0xc84beec6531767197744c2106caed4823936b1ceed7475952444acf832b57446", + "0xd8ba0ec6899e7ab5afd6774d7465b2ebc52e677b805f74deb131b1b243bae70a", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x545Be67ED1A0e1e4718655935bCDf5665b2718f5": { + "index": 334, + "amount": "0x01", + "proof": [ + "0x26cef08c9d79ea2f0b776d79ce355af5427b7fe0ee9ff58d1a826c226c028da2", + "0x3b55f29e6b8a42379cd8e8306f4d52325d77ad3e3654473713dc048ecdcdf301", + "0x937839ce24bd273187bcd1af0328a690c712a30e57af8e26d0ff2c9c1c709da2", + "0x1ff461854683a34317216055e65b6637346912d1739163d25c1a0b0a5f15c25d", + "0xe29ba79106b7b14c14912bb5fba509f27997ddbe5a7ebc941fa75e3475af4aef", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5477729b43A0A9beA8c41367C62e7864123B57d8": { + "index": 335, + "amount": "0x0a", + "proof": [ + "0x2d3ff56b2718737c43d80479d2b87c60ccf5f5d5556ef741339c958830ac34cf", + "0x5d6de4795bab1e85d49eed3991058c8526b26f028f851798e64c44b02b219533", + "0x7459c50ac266878a3e428777040add9dd05d3119fa6ca0893dfe78b87af16a58", + "0x71674724de34865e988a846825d9f937ca48ef7322279591194ca7d40d8ee995", + "0xa43a1be4a3c4bbd4e28425f3172d3522b7e954d7cf0fc72a26d8ba7bea25f197", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x548Fd76c247E40155bbAd5caE2f091935b07b6ea": { + "index": 336, + "amount": "0x01", + "proof": [ + "0xa1cecbca626686e2791f893b538f80c72dadb1b6bf398f7000dff8fe5c595c9b", + "0xfc6474a7c7bfe6b0c19f19b0b1a115c18bdb531d8b9c74c4b5d2ffbced6b0650", + "0x7306ff63535bc4b71716d17c36277e5ccdcae2c03cbbe50c57c9420e43b33b29", + "0x4fa24b2d1635e25dea497fe90d30db11d577f752b726d47caf1b4952bdf93c96", + "0xc36c52715656389b2693c145860adf3b1f3d4d24a139850b1fa5f2236456376e", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x54Bcd31Ca05680f24F9Ad644187E06C5DeAEc649": { + "index": 337, + "amount": "0x05", + "proof": [ + "0xda52be382079b3f0da0b560c794683838e4a2820b63b1e12cc922fdce26a94e6", + "0x7fbd4fd3ba3eeae8eadfcaa188b892e34ed2832c462eabc0bcd5136ceddc2d99", + "0x9dabc5eec4ef62215a8dfd99f8da29641f4d2cade52a73474d7fa008bf611d21", + "0x3cc86f19d7ab5abe54cb84f21d19174b3158c792e08130d0d4f813b822ec451c", + "0xd8ba0ec6899e7ab5afd6774d7465b2ebc52e677b805f74deb131b1b243bae70a", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x559C4b03a2474b04074c3678d08Fd5B8BaE85028": { + "index": 338, + "amount": "0x01", + "proof": [ + "0x5f825c4cc2e14b972026165c03dce6c35fce69e0ade495466a04f4788b90c8e7", + "0x7197f5b66cfae7d5cf1b82a59d2bc154552e6c3451db4c193ada7e46662a658d", + "0x235df6c4bfff7e5ae5051713ca9a7dc5664282cfc88bace4488c612d23aaec19", + "0x70db17f5bfc52cce1e5c71a7571d4c960efb51e88d7fc8b1162dd074c38f333e", + "0xdfdb156cb5d2b90a5253163570fe08739b17ab3fc383c79eb041c1d1a667fe84", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x55CC5F2Ecf7ce5df1324F7EDFa961dbC73487221": { + "index": 339, + "amount": "0x01", + "proof": [ + "0x578641b717776f336de3280e07831d9637be33e109e66df17d7848b4aea513be", + "0xcfd16bece7c014ad6f62b5a351f1ce42141ca93cccfd4f049bbf7d5041d60b05", + "0xc2728ddd0ac297fcc2105abf09903a984517755b402fc34c874d56a464249392", + "0xe759b6546746269851513af2e7b90b699309ac7fd4eb1cefe25f45f6c49d094e", + "0x6ae25cafc683eaf0756d86c89deb0abecfbfd01e812ffbed4e7a26f11cb91f8c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x55e4750743f1E394DFf3E46eb03136FC27f29611": { + "index": 340, + "amount": "0x01", + "proof": [ + "0x580ef6efcbcb2f26eb68e2691b083805fe0fad04dcfcfb32ca4221921e370b92", + "0x49f105d825a6d26246149e137a77f402080929c3c15d458e782dea9211d5d905", + "0x708202d8f80bdbf5dc568f0ce8b7b9af201381136571a7d967efe4f79deae3c8", + "0xe759b6546746269851513af2e7b90b699309ac7fd4eb1cefe25f45f6c49d094e", + "0x6ae25cafc683eaf0756d86c89deb0abecfbfd01e812ffbed4e7a26f11cb91f8c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5662696f3487304A50AC51889c4e30592B6b25f6": { + "index": 341, + "amount": "0x01", + "proof": [ + "0xcf6d124bcaa758dea84fce68ab2c7698413c192b5eacf6c674aebbccda5686f3", + "0xf90ba0f4efc0dd3d7f49552842ca8dd3260f0faf2c3d3c105c1f85630cde0da3", + "0x13ea6405c1facec923a61440b64632ddc4351c954b3e5915100fe378a0664a58", + "0xcea68af505202af90a0679269376e373d9ceca250970bcb6953e0f30f5dcfc7d", + "0x85ada07677b521b0dd2e0d60f51f92f7b1217f46e36379a5afa5a74fd5c87a5a", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x568106712b41EacbF2A8643Ed2095b5327B61a5D": { + "index": 342, + "amount": "0x01", + "proof": [ + "0x9259b0c7d3e278a50d81937fd4b2ce52750a1d4373d8b35bbe7e3ee9cc50a21a", + "0x3f2b0450f93a25660c625812580e2dcaa6f91c463f685fc0f4c507c9f6bbe00a", + "0xf7812c617fd43b12d11ba57fd1f9b80022f8cbcc05f057d95b7bb516ebef605c", + "0xeb79377abd71cdb891e1379260c8fb1947760c17e28c7168ccd62f5d772f861a", + "0xea7c0076ebef0c429d544548828ff19d5600136801cc28845bdfa9990d97a058", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x572a75a82c7eBAd2C92dD7617740dFdaF420e518": { + "index": 343, + "amount": "0x01", + "proof": [ + "0x5b804f4ed8e227e0c4601d44e4da1ab3fdda6f2bb9042e9d2e46e7e643b00643", + "0x739e5a6c19c00f2a778c5ba3915ce56868f3278dbd62516f76632cd8fb65eee0", + "0x1e238294161409acd6c7ffaa2d08bd09d6a95e15ec21b6d1eed1c519054307f7", + "0x31f1720e10e01b0c3f193ea7a34f44234d915ebd6c8260e1b72970bca0201b09", + "0x140105e3fa17ce783a651f2281967c53a37a748c29442efd53ee24d8a1cff6f5", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5784fF641C2AeEE1339c4c32dA28d2E2E975BD3f": { + "index": 344, + "amount": "0x07", + "proof": [ + "0x02a3969d6b3500c70efc0613db6306b69c776b9e7e8f9927de6bc26bf23fd110", + "0x45f99d5aba828408aa25cab921c5b8d1eea54a12e7257217bec57eaf987e3243", + "0xa4fdfb9e13a8933dacaef17334dedd3721c4ff7bf3930be481e987c2b288d052", + "0x694db95f2efeaf59bc0b92d1736ca407eeca00ef7ad545f2c27ec99a059b74f0", + "0x9be1155992502d2b75a54fc5b2a41d663a86f7d329faea1befa0e24965b01a56", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x57dEC6115e561F3dE9fb7429CF14DE429713B3d6": { + "index": 345, + "amount": "0x01", + "proof": [ + "0x760b11783f5deba0df8fff3bf1b88691fc3d620a5447878d15c5113db30fb82c", + "0xd091941a39859e620e46e5a7faa44eda3f542993716ce9d10842c888b6556151", + "0x2f8ed4a6263c91d2dc6b5dbb2c00b52290fc594ce1c465e4bf2c33913536fd62", + "0x2542d5bed1352bb1dd1986da7e22c1f92c0eb7a7dead185e5100d7004e8e054c", + "0xb78cb1aa869958030ce4a14b5fff6309166225c83e0cdd2b91deb7b1639f67c4", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x57fcF904efC785e098676922d406e64A4e0e7ea2": { + "index": 346, + "amount": "0x14", + "proof": [ + "0x6cdb1ebb033d9d3177c7ae71911ff8d828af3b2bdff6cc885a5e263c1d38d310", + "0x9c2249c85f663730f542d3491a3925c33491fffeec05d50b68c911adf4c2b824", + "0x6739f7ef27695db5e41ccb568aa848d003419a94df0c5b9293106f211d362171", + "0x7c0de9d8e837704a5bbfc4993fa9b20e3f698f1b885a0b593d018e35bb790c61", + "0x1be60ce906d0d73954b2e1f2747ea1c9a23db0ad9345fa6801c551f1a39fa5ab", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5811bEdD2Cbde3F040cBF875FD3CD7ef2Bc7878F": { + "index": 347, + "amount": "0x01", + "proof": [ + "0xa73a4f455e4bd0dccaeee28aba4f686d710647af1ce284580cc8a9afbde30361", + "0x951cb512da99e967352d5b51ca184358fe279c4a23ecac38d25338d381399330", + "0xb094c21688682ebc73d83f5ad45321b8d5314b45d9b6d95ff0e4b356a6e6a67b", + "0x21367d58d52b32234887e9e91e468488a647d2d7407cacfa709cd59618255499", + "0x59d5a4275936eb4dfca0d17bab02b4a25bd4dc43ef3aa0e3515a07f7c0f68a93", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x584313319d0bFeAd2a9d98a7154f5dCb5a62887F": { + "index": 348, + "amount": "0x01", + "proof": [ + "0x1bc095c7fa3c0aaa9e8ac0c0b08dbd6fb510a6fcea6f689d2a99f6c276b41b88", + "0x4e17a548a0c71a27602d843ea4f61b17b34c35d59d0cc6982050f1c1789ae0c5", + "0x7eec595c69d6c1d1d1d8dacd93ff7c8b18c1968069bdea1797a90eeecc155ade", + "0xc2b85fb7fbdedfff6c0826f89cbeff5a93f827eeaec8b16d80424b138de956db", + "0x8e0cc5c13324dce3ab0f042d31a9db04afe0918f70e3f4515f43739791621c97", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x58A0aDF3C63607b18e34ceCbE85FC5c89355c8F7": { + "index": 349, + "amount": "0x01", + "proof": [ + "0x63ea94924a6d877d6e596b79835b69401dca42d08da02c58f7ed543b4714ee65", + "0x75744793836c7a312b9c37404505990c5c4256d38b41d7cda64bb1c9b716aa33", + "0xbb9d492cdff2f5113de60e7e37bb69fd0a5139cac96538ff8fefb20c479105bf", + "0xd2ab54f5e70cde7ed6caa9591ebf0def0ee5d532bfbf38a4473c6ff488c1d82b", + "0xfe7d73c06bd76d1271e4b772b51e13505a812b7c919129debfd7d15fb5014d16", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x58a283CD314c086F9B59FE5C6667CBf35B0Ba4f7": { + "index": 350, + "amount": "0x11", + "proof": [ + "0xc6b3148ec7a3e6631f524356f4b7d5b699f7d6caeb9e3ea0f3c54f96ef846b98", + "0x43beb4795c28b95c64d9e451dd152e82eab265ba25c79b9c00c5017c77c0919d", + "0x28953c726ef8579e21b5a30c7fb4f81f31e6a2af517a1f8948b50dc1a62e1f25", + "0x99930015299a0435807ebbffcd0957a02cf6631c31c05ff8ed9a165cfa4bf8e6", + "0xcf22c1d43a94c7c6471efe1209a3b103ec0a9836b6c11fe8d2e98d18b2e9cb36", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x58d0f3dA9C97dE3c39f481e146f3568081d328a2": { + "index": 351, + "amount": "0x01", + "proof": [ + "0x878979db097ed44286f01c9a9f5b4bbdd83efc3c01b48044bd8c29ada259b4d8", + "0x97e25993ad013625283866c50748df765ff71b428a032233b2207624c1e4f798", + "0xf2b143b8e4bb24b0f6133a57083058573afbf3f2d5a88213d4aef21a33017990", + "0xdb5507911490bc1574fb624fe6bd570cc6afcd947118f0c9c38fe90a00ee8b29", + "0x9dda7d74fd49fdacbeb3afcd37c878516159fe4b594e491ff7ecbc80fd8d6808", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x59241F5E850a9cE8A215A49bB2A7499b31296A94": { + "index": 352, + "amount": "0x01", + "proof": [ + "0x762d7c75384598ca4d187baa82bee051b49c818981a909cbf20573f0c3f38924", + "0xd091941a39859e620e46e5a7faa44eda3f542993716ce9d10842c888b6556151", + "0x2f8ed4a6263c91d2dc6b5dbb2c00b52290fc594ce1c465e4bf2c33913536fd62", + "0x2542d5bed1352bb1dd1986da7e22c1f92c0eb7a7dead185e5100d7004e8e054c", + "0xb78cb1aa869958030ce4a14b5fff6309166225c83e0cdd2b91deb7b1639f67c4", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x59f00A1B8C9E0984966402f8eA3E8d751aA6c654": { + "index": 353, + "amount": "0x01", + "proof": [ + "0x7579d9363260ff2bf10b1bfe7b48e9dc6d51302a1bdc9726ba855c7bf9228f59", + "0x7a516f6e59972f7d280c11dc5a969121ff19dfad19daf2ce131c82ad7605d370", + "0x6b1d50c8f881c6c8993f73ba91868e17e454e5d10e04868fd2b9002bfa1fa4c5", + "0x2542d5bed1352bb1dd1986da7e22c1f92c0eb7a7dead185e5100d7004e8e054c", + "0xb78cb1aa869958030ce4a14b5fff6309166225c83e0cdd2b91deb7b1639f67c4", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5A9Ab467ff24E592eBC707CfC6091E62eaa2b2d7": { + "index": 354, + "amount": "0x01", + "proof": [ + "0x3b552b7647831b8bf7bd96aed0d5c52ccf57cd10101d8e4480e4f39139c857e4", + "0xfa57d760b889735f50b5eab928528ac69d97b1713399d7aa8437b0144bf99b8e", + "0xc2aa8ca221a28e31ed71a4539c43e41e94c128f08a109bd6a1b093e635ca88f6", + "0x0f96aeb97a653e888416c064689ed19e2c4f980fba2ae619d0c47550168b385d", + "0xb5bb98883f5ea232108866e1400cd4067f34fc2d70605fd2c67051a6095af7f8", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5A9BD3E84376D2961D64e7088d0AA60CAB148100": { + "index": 355, + "amount": "0x01", + "proof": [ + "0x082eebbb710b41cd1954c5a33f33fce2882504a3e79414965344bbbcd58e20f1", + "0xc60c20faa140eef468595154b1c6b51502c5f5f41262b005375fe5c32a5c127d", + "0x159ab1cba9bf6ec481ada7ab7f7a06201f1346aa831336b8b398fcd6da2de059", + "0x7123b37c640e8ecb7e1db656a0f1869aecd392fe2f9511dc671c16401bc54aee", + "0x6e752d8572dc933bdf463f24751c7070d8aa74bb8987a5fe56dee3b0c9f53450", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5ABD904127C91db2fb61A4c0087dA24cA08b0280": { + "index": 356, + "amount": "0x01", + "proof": [ + "0xa6ffed99bd4ab6cd54dadb13cced7fbf1e44b3dbf091578fae6baa8e2b36790b", + "0x951cb512da99e967352d5b51ca184358fe279c4a23ecac38d25338d381399330", + "0xb094c21688682ebc73d83f5ad45321b8d5314b45d9b6d95ff0e4b356a6e6a67b", + "0x21367d58d52b32234887e9e91e468488a647d2d7407cacfa709cd59618255499", + "0x59d5a4275936eb4dfca0d17bab02b4a25bd4dc43ef3aa0e3515a07f7c0f68a93", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5B197894cd1942ac6f7Ab48A1F5CE38D72754b85": { + "index": 357, + "amount": "0x01", + "proof": [ + "0x2b9393c1dadfa531f1c1a2ec259bcf596943be3b718fc2c0be59011db3e7fc09", + "0xc56bdd4b88359658a37d61f564798baf08875bcfccb501fe44bfd18164acadf4", + "0xf55ee0666a9187169654a25df74d4fda1a91ed9900daa14c5b2ca79408f70443", + "0x36710d40c48dd22c4c23311fe2998a569fb56756df4d8eda7bf12408489aed56", + "0xa43a1be4a3c4bbd4e28425f3172d3522b7e954d7cf0fc72a26d8ba7bea25f197", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5B53d310c73Afd70f03b7a373b3e2451983228c1": { + "index": 358, + "amount": "0x01", + "proof": [ + "0xd85660711b4b660f4351657702d57f84adef7bfd31f213ac546282f160d286d7", + "0xc444e68fb51c3ee6268c2251e0bc4e1ffa81391195666bedb09363e903edb74d", + "0xe5131f39e8805c0037f27f127ffa4446b615fb4b7a3617c4bc555a5d8c3944ab", + "0x539804c7bf7a9b6235d14df5f64369e5a3ba52daf4ce320d3134eb569c42ebaa", + "0x57a1600e1002b648fc38956dc1d2f34be5ee3f6cf170c73bd27c43b2a01e45db", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5B7ab4B4B4768923cDdef657084223528C807963": { + "index": 359, + "amount": "0x01", + "proof": [ + "0x9f989831b699fe41a43f9a704d987305702a8b9b1b3cc3efe72f44c3d5061b2a", + "0xdd9e25d6522d53a2a041c98e65409444bd656dc47ab2a56452eb2e2b43d08ef5", + "0x2fbab75f362970937a06d430bd893a654663902ac95b78c258989474b316ccb6", + "0x35b38a743320b292e89d9164e2c2e5018fa2478f9a132ef65671c9bacfe611e9", + "0xc36c52715656389b2693c145860adf3b1f3d4d24a139850b1fa5f2236456376e", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5B81ac639448Ea477C6147eF7EA9b7c04C6F89a6": { + "index": 360, + "amount": "0x02", + "proof": [ + "0xd22d1c72e51214665aac851e1b00ba68c8f8f905d69a23381e880d8c504379b6", + "0xb809b86810658c031224356a60cd7a7da6c33bf718356a0e795010fdd7a63d9f", + "0x3cded42477683fe44d3b53da8af7372eebcf3f7b5d0c072544d9d80a0220aa0b", + "0x41e64ddeb2fc55a967472c34897707f35a7b74171d5a7d21351e62fd45ccae94", + "0x7e73f337249898d15604f7c330d90e36da04007407404a4b4276d5fe3083b929", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5D13980F513771D660d30a86b080fd5ce3738C39": { + "index": 361, + "amount": "0x03", + "proof": [ + "0x5df4af3f579ada929dc67edc171117e20f6a0e01286ab0470598d217b9e9c1b0", + "0x92b972a819593b4f9ee01ab9472121e0662188640a60977985e4a7d716563b63", + "0xc8194a78aa356d611f6bbcbe346bc7a996ca8addbd55a10d6fe06d7320b2f492", + "0x4bbd36041ce4968e3db3409953e198317c2cb3811d91f8fc5a98ba5c581d59e5", + "0x140105e3fa17ce783a651f2281967c53a37a748c29442efd53ee24d8a1cff6f5", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5DacBDD20B9eAFAaA30BFAD3B2Af1793036D65f3": { + "index": 362, + "amount": "0x01", + "proof": [ + "0xefd79dcf5a6bfb3018f163fc36c03117d3e24fe12cec85c57943f0bcd116b1e3", + "0xed750b694bb028b90d9b7935b9c4527713932e90b2cf648ce068500c7b73cbac", + "0xd8a35ae28db7c81be0f42512143e3c242b1425823caa2703947a88061459e211", + "0x27cae8e1fac7b32e83e85494312638757cf1e0afea8f4e6fe77387c412b4efd6", + "0x58340ed8edb441d787ada6b1aaf2b1e42912724e1f0f7887cde9253262aa0534", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5E4A7E014cd5E3C6067e8b84576D50C4ED5FA096": { + "index": 363, + "amount": "0x01", + "proof": [ + "0xa42a7796f528c1975bed8a0abeb3db0d7f8d47f6dd9388b3a4de7fd24b32bb8b", + "0xe610ec6f5d17c7c4632d467433a0265acd8a5474f9f6371826d0f2fb920f267a", + "0xe9c518193f61e187a919aad09e78c1cff35aa13804b131d81f50f7740479a903", + "0xc677cbee79568f65b4882bd20044555e2bddfb473bfa6749d1d07caa3dd6fd2b", + "0xdf701aa8bdb3ffefff1b359214087cc585fa0a0d40716a6635a8d2db4380dba1", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5EeFef8238B759BD8B8498EC3D1001be34fbf835": { + "index": 364, + "amount": "0x01", + "proof": [ + "0x1a942f18d30f2680ee39ba823fbe6a8fc2295ea716c6f12572d94338a92de448", + "0xeb60657c3c5cfd2a9cb0a7796e4138235793e7855cb9d7d46bc1d7a5974600fa", + "0xfe66f2955b7edabb48cb9446e3380701b161ec72c61f6ea4206263931d17ec7e", + "0x6b5b18bfb5c7b8de5b52219b51a21b6ff6e22d5cd7a147d521bbfac13cd7f7ac", + "0x93994074bdd819d668a79fc2c79be23cb074a679cd3fe03940945d4c6f9fa9b3", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5EfeC2646eb5D768dfA12C9943eE2f1Cc458913b": { + "index": 365, + "amount": "0x01", + "proof": [ + "0xa9f7a59afd33df9d40553516f8dd91faf86067120ecc076b9f4a8123fd74615d", + "0xe3cf7ff7415e2a99867984e1688a54275b875cebca9be08e1914bc2a1b2ac98f", + "0xfdae30148a910307864676cc680c0e41bb79c5b095c34c725c285354af84e7d9", + "0x68141ce9c9d3196b1db61f6e6c902aa8569304d1613ec750ac0ffed8af2bb113", + "0x32636a5315ca425c602832f925f24426ea5aec9939c73d1b2a6fcdace85ecae8", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5F813f7135a73B4360527F6428D5D8DbcD48a39E": { + "index": 366, + "amount": "0x01", + "proof": [ + "0xbbed00468023908011c44f3d249bb34893936fc288790d420465b69c819359b3", + "0x9142e314087f2b195a4182069198042cbac7dd8dbdda2ef722a7c3ba50b5bd20", + "0x2be23c7221abc4f749899eaf8c4fed2a3ac3684b891e4cb0133f0be9d8b49ff7", + "0xdb334b0b3ac11eef22a51af7bc46c7a633665d404c70629bf6c429ed0b8d1ae6", + "0xcf36a9c08620752945fec2c3138a9b0eaede19862d6c5cb3c0489e6ab3a443d3", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5a34D5230d87487A20086527ACb6672950E917D9": { + "index": 367, + "amount": "0x02", + "proof": [ + "0x5b6910f0afe36320bc78d651803fe1698d48e4fb49c924b9766d57a27ef71a6a", + "0x42822291c2457679ed40f4388aa0902e408bb7b05b881a5de484d47b0392e793", + "0x44e62419e6617508f01090bc15bf772f46d113e070bd339089cafb8752c6c104", + "0x31f1720e10e01b0c3f193ea7a34f44234d915ebd6c8260e1b72970bca0201b09", + "0x140105e3fa17ce783a651f2281967c53a37a748c29442efd53ee24d8a1cff6f5", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5aD32C7aeE7F06575EE0740cda8E6bd095CC3919": { + "index": 368, + "amount": "0x01", + "proof": [ + "0x79e99a441b9ac76450afbe32c2653162ec2f62e0531bb29c9d607958efd7a757", + "0x65aa36556359ae164c529dc578c2336c35b88a8f9ba2ca015c081db3fd0ff159", + "0x4c323856e3ed5872317143e057e5eb0b9c02e5efcad37c36801f077d7c535fbf", + "0x81cb79cde32d282b43e0e438fe2b6758f17fd2d569d10c780c800d4c492134d6", + "0xe2050f6c95c616c1cfdb04f4b6d0afb5afa0fb464f767c38aba0f07df915a97f", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5ad0734530568E5C80036fd814A8B50ac0A3EB4F": { + "index": 369, + "amount": "0x01", + "proof": [ + "0x742d6f478198d1054aaf7fbf9e21316b5a7d5ddc4738b3bd808a584fee8f6984", + "0xf51b13bed964f4212984b491cf6c9c2bed75982fba859045e82e5ca612731115", + "0x36984f6b1b4a1a6d888f3fa91ccc133c7a4f0e096be3777975d3fde4090b511f", + "0x396e47c3a850c873832c034b62c0031de9378efa99594428607ab8c6bc01e27f", + "0xb78cb1aa869958030ce4a14b5fff6309166225c83e0cdd2b91deb7b1639f67c4", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5afaA8D5D7Ee571F4E6651DCdAF515E0153EE073": { + "index": 370, + "amount": "0x01", + "proof": [ + "0xf4c0e538e98068e373e0d5aee75ff46cf7cae340ec7f424b0bf3b110fe763e2f", + "0x21bfd7cf8be8f35b289a19da561622b0c5a0e8b4d6dd7f83653f275eee8f94d5", + "0xfd0268e900a7c1ec041037fe894fcabcd46c99724b846e568ccd38d01ea0b2e0", + "0x3293f41caca9649b5e2565aa9f9ba63bf7c621850061b0b1b6af864bbfb07389", + "0xed5c942adbfa1d9538c55e89e4a7ff4276f908ac558913b5f43dce424bab8e0a", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5b79b8c395397E71295fa99da95a79CA2CEfB969": { + "index": 371, + "amount": "0x02", + "proof": [ + "0xba18529a755ce680bdb7d9ae8a8c0059171b79f6390c3ecdc808088e6878f0cf", + "0x45c63d6c978313bfe1f3a2c23a57432228e5991d269747656cc77bf884c24a52", + "0x99c1bfc876cf5982f012ca12995034d51b946a2ba47a506495fe65b361451d8d", + "0x6a8275b9d29aafc6358bf9f174b96a6a2561ace2c21d2edeb2a14975f0d9b0c1", + "0x83e262e483a6f2ff9f4df14637dbbdfeddf0c6b0b4ca462c4375d29a3521e052", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5b9A2267a9e9B81FbF01ba10026fCB7B2F7304d3": { + "index": 372, + "amount": "0x01", + "proof": [ + "0x5a36ef6db5416aea69ae6c825de657a6ce84bd433ef37526cef8fb004ca0dac8", + "0x6bf71dd96dc520ea1d4363e86e4f952fb827872011e1c93a08d9852877a38a6a", + "0x97f948eaa1e0aeac34d319d612cd62bd5eb49ea9df89012417a7fa4f0b73a5e6", + "0xd34d09ef2d0160dc3204b5dba612749c3a92de5f38fe30c9dfc3d0d199e36074", + "0xf9f105f90db6fe2970fb4e03b35654f9b69375879c783d3f1700e04b2e2f925b", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5ba5FcF1D81d4CE036BbA16b36Ba71577aa6ef89": { + "index": 373, + "amount": "0x01", + "proof": [ + "0xa97f106f3177f2d1cd935d76a5f148abcd03ef13432afdc31950df80a6fc9f6d", + "0x92328093f0b70d6e5e655a15b6241dbb85aabd4aa501a466d044f5d6e5cc66b2", + "0xfdae30148a910307864676cc680c0e41bb79c5b095c34c725c285354af84e7d9", + "0x68141ce9c9d3196b1db61f6e6c902aa8569304d1613ec750ac0ffed8af2bb113", + "0x32636a5315ca425c602832f925f24426ea5aec9939c73d1b2a6fcdace85ecae8", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5bb96c35a68Cba037D0F261C67477416db137F03": { + "index": 374, + "amount": "0x01", + "proof": [ + "0x5302697faacb279cfc7a04f963ab87263d2fbf2ee7b7de7b7861c617f8b5eb3e", + "0x00d9512d2309b56be4823526c3362ade247918c40c1baa0eb8c4ab6628d9b8f0", + "0x41a070fc9cc72447357345f29cf0f36b25fa38ec3250d2f34d6a05451b8da742", + "0xc7b00ce40d9d1f9a2921254e2bca646cf3992fb2c667a15215723d1f5a1b5352", + "0x5477c93aa7e191fd8f76e1976387fc82460220dfdcee87f9ba8926f4e0ddf45c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5bbB65fe6E990f2DCDF95FE7E71f07264c5993ac": { + "index": 375, + "amount": "0x01", + "proof": [ + "0xf3557f220d24af73a2740906b30c25879721b75ae5bbe5bdb1fe4ec8f7fe0674", + "0x73cfecf81f8519a867ee3ee6f6f5edc70d8198efc0ec8d4be34516a10c30a333", + "0x9dbf8a188dd35869d18593fd709b3e786185f077d3f4c9439919ce6a3d6d5731", + "0x7caec6cdfba66dc7947ce7a10af67bf36737d573f70c5bcf73b71057ac86d1f9", + "0xed5c942adbfa1d9538c55e89e4a7ff4276f908ac558913b5f43dce424bab8e0a", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5cd313f6defd02dA3ceb91845bFa492FF8bD8817": { + "index": 376, + "amount": "0x01", + "proof": [ + "0x4f515af52b8f83fd367c5ef94e6e25e4822a7f6f6229c6271d2de6e0af9c64c4", + "0x9167268bb67d5571096efaa161cce2c8e3c801840ac1d4e910cdc4742b2914b8", + "0xe823abd564575edaba5671df2299c869d599b76d50814c956babb2392af273b8", + "0xde9fcf6a43c240e1d4c7ca780516b34aba68d02c35c5ad3090d1ba1aa8d40999", + "0xcc9986a7987738d81db64db86f583aed4fde214b766f55d0f15a876c8f790fb8", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5d6a0c304097E0EF19291f57fD63d5151Dc1fDb0": { + "index": 377, + "amount": "0x01", + "proof": [ + "0xec6e63ad6806f18cc59ad9b11b8557727f34b683e635fa46cbdfe55c0df8f2ab", + "0x7c973e726223f392281bf4c449c5fe10d1bdde4121524c34b5caf331ee3ad0b9", + "0xc7a5709349e5e5daa302cf7bffba9d9d810a658db5159793c0ed38096beebc0e", + "0x338979409b1c886a92a48a505a3f0b093231b3d66119d999f9bcb41baf89c59d", + "0x6e496426985c92b04963088da4856230c781a975dbb5ce2d8eed77e7d2d4b58e", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5df1FF52d856CbE82e2D5eEeC7d9d0fA03572674": { + "index": 378, + "amount": "0x02", + "proof": [ + "0x381342c3c0638e75d00a17b31945e171c080fb34485aebd86b28ab44746ab21b", + "0xdf3a8571dbd4b3486be86fdd95d51d6597479efca978e36d91f63ce8ccb25aab", + "0x96659af2623f9d5820946e88ce636546f77239bf7c47b826a73c1355654c5cdc", + "0x26d5243ad79c6ff0365171b12c8ef795d8c977a57cace1265e53f8b7326c312f", + "0xdc998377cfbadb1c2d77196acc69c259bcfcc6de58df7f5aeea2780a288f2509", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5ed86506FF1244bb3aC0C309D5Fc5AE6C0375464": { + "index": 379, + "amount": "0x01", + "proof": [ + "0xcf2bef3e1e941297d6b34dde2edb4e9ff204a03b10dea940cb1186b9fe0f0be6", + "0x3dfdd67bd589ff08ccdc2e53bdd42b21a0c8811622386bda99933b059d28ed75", + "0x13ea6405c1facec923a61440b64632ddc4351c954b3e5915100fe378a0664a58", + "0xcea68af505202af90a0679269376e373d9ceca250970bcb6953e0f30f5dcfc7d", + "0x85ada07677b521b0dd2e0d60f51f92f7b1217f46e36379a5afa5a74fd5c87a5a", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5ee6d965E244d246E14dE984b19Ce2D06c06E0B7": { + "index": 380, + "amount": "0x01", + "proof": [ + "0x4fd92df518ba7d42b024d23df18b0f79e14549b57b85452a842b027064d63957", + "0xf27535c1fcc45333536c098b69bd0c478ffa501819eeb533f56a2075c5a4d6a8", + "0x10a0bd36bc8178ed9ea5da0e54219676f892a56ce312bd591118a0c3902c3d68", + "0xde9fcf6a43c240e1d4c7ca780516b34aba68d02c35c5ad3090d1ba1aa8d40999", + "0xcc9986a7987738d81db64db86f583aed4fde214b766f55d0f15a876c8f790fb8", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5f221CCA4fc951C89a04fD9D431891c31F5de5a1": { + "index": 381, + "amount": "0x04", + "proof": [ + "0xa56d62f3d263d533a3dd9ac2e85907e5bef2c6c4745ffb60593e67c76962014e", + "0x13eed6a0e176efe8128f983a64f34211969ae86a2f13b9c2bcb11cd3cb255fe2", + "0xe9c518193f61e187a919aad09e78c1cff35aa13804b131d81f50f7740479a903", + "0xc677cbee79568f65b4882bd20044555e2bddfb473bfa6749d1d07caa3dd6fd2b", + "0xdf701aa8bdb3ffefff1b359214087cc585fa0a0d40716a6635a8d2db4380dba1", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5f8Fd99047265Af45071f40042DA15c1BD375B85": { + "index": 382, + "amount": "0x01", + "proof": [ + "0x7e1d6c0f4d5918741946423ce9968ed92c270c96b12a993fcc2f1317a2a99195", + "0x7daa5dcf777e5abc497439e1fe5fdbf5d0f62c34b703ba211dd93f26d976d8b9", + "0x56bf94bfd25613c3b1c53d93baba2a4d76e076069333668d5ba3da9f1f69ce30", + "0xc7b7942da27652b608d4a505a59fef704f26c49f0c2a23709d80122b3afab5bb", + "0xe2050f6c95c616c1cfdb04f4b6d0afb5afa0fb464f767c38aba0f07df915a97f", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x5f9B7ed739bC5459b0DcDc032930a592995dA8bd": { + "index": 383, + "amount": "0x01", + "proof": [ + "0x51929fd719e779f2887d66cdf0455e391bfabdd0a0b828995508d989ab2b01a3", + "0x920e396325b266f2a107ddf1af2bd4d60098d29a2a5653028372b04a72136338", + "0xe9d1da07919f076017a9e46eb39c786b9ad3246e3af938c5a8bb37fcf62feac3", + "0x60ea05c082bde3732ec3daeb0e2bae0395932096e755b1a42d9def3042bddceb", + "0xcc9986a7987738d81db64db86f583aed4fde214b766f55d0f15a876c8f790fb8", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x602CD80dE210d4253F671276A85FAbcfA3Ee1C7F": { + "index": 384, + "amount": "0x01", + "proof": [ + "0x44488e779ac9afef9a77a2b96ea4bcb451848b5f65337cd2fd9f0f151cd1cb32", + "0x5c099c23f6c0f1edb9c7670c98c8e9ef3d3f6d289d5294a254f8ecd446c49e69", + "0x11143bf2cd84ebb9924b71d24ab1df210835583a66325b911ee5fca2778d0f13", + "0x9e0106695419683e28012ebdf11113a020b4f76869c1e66a51206a84371b717f", + "0x38d4a740f3f99a827703ce6725923277f058619e98435b28078dc5b994e00a6a", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x603a8FD9C4D35dd8DdD41FC8a0D711777334b3f1": { + "index": 385, + "amount": "0x01", + "proof": [ + "0xd67fe5595768e064d8e404263daf0872cf96c34d0994404e3f9c51ae86370aa5", + "0x3be9f3d3bc08f5b8c9382c65e359e61bc95b9dfe2af677a778c4a6723acd7011", + "0xf1ba16133c06bfb62c0f34a7f2c60b2d060a7b428988c8f8b9683824c0eff3f0", + "0xd382b6f12ac3804a083f91e50c5b4faff460036b8bbe9e3c74b4468370b346f2", + "0x57a1600e1002b648fc38956dc1d2f34be5ee3f6cf170c73bd27c43b2a01e45db", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x603b5ae7695d562bCf4615914A04395D5b796007": { + "index": 386, + "amount": "0x01", + "proof": [ + "0xc53199e8fd1f4e34cfcd62081b2b79b402b32b087fd44c7cc959bfc133a7ebe2", + "0x2ef6501a43ed6db323249952cad264de3e023579cd5beab9a0ab0c197e8e526a", + "0x1c0c126d67f3347f6eb5a3e70bd23a4f895f18b6418e58068e703bb374301b5f", + "0x99930015299a0435807ebbffcd0957a02cf6631c31c05ff8ed9a165cfa4bf8e6", + "0xcf22c1d43a94c7c6471efe1209a3b103ec0a9836b6c11fe8d2e98d18b2e9cb36", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x608b10b5CB5154132564e1d415B116dEF66A3960": { + "index": 387, + "amount": "0x05", + "proof": [ + "0x03d5ab7d33c21b7fbd656b85258a2055f2f50fd1a8b641f170b8cb29d8758b5b", + "0x81c21b814aeebf34dae43431dec6fc8fa7d9b823553bcc000812a76486259649", + "0xce425cf8478bb52919447ea20d7a544c17358dee3ce6498f1cae3e3f0f173aec", + "0xf48849b03cf9b334d4dc7a6911b922272cb1a72dc4223db35fa6c699461d5f16", + "0xb18758ddf98cdeec3d020c2379717281f5c0fa0133be7d006f7f753c756da43e", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x60999773A86345EF2Ce54954cC253e32e17f9df3": { + "index": 388, + "amount": "0x01", + "proof": [ + "0xaba79c919b7f6f528f6dd92621f7f700f16690bf4cbe3b10e5471bb1d1a39c5b", + "0x51d6140bdf2266dd9e6099fc4dfb33024b0df3b8f004e20097b66ec1d0ed4a9b", + "0x2d96d77142897c826da134ecca3727222ddacbe2424e5b5b3155c87241c4bbb3", + "0xd7f4836e54488e91267fda42072073873c17b5d47a5a1cb5374c07d89c92ff21", + "0x32636a5315ca425c602832f925f24426ea5aec9939c73d1b2a6fcdace85ecae8", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x60F3A536c3E8D35E9D27a4DB2b8FAf9C82b93060": { + "index": 389, + "amount": "0x02", + "proof": [ + "0x77c83a33985014f0ec8638ea88feea05ddda58d6ced368e2ea7141a3fa543efa", + "0xe9f35cf8f7a3d9836b30732828b7c2b20e233b2ca7f8ed6eb135552f1fd98685", + "0xd7a87e22dbf70420c67f3bd2ebe0a7a93c439db322f5dd2ad84c54df717933da", + "0x08cb8a426c97a85d30cf9308f5228aadeeb1f2c3f1f22bb2fd0d6c1a680a3ff0", + "0x80cf615f05f15e9ed665dd7df5d086fcb70ed5a5086e02db7c08752fcaab6507", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x60ceE186cAdaBBBa988C568aA80bBf67294bC041": { + "index": 390, + "amount": "0x02", + "proof": [ + "0xe1a2c4656ebb2279dc70884856b88996cb215a9a43b1f2725c0bcf98d4bd5e3a", + "0x47fe59bafd3357a18bf3ca4978f0cbabaf927bca771ed8620571a4205920deb5", + "0x48e789a37f032c18f647b0c6b852a88e29403e31c0f6bf94215b72507b16fbbf", + "0x60dd57debe01b07f2150f54d637bd8f574df12ac003a445ad012509f5b619671", + "0x966715df220dfbe5e11392b257b61b64c18178d1825b654f95f67d7c9558a2a2", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x61b076d17a5B1D3F0a2b5322C0991d5698CbF72b": { + "index": 391, + "amount": "0x01", + "proof": [ + "0x42f1d6a9d2b255eb39c4c71d7628cfb5b9a784bf0664743cb3ca8520e13357e9", + "0xde1e0e90408abbaa4fb3245e1402041c8b49a5055e5927f00d6d2f70f58d61cc", + "0xa734a0bd47ea59109ab668778330ff5bec3b192c7fc158c8d946591e657bcae3", + "0x9e0106695419683e28012ebdf11113a020b4f76869c1e66a51206a84371b717f", + "0x38d4a740f3f99a827703ce6725923277f058619e98435b28078dc5b994e00a6a", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x61d2fa393B5F2327E9F1c1C8C4B38547B41EF97E": { + "index": 392, + "amount": "0x01", + "proof": [ + "0x3701ede7f72bba0c165661cf84253526868f3c030cb7c8879c966b82c7836045", + "0x2376b40b0bd18445d7bacd2f46c9264d69a2dd66d8b9bdb9a6610df295422c0e", + "0xba70c400dd80e4274e96080abd494fc3d055f32a6397ae40d812707e3922a8b7", + "0x26d5243ad79c6ff0365171b12c8ef795d8c977a57cace1265e53f8b7326c312f", + "0xdc998377cfbadb1c2d77196acc69c259bcfcc6de58df7f5aeea2780a288f2509", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x61d84d65d0cD1B0D22EeA94A80f15554e3304E49": { + "index": 393, + "amount": "0x01", + "proof": [ + "0xccb5577cf8d38e6a759ef55b4d626fb71e4d2377270acbdc2f3cae70f475ece5", + "0xa9ab7a810e9efa28245ab6cd8c9cfc6865cf4e6eaec31c0760739c529377b269", + "0x80afd91747cf4aadcd0a9bfc4df210ea0e0b85434282ec9bee91d7d5f9165218", + "0xef33e9da5226ecbab5796a616b47d5f4223c729722fba46a5cf043b7bdc381ce", + "0x2e78635a0ed4a14dadd872d564c5dd2afc4f21b0307932d27d4471c48082b7f3", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x61e193e514DE408F57A648a641d9fcD412CdeD82": { + "index": 394, + "amount": "0x02", + "proof": [ + "0x5a0cbd4a47027ab79f6d8193cba82aabbfba10de1c478d24be093bf6b15b02e6", + "0xf3e01ff0fb916448f11e5c6ce85459a0eaa2df00fa5ac47f79d300a182c2cc02", + "0x97f948eaa1e0aeac34d319d612cd62bd5eb49ea9df89012417a7fa4f0b73a5e6", + "0xd34d09ef2d0160dc3204b5dba612749c3a92de5f38fe30c9dfc3d0d199e36074", + "0xf9f105f90db6fe2970fb4e03b35654f9b69375879c783d3f1700e04b2e2f925b", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6217DdD12dE52a15B204594a596F20C6f717B6dB": { + "index": 395, + "amount": "0x01", + "proof": [ + "0xb158bcc4287c8a3880c7ccc7613c347d1c5dd1e92ae8eb2fe0b3ac79e4f34973", + "0x3d20bf045759d6113388821ea6575275e0487132b6c2b86adf8966ceb779820f", + "0x29019a0cb0bda0ba23b44ca59094eb26fe840748f490419f63051f2087caee0d", + "0x49f4781ffbed71f831627c02425eed106f4714988055f5e0978de46ca35b3ae0", + "0x72373ecc225af245878bc638c49c8901db1430b7210a3008231acc8f8118d2e0", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6273540b8160b2d923652552FaDe0Da98bb10dC5": { + "index": 396, + "amount": "0x01", + "proof": [ + "0xbd34070f6d63a449130ef5069c48d23ef4fb5f9083b9560acf79ceb3ab0dff85", + "0xdd5a5a03336ff3fcd03b8c065a4e184b77cb95a5fd5e4d4fa95ce164f2e7e261", + "0xb47c664b127e95ef186434a19e51e8c91952a09c8b6513f4afcf82c63bcec3b2", + "0x3886e44b7873439ef0a83b4119fca7dc640ee0f9551983449d038a076169bb1d", + "0xcf36a9c08620752945fec2c3138a9b0eaede19862d6c5cb3c0489e6ab3a443d3", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x629DE717D4f9338a6c38B2DcCe0CC55c1e28db80": { + "index": 397, + "amount": "0x01", + "proof": [ + "0x232b9e54498338754720d03e6380033d653533607090eb0b2a17b7d36fe1ecaa", + "0x34d5730d425d1f6bf8ca2fb63a0b6942edcec42c19183c4f2a43b7368fbb5cd6", + "0x3f50362d7d3bf3f3f84413a1792917e070daec36794eb4cb6cd5dd3720a2ae19", + "0x7076b49e1dda289a132a67f2f0be7b87522da84294f2302ec4d61300a0630b79", + "0x6665ebe68e892e4e5135c09f9cdc379628aaa60a8ff322ed2ba75fab3b3a9cc0", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x62E1D5ADfB8826515DDF897BF32ae397b9735208": { + "index": 398, + "amount": "0x01", + "proof": [ + "0xc2f41138d4b23bfa6a6745118b85aab3345d73c28b224d5d967bfe1447ec3c72", + "0xbbba871a00094f3668a4e2ca6ae0591b1f2f7b091d9d7a7fd36ed011e6739e1e", + "0x31c626a13fd36bf9222fabb7f884eb7f6bbc58d99a42ea76aaf069282a6bfa97", + "0x65c5caf7f221e805a211309d005cab013498255a9343870184292835ae911371", + "0xcf22c1d43a94c7c6471efe1209a3b103ec0a9836b6c11fe8d2e98d18b2e9cb36", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x631857e975cBea9E3107d69B805d4Af9EA50Eb88": { + "index": 399, + "amount": "0x01", + "proof": [ + "0xa768844b0f16a5e745597ef8cbe7339552e579df992bcc2d0ee86b0c0a5bafc0", + "0x27d809de885d2242d71d52112d90854ab7b77573cab5a8aa24fa43743b76a6e3", + "0xb094c21688682ebc73d83f5ad45321b8d5314b45d9b6d95ff0e4b356a6e6a67b", + "0x21367d58d52b32234887e9e91e468488a647d2d7407cacfa709cd59618255499", + "0x59d5a4275936eb4dfca0d17bab02b4a25bd4dc43ef3aa0e3515a07f7c0f68a93", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x633C2EcE13b33502d6CfB8d054821625600c7bC6": { + "index": 400, + "amount": "0x01", + "proof": [ + "0x50b697eb03de77092fd071a1c39db0830d0e51e2b0451b2626238a829e59e06e", + "0x42921ed36435b47cdd73309952b5fae6365d4544976aea9a02671c14402134ee", + "0x10a0bd36bc8178ed9ea5da0e54219676f892a56ce312bd591118a0c3902c3d68", + "0xde9fcf6a43c240e1d4c7ca780516b34aba68d02c35c5ad3090d1ba1aa8d40999", + "0xcc9986a7987738d81db64db86f583aed4fde214b766f55d0f15a876c8f790fb8", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x634775eFe2d77FF787fA843A57e752b9BD515F41": { + "index": 401, + "amount": "0x01", + "proof": [ + "0x39076640052af4879d81442ff79deaf9e05443908a9fcc7e6d7cc4d7944533cb", + "0xb2a3a5ee3811ac9759dc207c4777dbd3f7d718388fc64b9d918b37b593468eef", + "0x96659af2623f9d5820946e88ce636546f77239bf7c47b826a73c1355654c5cdc", + "0x26d5243ad79c6ff0365171b12c8ef795d8c977a57cace1265e53f8b7326c312f", + "0xdc998377cfbadb1c2d77196acc69c259bcfcc6de58df7f5aeea2780a288f2509", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x635b2aA4b3A3eAca4F84f5b3eaf49f10C7B9A914": { + "index": 402, + "amount": "0x01", + "proof": [ + "0x8d41a9f76adf4af3052bc5b259cf800ddc85fd6224ab87d1916fde6fc5911e5e", + "0xa2cf422335730cffe37f7091da1df639821c9ee87a748942afac2c65f9a8721e", + "0xe0327321894dc1feb38e3fe36a354623f4288831a6705367168694406a92d9af", + "0x7217bacc0b5fadfdc27aef27f3baae246ba909c02961594a63bb24f24958cc4c", + "0x8fbc13f50b0f82a781945a74ddd5c5abde0b4a8983852c66ecda77a68df50722", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6368CE2750325f5002587C70C8Bc298B4df61EBA": { + "index": 403, + "amount": "0x01", + "proof": [ + "0xe851a4d03ed59a53d8e307b4f90de0a9280d41f80a975e2ba21e20306acdfcad", + "0x8a0949b6156f3e32d9bb2135dd35c858d532dc65563e1a24d5bf0e3947c16d92", + "0xca244e046f3d59b7d6cc79bf3d79d36d4e16637e4322e4e66e83e8c3fc48a083", + "0x6029ed468a13d48547faf514f4c29ae1fc65bcefd1ecd17c26aeef29ec044356", + "0x7a545b345b30e441bb780a4fca731a87b1e941b75518a9983a312194a9e7bd46", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x637307b752f001a30EB7a05891C4e02922C912bE": { + "index": 404, + "amount": "0x06", + "proof": [ + "0xc9fc3f9e137be40a9dc8533860c178eda88cb399320c51b0e8e617f93e447bf0", + "0x7b4c6d333fad478f8a08a5e68345ba6284b894495a474ff212b8a2e7c01c3baa", + "0xbbe257abf6239029d7b9473e959941b7ffd9cc84496254335d553ed2f9334fd2", + "0x1f4f9d2e01bb8c804693d53134cf046798ee2607f0aa015ff42b474e23cf7ed2", + "0x97fbe90108c9d6db20d511e4419e4ed044f589ef1f2a9f6539187bad21502f90", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x637E21Ac11F0E0Cf95D926d6bd2737b059A2858a": { + "index": 405, + "amount": "0x02", + "proof": [ + "0x324d4086ac18b08bc4167725b8f47016a77305424f4bb4e39497c8dbeb383714", + "0x7ee6a8a9db2cb4d3c7101f89bd0781f97303b41e441a1d4b933387eef9b1f957", + "0x0cb9cf742e620c55a260b746926eab12f725e11bfe56426413054bc3c2d83746", + "0x721f15749c8ad9759a4a7d682519f25f59a5bf74daab7275c00bac9f0ddc323d", + "0xd6d09ea62a0a0959d8a1f1cbd849b805597a75fe443bbbc4d5e2555bf8225437", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6383457bbF853aCd330B9568D743d283B84c55B7": { + "index": 406, + "amount": "0x02", + "proof": [ + "0x8663494326d8b5c29595dbc21d26215086682f1322aa5381814098063a2d2cbb", + "0xbdce07efc4858fce7924d176e8f3e73c3ee1f7cbc2ee9b5b1c47517dc76172f0", + "0x6bd30df1554552e0e9b030df3da576a8a2771bdb0e518021ef2f17fad6b2fe6a", + "0xdb5507911490bc1574fb624fe6bd570cc6afcd947118f0c9c38fe90a00ee8b29", + "0x9dda7d74fd49fdacbeb3afcd37c878516159fe4b594e491ff7ecbc80fd8d6808", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x63C964dc8fa9DEd3510af5fBe5Fe18baC844E69D": { + "index": 407, + "amount": "0x01", + "proof": [ + "0x00fed020579b161df49dd4dd764bdb93d115e814b851a2b46acda4de05f705f5", + "0x1f8ff13f260cad30ef176053169afb468b60d46c671780fb667ed98c55dbe7eb", + "0xf1525aa7a232fb8c1021a8aebff4bb78ffcfc5a5e00461950f235b958d5c70ec", + "0x694db95f2efeaf59bc0b92d1736ca407eeca00ef7ad545f2c27ec99a059b74f0", + "0x9be1155992502d2b75a54fc5b2a41d663a86f7d329faea1befa0e24965b01a56", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x64257b8a791Fcf74400B828b22ff0F3A015B4AB7": { + "index": 408, + "amount": "0x02", + "proof": [ + "0xf7cc7b15b1aaa06fb6fd4501d60b283f1230c38c2488235532609487fa2cc8dd", + "0xa7bc4f20b49093786623053d8eb39b029e2c70f654bd48090c7b98c639e4a678", + "0x9bc46200f73af0c38de14df3f6eddf911056a5df16ad70b6582fcd96bb7e45d3", + "0x3aebe8d88cbaf4043e28b3d6aad9a1f79bda4dbadcd2f685785a58d155fbcc50", + "0x8e7f75ccc4d864471b1a7ec71efa29a4e8cc4761c26a6987c8043d9ca642a2a0", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x644a135d5b59bcc7149acC24c52BbcE32c8f196B": { + "index": 409, + "amount": "0x01", + "proof": [ + "0x1b158c2eceae8c179acd9f4856f7e4e6faff8ca9bb90f788d74eae86c04a2e76", + "0xe9608ec4e28b0a72b750e7a535f206af5c9b5a72e05dcbdbe3c4ac2f74f5fb94", + "0xfa32f82efe11ffd2403c559b1ec3e3004c40156be97edaa5050d9a8a56426e05", + "0x6b5b18bfb5c7b8de5b52219b51a21b6ff6e22d5cd7a147d521bbfac13cd7f7ac", + "0x93994074bdd819d668a79fc2c79be23cb074a679cd3fe03940945d4c6f9fa9b3", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x646469ee06FD4974edB05c84e290612658cFbbbc": { + "index": 410, + "amount": "0x07", + "proof": [ + "0xec4813446e745ae37e294ad725b5c865a5dd0982937af18bc0e5df19df9e9ecd", + "0x5b1269b8944ee3ab1144f2f68294d642f03859fc772cdc849524947d49b1dace", + "0xc7a5709349e5e5daa302cf7bffba9d9d810a658db5159793c0ed38096beebc0e", + "0x338979409b1c886a92a48a505a3f0b093231b3d66119d999f9bcb41baf89c59d", + "0x6e496426985c92b04963088da4856230c781a975dbb5ce2d8eed77e7d2d4b58e", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x648c9ef315eFffDD89B057f963547DdBCD499166": { + "index": 411, + "amount": "0x01", + "proof": [ + "0x59c39fc3012748540faf7b0e054686ecefdb1924afef1cc9017f6f21aff8367a", + "0x60aa814bbf80a454545653f32fe51ef43892a92d8211ca558afff6153de13565", + "0xf605611ce1c692b9714072be746e6b2642baaa0e106fff51378e6de24bb39de1", + "0xd34d09ef2d0160dc3204b5dba612749c3a92de5f38fe30c9dfc3d0d199e36074", + "0xf9f105f90db6fe2970fb4e03b35654f9b69375879c783d3f1700e04b2e2f925b", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6496B57Cd93c607527b418EF584a6b293b80a718": { + "index": 412, + "amount": "0x02", + "proof": [ + "0x3af3f6fc9c7399ca8e50fde9c1d9ab370e7050fa0d400c070fad4d1c12ac7c7e", + "0xa0c00fe651542ce532c519f2a8f8d135342c35e4dd428389f37c8782872d46b1", + "0xf40d9321096b33fe11dd3bb5f540443ccc3463fb86ca7e96dbab2cdec392fead", + "0x60583de8b96cf21d7bf97a30f8f28bb928ffecf01373b007ee5bfa1bb5a1f776", + "0xdc998377cfbadb1c2d77196acc69c259bcfcc6de58df7f5aeea2780a288f2509", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6512264566bF91eFcA43cAd4e4495148511C9EDC": { + "index": 413, + "amount": "0x01", + "proof": [ + "0x8ecebc7510a182b907a154a729673f0ff3a118c8d752ff83ff5e1410eed485e6", + "0x80550099b7442c77221445552d3764ecdc31c24959798fb3f8611dcd58a0fbe3", + "0x71bf6e85247d9d89451b82be9a28d64d19071fd3c122e3bcc6db9f470fb854d4", + "0x1a6147d096056583b570a6da72277e79d6ef31519ab9cdbd2d1115f5eeb94a46", + "0xa4e0ebcaa65c6595e7c7f0ffb89992e2b9cb58ac405c81aff220fc4b16ea3b6b", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x652151c8521A46bEA762624726214FADd2e666Cc": { + "index": 414, + "amount": "0x01", + "proof": [ + "0x9124c871f96b3cd2130a821a41ed895805367c7300220e62c5da83ab7fc6842e", + "0xf92ef9e908151a0ae8816d2bd70c1c9356b98500d792d7dfd5910a2e36716db3", + "0xe08ba4e5ddf5c7b3ab07672afdf53c0a975a407af8a156203f47781efabe266e", + "0x0a650a18b5dc7e14051f590d1612c3614c677cc931a3bd72443efdbdec9b6fb6", + "0xa4e0ebcaa65c6595e7c7f0ffb89992e2b9cb58ac405c81aff220fc4b16ea3b6b", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x653d63E4F2D7112a19f5Eb993890a3F27b48aDa5": { + "index": 415, + "amount": "0x01", + "proof": [ + "0xd65e21d23a1b1f4aa5dcfb8af601e60c09ed69cc3584c14886ee24e939a35a97", + "0x3be9f3d3bc08f5b8c9382c65e359e61bc95b9dfe2af677a778c4a6723acd7011", + "0xf1ba16133c06bfb62c0f34a7f2c60b2d060a7b428988c8f8b9683824c0eff3f0", + "0xd382b6f12ac3804a083f91e50c5b4faff460036b8bbe9e3c74b4468370b346f2", + "0x57a1600e1002b648fc38956dc1d2f34be5ee3f6cf170c73bd27c43b2a01e45db", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x65CAc1fc7489f7B08156e2e95db4cb35C7C29b4f": { + "index": 416, + "amount": "0x07", + "proof": [ + "0xacc56f1e5c281ab51e4411e094b1b338f52ab8f639a6285dc961c947c5af6ce5", + "0xc698bc652b758e0e6ac353da1c66360662eb63823635bfbddf0bab4e3d6bc94a", + "0x547310dbf01783252ecf8dcb1f11da8552ff7f0911e701b5e17e3f8ce6679a4b", + "0xf685abad756fc52292f02befc3f5465de8d8f16cce61117b3f5de4fc38a60819", + "0xa952d1dc401036dd357d470bb699a7e9cfc64f0caf6dc51a638cd2487f5e73fb", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x65a441c7A0607f76B3B153fDe0fD2f3a920CC8FB": { + "index": 417, + "amount": "0x01", + "proof": [ + "0x571ab59d79c7d8c0f1d35072cb5c6f9b15a54ab274bb4db458ea71380c793213", + "0x618fcae394b9be93ebf5368a54b5a6244a2176fb031c7b6bfbae4387442d4ec6", + "0xc2728ddd0ac297fcc2105abf09903a984517755b402fc34c874d56a464249392", + "0xe759b6546746269851513af2e7b90b699309ac7fd4eb1cefe25f45f6c49d094e", + "0x6ae25cafc683eaf0756d86c89deb0abecfbfd01e812ffbed4e7a26f11cb91f8c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x65ceD347A006B95C8FA74Dea8DE4F688A264f9B0": { + "index": 418, + "amount": "0x01", + "proof": [ + "0xa830988e1abf77ef25c74e9234131d7662c5a354201b032db5740d345c5149fe", + "0xc877bc6b4ac51ad2d48575c87748ae94debe6948a8143e714b09ad09b0711ea5", + "0x31fc7a90e64fedd0c716849f9c3d85d7bb0f0af21a85776a85104ce4712fea76", + "0x21367d58d52b32234887e9e91e468488a647d2d7407cacfa709cd59618255499", + "0x59d5a4275936eb4dfca0d17bab02b4a25bd4dc43ef3aa0e3515a07f7c0f68a93", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x662d5d79849113A5403Af776210307a7c82a5267": { + "index": 419, + "amount": "0x01", + "proof": [ + "0x59f5e808750f929d7719331169072e5c5c433251591d315b50570adb8f6e1b61", + "0xf3e01ff0fb916448f11e5c6ce85459a0eaa2df00fa5ac47f79d300a182c2cc02", + "0x97f948eaa1e0aeac34d319d612cd62bd5eb49ea9df89012417a7fa4f0b73a5e6", + "0xd34d09ef2d0160dc3204b5dba612749c3a92de5f38fe30c9dfc3d0d199e36074", + "0xf9f105f90db6fe2970fb4e03b35654f9b69375879c783d3f1700e04b2e2f925b", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x669F7c5d34375d75E2cc97d9519fBF243d1D5283": { + "index": 420, + "amount": "0x01", + "proof": [ + "0xef25141b7bbd00b861a6b1e86492af47489b7969de1cf5a38fbd552cf3e89922", + "0x238cbcd3ce5b90d05a442db0b684759240a8b4865b0b8d86c26c98bd3d538242", + "0xc71ffc537d3b73c4d65d5ec902214853d0ca3a6ef44a38e578c0f12fbc4929f0", + "0xfbd5cea7e1eb5806f6f82efdb0e881576ab386159b1b3ff7402e4bf56a947d8c", + "0x58340ed8edb441d787ada6b1aaf2b1e42912724e1f0f7887cde9253262aa0534", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x66E210090aD8f00Cb3915b48ff4E67EaA0282053": { + "index": 421, + "amount": "0x01", + "proof": [ + "0x485c2b38c6c41c44292e4b13bd6223d8587bd45a3770049fa7f1270c66f529be", + "0x67dc31eb86ead2b664bbcd08dfbe333cbd85203640629b59eff787775194f429", + "0xc117d5a519f6e0f840872df99b897139406abd328261f34a6e382399bddb5bca", + "0xa5e8bb53f83c3715772cbf32d53d2e1c1c9b5abd0d51618f0e2ec2960d9a33b8", + "0x43f59a603c2458850547e5a84d47e61be843b4a3c814303ed1b52e1e4d37a1b5", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x66fD7B483c1Ec17a3968fE1A8bD42efB2afA7E46": { + "index": 422, + "amount": "0x01", + "proof": [ + "0x19d971504ce73d70f5ca62923e9f84a4cf3d98d9312d64a4a8e5b26e50113e7a", + "0x7ae87d7a29876f3cd8cac0feca7f681d230c6a6655459c0842b1eac0993607da", + "0xfe66f2955b7edabb48cb9446e3380701b161ec72c61f6ea4206263931d17ec7e", + "0x6b5b18bfb5c7b8de5b52219b51a21b6ff6e22d5cd7a147d521bbfac13cd7f7ac", + "0x93994074bdd819d668a79fc2c79be23cb074a679cd3fe03940945d4c6f9fa9b3", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x675F60d68701ed237e19B78152dE1a68f3500e2F": { + "index": 423, + "amount": "0x01", + "proof": [ + "0xecb13ea3940ee8b0b961ed4377987e92c2f4abf0d6b4e7f02cdfcf49f3e2b693", + "0x04d471b3f63fdfe552b833954e762dfd65f476994a6e4890b49e6222237e2e80", + "0x77487187bcb357b4188cf608ccfa3f6f329c635c083000f639cb79cc9e5b4cb6", + "0x338979409b1c886a92a48a505a3f0b093231b3d66119d999f9bcb41baf89c59d", + "0x6e496426985c92b04963088da4856230c781a975dbb5ce2d8eed77e7d2d4b58e", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6795F18D9B8F094121020FD46bA3c51E76caCE09": { + "index": 424, + "amount": "0x01", + "proof": [ + "0x73fae91f1bcf2dfabdea19aa5788492f7cfa84c2a546fd5504c0d6f76651cca5", + "0xd919d00f8f99817d7acb40512e59dfaa25e6d93bb8db81521771273bcaa8e359", + "0xd4cc5cd424ec4a17ab20cb4944d11cc81c6d34f1f8242f75b4f4111a721a2141", + "0x0dcce906ec5827bcb3dee3fc162b46bcd945486f9b95e6d9175120ea721c3e19", + "0x7abccb934a7f719fa80b9a5d3157e99d45ee17a391abf85d4f60839dbf3769cd", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x67D33CF1C7c699078f86D517A5a1cd1444A1E85C": { + "index": 425, + "amount": "0x01", + "proof": [ + "0xc814fb8a97c2c891ed2b2f219d3020c8c792cac3cba7e10097f71653ed7c1058", + "0x2ec1a43157568ee3f71eb3db2134b0beb5dcb531e5f86ddbe72dca4e015746ae", + "0xe4ac80d26c77ba89058dfefdaff6c557a8b7b9a413abd87f4e1ed3224c0d25a2", + "0x036edc84651a6e437d2aeddbd5e5d10d4911716f37c92c584d637f9f9ebb0dec", + "0x97fbe90108c9d6db20d511e4419e4ed044f589ef1f2a9f6539187bad21502f90", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x67dE64113d7b412d1E853ED66DFB7EAF7047d093": { + "index": 426, + "amount": "0x02", + "proof": [ + "0xa8010d617093019140f8036f78383ac1c7a76a3ec361d0d99a539d6fb5939195", + "0xd56b555d818336cea18dcae1ff76d8d64f7a213bb9bc6e31fbf1d927baf3298f", + "0x31fc7a90e64fedd0c716849f9c3d85d7bb0f0af21a85776a85104ce4712fea76", + "0x21367d58d52b32234887e9e91e468488a647d2d7407cacfa709cd59618255499", + "0x59d5a4275936eb4dfca0d17bab02b4a25bd4dc43ef3aa0e3515a07f7c0f68a93", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x683c6cB00DDE8605d44dd038f341528A16666666": { + "index": 427, + "amount": "0x01", + "proof": [ + "0x596c05536648df1efe68aa389a5c9fb8d88a8ef42ef150a3628f47caaa14211c", + "0x8b5c5f7cc90e98ef66e6fc6d4b4df374ebcb03878274494f7fb3e7f08a16b0d8", + "0xf605611ce1c692b9714072be746e6b2642baaa0e106fff51378e6de24bb39de1", + "0xd34d09ef2d0160dc3204b5dba612749c3a92de5f38fe30c9dfc3d0d199e36074", + "0xf9f105f90db6fe2970fb4e03b35654f9b69375879c783d3f1700e04b2e2f925b", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x68476977382d9cb85d11775B79252ee7d2859738": { + "index": 428, + "amount": "0x01", + "proof": [ + "0x701c061a9e4a0b0a04ca9311ef9a384d3633a154288f9952471d3fed2bf2279c", + "0xd8ecc241adb71b21090c3d9062fbf295740ba6152d7b65532e91ef4721ec2e4b", + "0xac8fd80a51422b299c5bf7ed366a10de6c633f04e56e7d1a93f0b71c220e8856", + "0xfe79a6356c4cd9282dab3a598f859bdcecd04fcb915a9edd66380a81697af3bf", + "0x7abccb934a7f719fa80b9a5d3157e99d45ee17a391abf85d4f60839dbf3769cd", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x68BB5a6D14CACEaB866037b1502565f5BbA17506": { + "index": 429, + "amount": "0x01", + "proof": [ + "0xf42d724ebf9e098450904176db8e110fe9a3ad94c2036d46301553264be51e85", + "0xd439ed65575104721c50c13d7272ad1e45bc19a9e86984bce0ab9589e0c70f29", + "0xb0010d722b0a6ca31a164d69fd41792020ef08e55c137f9e16186b7da6a1b655", + "0x3293f41caca9649b5e2565aa9f9ba63bf7c621850061b0b1b6af864bbfb07389", + "0xed5c942adbfa1d9538c55e89e4a7ff4276f908ac558913b5f43dce424bab8e0a", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x68E48c7A395B5431bAd9093b15558Adc46D0fA7B": { + "index": 430, + "amount": "0x01", + "proof": [ + "0xb54f5038ef92b559a1e676f51734ac14b0424b349d50fb56bfa8895e436bf7fb", + "0x5d919e51debf483fa3159cf633ae39a13dfe16d4c45d13c1d4ea5db1dbd217b1", + "0x180e1c5787d5d2cb7c3d1a878f6ef656de538e76593c3a78aa00ca9ac631f7ff", + "0x841ca200e81dde455c9bb72802b7b377b46a9d6779eec08b07e61939b8d43c1b", + "0x529f1b48ab616d4dd60f663753a7779d8ec25952bc8c34df4aa96347bdb0d542", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x68E8697AB23d7C74568D95C09862b95869C70dc2": { + "index": 431, + "amount": "0x01", + "proof": [ + "0xfbc2da681fd5d756971d547f6d802413c246b9da41c961966925d656e6642638", + "0x579f20e9e1d029b8733f777de11d92106a52ed5ffe80b41abdad04f1c7994a7b", + "0xa2bfc6b37e4189ddb762b679e4a5c9ece35447f0664935e074375ef5ac0ce2fd", + "0xa151a98046c68dc4de0dd4ca59fe7fff4ba692aa78310b499e772f0cf61a08d0", + "0x938890418edfff03e5d8f0abce65769ab79b16db349d2869a477500717305360", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x68c7dFd627f01D1fEf512c3F1b1CEf46ed78B377": { + "index": 432, + "amount": "0x01", + "proof": [ + "0xb2aa04bffd3d6665de3519c2ed22544b6bc2bdf74f5a757058605c9f37b857b3", + "0x7226cab2ff9b4e932dd8353e9d8be94a42eae77d74fdb63fcc8e7dbd8aebb36c", + "0x0826ae5bb3f37697633d99d3705ae48cde39e7b0d247ca8a78e1143ad8ef0c99", + "0x575d2e3f9c311244d801f96a2b4f9fc9666f8793f898d400d71e121add7f872f", + "0x529f1b48ab616d4dd60f663753a7779d8ec25952bc8c34df4aa96347bdb0d542", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6905B7A65ede4a9b1181F6abfB5Cbc122c661F52": { + "index": 433, + "amount": "0x01", + "proof": [ + "0x0557f147ff51576773ce76a1ff39677ae1f19c76a88015b4bad457c5a64c23af", + "0xe7434d9c0e857b8959f43a7031f7655e71f24de6adeaa653f113420d97fd3b65", + "0xfb73c958d3ccb8e44a37fe3c5e674c657e61258ba6390076a46270ed22699002", + "0x2782f91cb56c53bb349c99893dffa8838299f03f96c6519b56f604653b45586d", + "0xb18758ddf98cdeec3d020c2379717281f5c0fa0133be7d006f7f753c756da43e", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x691e1D2eF45d52c7CA946638B1400933592330a6": { + "index": 434, + "amount": "0x02", + "proof": [ + "0x9ca91c60915a8f5ba8be5cf5b6203e6d8a502633853cc7f53d9cf5cf3822d05a", + "0xca2821d5beb92f9642873e9ceb82d506320dad5ce984017d4118a116296817fa", + "0x0a6684890164794e3e646f48f9ca38abf68b10540785b90fb3834ade1e101d27", + "0x4e1a6e4b411d6f4beeb3ab0567980aee8895068f33d0f7cf833e4bc4887a1b83", + "0x0b385e4882f89784f506afafe6dd217c6ad9d142ccf58713e27961d25b2c6d0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x693AF77CE2c0b4287FB0acBddC9B36369A20dAD8": { + "index": 435, + "amount": "0x01", + "proof": [ + "0x5e3f2e12ad69ad7200c1d6496d3882952e28a66df7ebfd8345bf4c56f67cf534", + "0x6fc7c8af509151e1cbb2b27c3a61e6ef14f892ba565b0a9f88eb86f3adef9a8b", + "0x392e4357413d2c40440f7c7366dd2b7e4169a71d8580214634fe41a4c322d037", + "0x70db17f5bfc52cce1e5c71a7571d4c960efb51e88d7fc8b1162dd074c38f333e", + "0xdfdb156cb5d2b90a5253163570fe08739b17ab3fc383c79eb041c1d1a667fe84", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6957D2139d29E7DB7913ac21e813f2a561E47aC8": { + "index": 436, + "amount": "0x01", + "proof": [ + "0x82cd744258dc38f46af8b85845801e6690d45b9ec2604ea6906d7cb91eb10675", + "0xc795aa78d3489fef0249708334eca5f50ae6b1836de13fd7dd09eb6599a9bbb4", + "0x4e10e7f195c67618f3d3a7993df508e04ac06383b5ec9580c6c0aa53b1917d0d", + "0x13c4723f9c83e02f8e5d7f08a17afc4776844c18a0189a9fcccd2702d623254a", + "0x891a74fec62a569bdbcb44171dedc1926c5cbe5d803c0c17ff419a861e9ee5b3", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x696c1E8Eb2BcfC4Ad504E246cEEc6eC853265506": { + "index": 437, + "amount": "0x01", + "proof": [ + "0xffb81a65d57fbf2a34c6a1c00c85447dd4d4c971ccaa4625cdc418793391bbb8", + "0x06982195a071992891577e18eaf92fc56455693eddc2807f01d6a0ae9a3479e7", + "0x4f0777a7470c7d964ac693f72cf12d27e2160fcad1a3a0fb364048f8088e3278", + "0xd234d050330272d515ab9d9de470961bb799874daa015afb8d313d5141c5e8eb", + "0xa0af5121b49fc7ea34ad1f4c8308fd6e51803abadb614d1f15f8c87bf9fe29bd", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x697560Ec40177d9f3B450abEA56700eD84df7cEF": { + "index": 438, + "amount": "0x01", + "proof": [ + "0x552d83b1f96a60167cda047e536b3da61abee80a8c26e6ad5ebe601520a93e22", + "0x8c940500dfb9a5194bc0ab633ef9966c4fc296a8fce41bde7ffe0b3f67f7fad3", + "0xb38048ecbdb0d7a97188f59825c94f13ca314f4be11d86febd1cdf302e0326ad", + "0x9104efb4441e61a09b4e458e6b45f6759c37c20733b5823cc04f759cc53d5575", + "0x6ae25cafc683eaf0756d86c89deb0abecfbfd01e812ffbed4e7a26f11cb91f8c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x69Bc29D277e43F0a253Ca7bb79A72Da6da4BCBa1": { + "index": 439, + "amount": "0x01", + "proof": [ + "0x729a5c5972e3d74198776355374d94d85ca0f6dfef8b12e2a1683203d9adfa32", + "0x2182370a1e13111884e9e0d103fe6916c45bc8b8871e94e2764e1243cd3dd58f", + "0x8e6c137a880fc95bd5ee7752b07878a345c6c782dd2c5f54cd1429db575fc484", + "0x0dcce906ec5827bcb3dee3fc162b46bcd945486f9b95e6d9175120ea721c3e19", + "0x7abccb934a7f719fa80b9a5d3157e99d45ee17a391abf85d4f60839dbf3769cd", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x69b7F94fA8961A72f472Ac672693a5a117807c4c": { + "index": 440, + "amount": "0x01", + "proof": [ + "0xd0c113849828a71b84d6ebd798c819eed3f784767685b096cede08586d3247af", + "0xa2054a0f03c8e791e9bc91f47f943efd3fe29db48cf40805d468463baf7bb9b7", + "0x45b3ee84bfaab4fdcb6b276d32ba091b4d13fb4a3385b5d29d91fb477bcd0392", + "0xd549250cf81d453ab878cb87d004bd56f5975ca86398b00d651f71d522925a30", + "0x85ada07677b521b0dd2e0d60f51f92f7b1217f46e36379a5afa5a74fd5c87a5a", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x69fe2BADd12F4515AAF99E3a9956b9fFaE56f877": { + "index": 441, + "amount": "0x01", + "proof": [ + "0x40edafbaee00687b66ec8300691367acfc0fe0909bb51c8d7de0ae9886558cf2", + "0x8b566b277921d2b78a6cab9850dc5f97e85f826d814f45b2d443592b68c11510", + "0x6cb469a96723651e405715162b9903adfe081b56ef3c5c27f903302a7ba044a3", + "0x3ae549d14256824a2b8db4d8292224eb9b3beda41a6712098d825d2a32cc6dcd", + "0x98ba92b6a1d3418a3c44b684c9f0dc2177f48d3a6b666334d112dacbb6f5acae", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6A58D7Bd0CafF749C57c00AaE15867B33951dC0D": { + "index": 442, + "amount": "0x02", + "proof": [ + "0xe7db3272d853893de6fb989d1244296dff182bac9bf0c1d9b8965d4a26551a96", + "0xb8e41fa3fc49245fd80cb7b4052925bfe6eae4a5084af29171498e0e1501d15e", + "0xca244e046f3d59b7d6cc79bf3d79d36d4e16637e4322e4e66e83e8c3fc48a083", + "0x6029ed468a13d48547faf514f4c29ae1fc65bcefd1ecd17c26aeef29ec044356", + "0x7a545b345b30e441bb780a4fca731a87b1e941b75518a9983a312194a9e7bd46", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6A9ee69B6781C18164ee9F7C58f1763BcFfC7c51": { + "index": 443, + "amount": "0x02", + "proof": [ + "0xfec80a9a2224d4b30084fd64e441e2092ba8af13082b31ac13ace8382fa067c5", + "0xc9b2f7dfd9fb48559029d5027b617be4c0d10fb84f122769eab605723bfb0c4e", + "0x228366240da7e1e50c9fbbf0d83ef3aee5be6b101fa2d9de2745bc568f3857bb", + "0xd234d050330272d515ab9d9de470961bb799874daa015afb8d313d5141c5e8eb", + "0xa0af5121b49fc7ea34ad1f4c8308fd6e51803abadb614d1f15f8c87bf9fe29bd", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x6AF99E614F494dddF6B29F7D4F056Ca5A5bf6Ac7": { + "index": 444, + "amount": "0x01", + "proof": [ + "0x41b90767b922a37c4c6633693ed391e0b52c156357b2552e86ef3c28520198e4", + "0xfd22bfc81a6a21247d228d835e39e9a76330c90fcdbb9c6abfa551d616927a34", + "0x308e3c3f0424a4c813565e783cb4d79cc2927c1d11c780b46d52f0c53a01784a", + "0x3ae549d14256824a2b8db4d8292224eb9b3beda41a6712098d825d2a32cc6dcd", + "0x98ba92b6a1d3418a3c44b684c9f0dc2177f48d3a6b666334d112dacbb6f5acae", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6AbA1eF9953470646E1e4De37597b665a6a18bdd": { + "index": 445, + "amount": "0x01", + "proof": [ + "0x32ccb1785cfdac26db98082d7c035142158e70a18a1378072251f402316bc35f", + "0x4255b68f002660f4a1f68ac2c5699100762f34e0ac84047e1501eb89768d0532", + "0x39cb0477c1d663a69af4e075a8fe812a6810eac47e570c671a96d933ce996528", + "0x721f15749c8ad9759a4a7d682519f25f59a5bf74daab7275c00bac9f0ddc323d", + "0xd6d09ea62a0a0959d8a1f1cbd849b805597a75fe443bbbc4d5e2555bf8225437", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6B67623ff56c10d9dcFc2152425f90285fC74DDD": { + "index": 446, + "amount": "0x01", + "proof": [ + "0x18f3bb8bc3f3f84a5a6d7f260f541e33b4bb2d8242b95de64f6bddedbfa1149f", + "0xadccb699b553a9eb87afcfa8bbdba744ed39f16591a1e3c3b3dde43b861f87c3", + "0xf9aa43102404b84f14eba6125f677ccda1d14a7d5704168958698912672e9e8b", + "0x9259974d28cfc23eade84b4a12eba89f4b5d3b0064ca7ad3dcf3a6a6a2555c91", + "0x93994074bdd819d668a79fc2c79be23cb074a679cd3fe03940945d4c6f9fa9b3", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6C4077dc7281360B1F1eef4EE192Ad3839C0CC59": { + "index": 447, + "amount": "0x01", + "proof": [ + "0xdf05e665418b6d35395e758cda23ed47ab8d51a691311a22c2279fee686f2b35", + "0x16b5a68d45bd1b4a0b677c7305fd29d2942d1d93601d756ac76386d36544226c", + "0x1b6e78ed9f82ec1c3081d1383366405b44866f8b35969ff88549384d481f717c", + "0x285f0861eec4fffdb569c07f6f01125414c98685171578e7317ed5b8c16ba373", + "0x966715df220dfbe5e11392b257b61b64c18178d1825b654f95f67d7c9558a2a2", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6E56E7ff87b9D28BFA3EB58Aff1C4ECC0955b25e": { + "index": 448, + "amount": "0x01", + "proof": [ + "0x400333dc5b77fe94bbd759625ba1ca58db26415d01915ca05d829583e900891b", + "0x8fbceccd6e6484920af81c777735be8f05f7ee7b13e0dfbedbf53d52b89f6e35", + "0x8f2a101ee77b78dee9cb982af71dce833445b338ef84d162c17a123bd6df03bd", + "0x2b5ad2a01fbc178584e521e2b2e5c612407bac24dd9bf0c452060b71384720b6", + "0x98ba92b6a1d3418a3c44b684c9f0dc2177f48d3a6b666334d112dacbb6f5acae", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6Ec4DEFaAA028bbEe11494baaCb9067F083C359f": { + "index": 449, + "amount": "0x01", + "proof": [ + "0x681e89ce1587bdf5ca75d2c5be86c210dfd46d1fdccbbe75e7c74f928eee4f64", + "0x205f0c0ca16f55170c0661751a1e5df6422be81517d44622e0cc3498177d4687", + "0x12739444750a786d216e7862d022a412d833ffcaf4cf4f6b1414e14f4ff27db5", + "0x5fee000564bb97bedb499d3b5c01f147f4e4ad76f5f6443565804721f95dcda3", + "0x245190f95f5e09d43d1da7e9757fa066be1942b52f7e4962cbbe6a5f2e0981bc", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6F30E28368f444182368069174dF5cc1eD987058": { + "index": 450, + "amount": "0x01", + "proof": [ + "0x05572fb9f9048630da0302132c7f75c0506ba11a0b95c980dfe5b43f8bc6481e", + "0x195fe41aa4a5027de3e57f4b28b49d2fb42923ce34349b86387736bc52d939a6", + "0xfb73c958d3ccb8e44a37fe3c5e674c657e61258ba6390076a46270ed22699002", + "0x2782f91cb56c53bb349c99893dffa8838299f03f96c6519b56f604653b45586d", + "0xb18758ddf98cdeec3d020c2379717281f5c0fa0133be7d006f7f753c756da43e", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6FCbbaCCD027e8E29cDCEC8B340784cB699bb348": { + "index": 451, + "amount": "0x01", + "proof": [ + "0xdf40fc2020c8d34e19da1ef431c059402e0c153047a95c0349fab03a0eaa0231", + "0xc41dfe428693dcd917be2116df24c4e4eb6b01e19c2087e0949b91fcd731e59a", + "0x1b6e78ed9f82ec1c3081d1383366405b44866f8b35969ff88549384d481f717c", + "0x285f0861eec4fffdb569c07f6f01125414c98685171578e7317ed5b8c16ba373", + "0x966715df220dfbe5e11392b257b61b64c18178d1825b654f95f67d7c9558a2a2", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6a51C6d4Eaa88A5F05A920CF92a1C976250711B4": { + "index": 452, + "amount": "0x01", + "proof": [ + "0xa61449de30640a199aa71f60f8593d2137d77e0bda51bedc6727292eb45a30d5", + "0xc4af8683d87f089204d6e24c965f84bca5121d5e247e19e4ca2b1c436e43f535", + "0x749ec840687b0c3028d9ebbc2bee7d5e4b09957fcc6d0764cc748253b597e007", + "0xff4bbb2da92e4f9e24f8d79cfebe3e93428702c14b9f4cc9993761fab9d19c9a", + "0x59d5a4275936eb4dfca0d17bab02b4a25bd4dc43ef3aa0e3515a07f7c0f68a93", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6aD92C614CDC6FB65Ada60F809caEfC697daEF2a": { + "index": 453, + "amount": "0x01", + "proof": [ + "0x8b69e8422fdeb094ce3b303cd6d976fd928a42d9930ce99e22e13af71157ae03", + "0x5fb23e09649322695a74e48ae902ee984aae9f179ecac63ad5af24de31dd0c2f", + "0xeab5b9106c246e423a3bad13324b91b16f3f43030108260127abad6f7f52e76e", + "0xe04deda4b0f0ea0bda4320a7f8e55700dc470bdcfba68775214ca25f30ccc348", + "0x8fbc13f50b0f82a781945a74ddd5c5abde0b4a8983852c66ecda77a68df50722", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6aE81A901fB833A6f19F211Ee6D18D2AC0A87151": { + "index": 454, + "amount": "0x01", + "proof": [ + "0x03d38da628772091c59186a2947763c7958ad472dc5d4a0af22fcdeeeb0422c6", + "0x7d6f848972693b2380fd40104e619ae07ba94d0d68be7f7a26a277a832d3154a", + "0xce425cf8478bb52919447ea20d7a544c17358dee3ce6498f1cae3e3f0f173aec", + "0xf48849b03cf9b334d4dc7a6911b922272cb1a72dc4223db35fa6c699461d5f16", + "0xb18758ddf98cdeec3d020c2379717281f5c0fa0133be7d006f7f753c756da43e", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6ca323Ab76aa6d0C7406520f49795470662e9C84": { + "index": 455, + "amount": "0x01", + "proof": [ + "0xc8495b54fc8e1542296b5b7fb0da47277833e0e6d7c3731676ccc5554868fa86", + "0x4f2defce742d364dd56ee95d19e1cf0304d720105e0289a6c6406883b57554f0", + "0x040429b9a444021a6ff7e6c6ecf5b7ad469b7bc2acfbfd2738ff037f2995c0d2", + "0x036edc84651a6e437d2aeddbd5e5d10d4911716f37c92c584d637f9f9ebb0dec", + "0x97fbe90108c9d6db20d511e4419e4ed044f589ef1f2a9f6539187bad21502f90", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6d353892d35d8BAB33Cba7D8FebfA57f15DdFAD2": { + "index": 456, + "amount": "0x01", + "proof": [ + "0x9ba0f41e3ce904959d82d21a485fadb9724b9bca2eddd287d9e17bba151a057d", + "0xcd6b4952b042a60e11ea0287f2bd56d6fd7b8dae09d1e97b57efb84e331cf179", + "0x0a6684890164794e3e646f48f9ca38abf68b10540785b90fb3834ade1e101d27", + "0x4e1a6e4b411d6f4beeb3ab0567980aee8895068f33d0f7cf833e4bc4887a1b83", + "0x0b385e4882f89784f506afafe6dd217c6ad9d142ccf58713e27961d25b2c6d0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6d95b329944c630Fe5538167B905791b2b638675": { + "index": 457, + "amount": "0x01", + "proof": [ + "0x0e79cd0ee1cac50515dc8fb142cb6c29ad7568898c7d3a3c2fc12c103ff0feff", + "0xcfe102d511b2c5bbe3ccfae55610fec5d3b30b1796e45520509e73b2a410daa6", + "0x58fc0f95394c3d85af39af4ef41b7b5365fdab351fc36f9bff4ff8482e4ecce6", + "0x2eb27b26c39f3350831b9042b1a0e6295ae6da1b11f07f10b4a83da8dc66b536", + "0x4bab2069d20a5d1d2f5ebdb61803a57609b7709eca9e925e31a7d14434af1326", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6db0924bC39878F43Ef60AD38d392668Eb878b95": { + "index": 458, + "amount": "0x01", + "proof": [ + "0x58519ea166a04565f6a06198b9843794e78d802220a879ab258544c88f3b8364", + "0x0790dc7bcaa6c4d6aec3b9e0636578c0d57dd05721b3ec0594a7e74573105773", + "0x708202d8f80bdbf5dc568f0ce8b7b9af201381136571a7d967efe4f79deae3c8", + "0xe759b6546746269851513af2e7b90b699309ac7fd4eb1cefe25f45f6c49d094e", + "0x6ae25cafc683eaf0756d86c89deb0abecfbfd01e812ffbed4e7a26f11cb91f8c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6dc88B231Cd04Dd1b1e525161162993F47140006": { + "index": 459, + "amount": "0x02", + "proof": [ + "0x6e4265175317f373de3b4cc59da5acabe58d3b1a85c696300bfc285fb345618a", + "0x5c36666e9d0093e7f3a0fd67531c35f22dcce83b8026a1e796f2509c2f5bec64", + "0x6739f7ef27695db5e41ccb568aa848d003419a94df0c5b9293106f211d362171", + "0x7c0de9d8e837704a5bbfc4993fa9b20e3f698f1b885a0b593d018e35bb790c61", + "0x1be60ce906d0d73954b2e1f2747ea1c9a23db0ad9345fa6801c551f1a39fa5ab", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6e561FFF127d63E298d1B08bDbC07D59Fd748ba2": { + "index": 460, + "amount": "0x01", + "proof": [ + "0xa899be115f30820860394224c2d21e05e61932f11bce12e897e6891e8f59218a", + "0xe507eddaad7c3ee6ac6ab729bdb2eab63539051b2560f65e1914e4ab56e61aa8", + "0x94d660904dde29f38b66932719fbb6b3f61f23334c6bed78753e9db544ffe1da", + "0x68141ce9c9d3196b1db61f6e6c902aa8569304d1613ec750ac0ffed8af2bb113", + "0x32636a5315ca425c602832f925f24426ea5aec9939c73d1b2a6fcdace85ecae8", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6e9fe041e0bA8C2Af35215d900D188d53d7A9B41": { + "index": 461, + "amount": "0x0a", + "proof": [ + "0x0555d99c9261ac9ba97b46f172461a088e53fcb946c27d2559fe2a37a6c35cd8", + "0x195fe41aa4a5027de3e57f4b28b49d2fb42923ce34349b86387736bc52d939a6", + "0xfb73c958d3ccb8e44a37fe3c5e674c657e61258ba6390076a46270ed22699002", + "0x2782f91cb56c53bb349c99893dffa8838299f03f96c6519b56f604653b45586d", + "0xb18758ddf98cdeec3d020c2379717281f5c0fa0133be7d006f7f753c756da43e", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6eBD7c0d6D7B6bEa3F2Fd7767DC0e9992dc37Fe6": { + "index": 462, + "amount": "0x03", + "proof": [ + "0xe78e0df107c303f8737474c1f427d67cddd521e3860c8aca1956e39b706c87b1", + "0xb8e41fa3fc49245fd80cb7b4052925bfe6eae4a5084af29171498e0e1501d15e", + "0xca244e046f3d59b7d6cc79bf3d79d36d4e16637e4322e4e66e83e8c3fc48a083", + "0x6029ed468a13d48547faf514f4c29ae1fc65bcefd1ecd17c26aeef29ec044356", + "0x7a545b345b30e441bb780a4fca731a87b1e941b75518a9983a312194a9e7bd46", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6ee25007B73Fa79902A152A78cAB50f4f7fA9eFF": { + "index": 463, + "amount": "0x01", + "proof": [ + "0x7e7d1dbf4b0c8eca6f4499ff652dc4cb4479486306ba7e58cf93566fbafd4386", + "0xb89c4e722cdd0d6075de7d9d8ee765d16850c9ef47a2a732ad04135292da2431", + "0x56bf94bfd25613c3b1c53d93baba2a4d76e076069333668d5ba3da9f1f69ce30", + "0xc7b7942da27652b608d4a505a59fef704f26c49f0c2a23709d80122b3afab5bb", + "0xe2050f6c95c616c1cfdb04f4b6d0afb5afa0fb464f767c38aba0f07df915a97f", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6f6B15bcce6B2feE40aF3C32a8547790ab2aA275": { + "index": 464, + "amount": "0x01", + "proof": [ + "0x8a2f00fc4112cbe7cd3babbffa91675826849ee54fa00cea4728129ec0763781", + "0x66f977d5e1dfcb7bd97f6e37835fbe791e6d0daee4f0c72bb998bca8aeaa68ca", + "0x62b2963c1057263f03a882a1c74c6dd227168b925fd226563d397200dc561e0e", + "0x0c15cd0e5fb4411c59b182f983d4322f33d3be8bd2c5425b705021fa316a402d", + "0xe4fc54838dec16cd3ac94713f191dc41ac7f5e070180d4843c9aaaf9c71ce29f", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6f70F8C55A0A187BeE0202F5a85d9b43b5d07296": { + "index": 465, + "amount": "0x01", + "proof": [ + "0x993e077a4f0c2db87dfc1d5a56244a3820be974e19ffd1912ffd82dcf15ee2c6", + "0xc6d56ed1e881993b8040ac45d275f6bed4af342064a864de32681015f370bbb5", + "0x8b0939c5da9a4351dcc809a063b8226bb4eef5b67c44f5015340b9723d256a41", + "0x0209cc90d619e0e5f56081126d2ed4018391f3d9e1dd1238794235d656c68c9b", + "0x62ba7b58fd554e8be295bf9d4baf9eefd0b518ead5cb8bab321717a08160ae0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x6faCf564dBaFcAF142CcE4fBEA8FCa108bB42408": { + "index": 466, + "amount": "0x01", + "proof": [ + "0xf31277a3020adcf1e4f9015bbb28150424615ca6a8ebd147b6a9990bb909e571", + "0xd9e05ba09015e9481504b532a6a889bed7b6b1bb2c80ab50514e9d57015413ba", + "0x4fde23ae7d8b91b73ed7665e54d03801fd1fde8acd49d16d146cc40a2ff9295a", + "0x7caec6cdfba66dc7947ce7a10af67bf36737d573f70c5bcf73b71057ac86d1f9", + "0xed5c942adbfa1d9538c55e89e4a7ff4276f908ac558913b5f43dce424bab8e0a", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x702E9e66A100881039bE7BBadaCF1BA607C97f6B": { + "index": 467, + "amount": "0x03", + "proof": [ + "0xa2f2913f8f7a7c075b939e3f367171ae90b2bb90a9bdbd4a2cc7c1aac3340487", + "0x79ec05ec13a307e7f5601eb6bde69b5ffc24db29a4e4b2481393ee472082e482", + "0x91479039fdbcfe3f9e57c85a35424ab551f951e96197067348c757ea7407d64d", + "0x9d1cf6e9f51d85a77dd4eec2524ba22941ec238f140f4f63c1712d78c1e4c21f", + "0xdf701aa8bdb3ffefff1b359214087cc585fa0a0d40716a6635a8d2db4380dba1", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x703a767FB6A56dB0888D6A3e56FEdB169B39F3Ec": { + "index": 468, + "amount": "0x01", + "proof": [ + "0x6a5294bcd1ae2b50968c769f64dd701339de5c929d8def999c4d75b80114ad34", + "0xfe1ecd3f8cc7a1a01aecda4933fef22f9aa17eff1ae0adc7a02019bbfef8d000", + "0x1390b60f90b43662c35607eef4b6d21963963777720b34f19533e009d75b03e4", + "0x283f6032b7beb32fcc6ac4b21c9941360bce453787f78b6251c38e3890b83a8f", + "0x1be60ce906d0d73954b2e1f2747ea1c9a23db0ad9345fa6801c551f1a39fa5ab", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x704D907FD619fb1908F08615623d7d10D82bD442": { + "index": 469, + "amount": "0x01", + "proof": [ + "0xff86eb9f8aa0299cc8b6c7da9234f0b47566392653453739638ac079f3c07707", + "0x06982195a071992891577e18eaf92fc56455693eddc2807f01d6a0ae9a3479e7", + "0x4f0777a7470c7d964ac693f72cf12d27e2160fcad1a3a0fb364048f8088e3278", + "0xd234d050330272d515ab9d9de470961bb799874daa015afb8d313d5141c5e8eb", + "0xa0af5121b49fc7ea34ad1f4c8308fd6e51803abadb614d1f15f8c87bf9fe29bd", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x705415B435751eCc1793A1071F8Ac9c2D8bfeE87": { + "index": 470, + "amount": "0x01", + "proof": [ + "0x2203a757c25a0141ec64dacb05529312defccf218c7ddfee3dd9df8f7b51eb2e", + "0xcba47d3e3066624ac5fe167f8941130f54ee55629bb1146e0c3a02dd3dc0d37b", + "0xaace454f3f03cf0e0a3025941926638c00df7354ff9ef7c7ea1df6506661ad57", + "0x7076b49e1dda289a132a67f2f0be7b87522da84294f2302ec4d61300a0630b79", + "0x6665ebe68e892e4e5135c09f9cdc379628aaa60a8ff322ed2ba75fab3b3a9cc0", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7073133dff534A2f5f89dA04a5cDB792d047Bc6E": { + "index": 471, + "amount": "0x02", + "proof": [ + "0xebce361d7405f5d0da5dad4f070b417f10c6f37198bc9d92f1c25b17b97b3ed7", + "0x371965ce9f8412c1254b74d648ea441e40a1f09b6e053522ec33c791ed931a3e", + "0xde0c48888840a3a312e45aefc38e872d11021fbfb1c21f69dd0002cc3205c985", + "0xa6bb3b2aef22e52a1e0052bc5777bac639d24ffe832889b483d829660c1bbc1c", + "0x3ac4ae4a4697e2400113df3bd55f84456aff86925f45224af80fd8af20592214", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x70bE2bFE60d875FAAd5922F2379aF1a0AFC8e754": { + "index": 472, + "amount": "0x01", + "proof": [ + "0xaf21c615d3278a0080c95474c14f2fb0ed56505eca2785ad5dabecc1237be25e", + "0x884dd9c990148c637adaacee9e32655aef34b57be5e027180f902bdea3294f9a", + "0x9bce549829c21177902c8beec5ddfffba1cacca3b9853a79de10a2978d74fe13", + "0x577f81e56558cea5cd9d5160218e718fdbd9b124f0dd5499c3e14a238415b645", + "0x72373ecc225af245878bc638c49c8901db1430b7210a3008231acc8f8118d2e0", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x70bEfcb944275e3AD3A64a6e1C9cfeFaB48B3E2A": { + "index": 473, + "amount": "0x02", + "proof": [ + "0x0cd905682ead5923e39f1dc69323143fd924351876dd1363d7507a5a771570f3", + "0xaa8559fbbbf33b202940a5ad77168275bbb3174d53b9d138da00e70463150448", + "0x1ac17eae005e68d333e431b1be274794132926bcec9fd36924d6e7e39904133c", + "0x979cc6c181e08190bb233f0cf5b0f7b487d9aadc675c9326a9af9732d3369d45", + "0x4a36dc66177a8394f6b14fc9adbe4ad7e0cc2dead6acb72d80990e336fef8d45", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x710049Cfe15475b24D587CC2bF5fFa2007E7a9BE": { + "index": 474, + "amount": "0x01", + "proof": [ + "0x849b4fd3d15fb73d02b9a04616c318590d7606ac76d0756eda26130cc2d481cb", + "0x11e2c610b943d7d1768b63b84c5b383784c1a921990c4060813fc08cc72621f4", + "0xbc2dc753cf42a1935c4d0a0882fed8a90a12f1c0a70573deb71cc2d70b40317b", + "0x02cef8ccb3c7906e41a7ed9d223c95f320f2860a3d5a5dc4598d02362970eeec", + "0x9dda7d74fd49fdacbeb3afcd37c878516159fe4b594e491ff7ecbc80fd8d6808", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x71535AAe1B6C0c51Db317B54d5eEe72d1ab843c1": { + "index": 475, + "amount": "0x01", + "proof": [ + "0xf8c5c696344559662fec3c43a3595783ba7813060f92426e441eba1620acfd98", + "0x275894f0417cecd9b43c98723a1d5ccbaab7fe97d29415a58006d94c8d87eb84", + "0x4bf5a604b9a09c347e1aa7d41b0a7679a3e791ff15d6e96a280af113935ff733", + "0x3aebe8d88cbaf4043e28b3d6aad9a1f79bda4dbadcd2f685785a58d155fbcc50", + "0x8e7f75ccc4d864471b1a7ec71efa29a4e8cc4761c26a6987c8043d9ca642a2a0", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x7201A03996C502b124acf2A10DFAe55C13FE99b2": { + "index": 476, + "amount": "0x04", + "proof": [ + "0x1cec1ae06222c3c8e36f569b17d1a7b11dec949bb7948585093e16992779b31d", + "0x367fe41342aea0d28e1794ed9398d6527b09b14ac4222e064ba29a38f2dd8ab3", + "0x702557a325e5dfca211cf992bed4c7d6442ba5a9ca061e69640a79660a822710", + "0xc2b85fb7fbdedfff6c0826f89cbeff5a93f827eeaec8b16d80424b138de956db", + "0x8e0cc5c13324dce3ab0f042d31a9db04afe0918f70e3f4515f43739791621c97", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x721D8755B8bbAD8D3ef7829C87b68C48Bb8A9b0E": { + "index": 477, + "amount": "0x01", + "proof": [ + "0x6ef706244197544c1558de6ad731b92cead127ac6d77aa17561dd650d1ebf09a", + "0xe48907b05d0e777121c74b9df4d132da8222373c7e82e518957578d2ea67a9e7", + "0xca0621c350e7f4c10764a38942c3df34cc262e74fd6d9d2f4434fbf0443dbea1", + "0x7c0de9d8e837704a5bbfc4993fa9b20e3f698f1b885a0b593d018e35bb790c61", + "0x1be60ce906d0d73954b2e1f2747ea1c9a23db0ad9345fa6801c551f1a39fa5ab", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x72E9F58607055f44B37373424E543C380a55a2D3": { + "index": 478, + "amount": "0x01", + "proof": [ + "0x75d1cd1af5d1f04945ad0ac051bbe51542cb394cacddb2494120fd545e6d299f", + "0x7a516f6e59972f7d280c11dc5a969121ff19dfad19daf2ce131c82ad7605d370", + "0x6b1d50c8f881c6c8993f73ba91868e17e454e5d10e04868fd2b9002bfa1fa4c5", + "0x2542d5bed1352bb1dd1986da7e22c1f92c0eb7a7dead185e5100d7004e8e054c", + "0xb78cb1aa869958030ce4a14b5fff6309166225c83e0cdd2b91deb7b1639f67c4", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x732A9FaCD1bdc6eBD927114612EC93610A36eE66": { + "index": 479, + "amount": "0x01", + "proof": [ + "0x50439837268f3ebde34b2ad4100de85d38c349413086154eefba3085fcf03e99", + "0x42921ed36435b47cdd73309952b5fae6365d4544976aea9a02671c14402134ee", + "0x10a0bd36bc8178ed9ea5da0e54219676f892a56ce312bd591118a0c3902c3d68", + "0xde9fcf6a43c240e1d4c7ca780516b34aba68d02c35c5ad3090d1ba1aa8d40999", + "0xcc9986a7987738d81db64db86f583aed4fde214b766f55d0f15a876c8f790fb8", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x73489f06af6105cC6816C8F5bC2c063Df9A643e7": { + "index": 480, + "amount": "0x01", + "proof": [ + "0xec7703abddf1b24ddba125375b8326e9279e3a88e1c66f794b5ae55133f4ff8b", + "0xb2bbc7ec4d0dd075b47f1aa696f7a532fc23f61125da3784096070efe2d026d4", + "0x77487187bcb357b4188cf608ccfa3f6f329c635c083000f639cb79cc9e5b4cb6", + "0x338979409b1c886a92a48a505a3f0b093231b3d66119d999f9bcb41baf89c59d", + "0x6e496426985c92b04963088da4856230c781a975dbb5ce2d8eed77e7d2d4b58e", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x735660e3c4049988393471d60817F0983852Aee6": { + "index": 481, + "amount": "0x01", + "proof": [ + "0xe50d4edd099df0601ec1a2be64f924226dfeee22b45b56eb957f2d0e8de68190", + "0xe4d3a1207c58c789f1eb6f8d5714fb54e6551757d5ddb0fd5c246ec39a3b4bdc", + "0x8cfcd40e91f96163b5cf64d309e176e363224f3a7be5b7057c9ec3c6a7181408", + "0x372cbc91aed35f80f87f2c13bba747106e9ece94f8d166e828a5c70b321c5528", + "0x7968b2383e3b914ab3a36580b205f1449b51563630c77871f712e94743e3bf39", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x73E5c3aE8cD76DBb873892aDC289319991CE814f": { + "index": 482, + "amount": "0x01", + "proof": [ + "0x8c10dea5c2fd0729242b49f2c347fbcd94b672e1448890baf1f80ebbb1cb174a", + "0x76ac387e248077a9d14055824f94933207c3417fb65ad9be71b47383d2dd8ac9", + "0xe1eadcfc59183c7853b885552d4ed0af4a4691e55309e8d127f67718d28a68db", + "0xe04deda4b0f0ea0bda4320a7f8e55700dc470bdcfba68775214ca25f30ccc348", + "0x8fbc13f50b0f82a781945a74ddd5c5abde0b4a8983852c66ecda77a68df50722", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x741bD2e9cd525D1b88972b32b0Dba5e257ce8978": { + "index": 483, + "amount": "0x01", + "proof": [ + "0x9ef67f13020a7fa6dc9d1702db67c55815f02a639ae9a0139296d3307b0b8974", + "0xe28898e88d213717bb65da16f880dee507da43bfe760c044d587438005ab51d8", + "0x2fbab75f362970937a06d430bd893a654663902ac95b78c258989474b316ccb6", + "0x35b38a743320b292e89d9164e2c2e5018fa2478f9a132ef65671c9bacfe611e9", + "0xc36c52715656389b2693c145860adf3b1f3d4d24a139850b1fa5f2236456376e", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7494Eb2916CAD8649F4f91eB1DB6E20bE605DAd6": { + "index": 484, + "amount": "0x01", + "proof": [ + "0x738df447885cdcbbc031f178f65c064edf2fbbe9e6390b438981c21ed6e9e9fe", + "0x33f5b44265174df5a561273a42732cec68a31179b1519b8905e3d5389803eda6", + "0xd4cc5cd424ec4a17ab20cb4944d11cc81c6d34f1f8242f75b4f4111a721a2141", + "0x0dcce906ec5827bcb3dee3fc162b46bcd945486f9b95e6d9175120ea721c3e19", + "0x7abccb934a7f719fa80b9a5d3157e99d45ee17a391abf85d4f60839dbf3769cd", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x749E1d15d3d461469BEc674575c2B07dd0dBEdeD": { + "index": 485, + "amount": "0x01", + "proof": [ + "0x944827057ab7563aa7bf3021e4c3ee47d7860d279d37d3b595ae80040c06df26", + "0xca27fcaa9e81967982f07653736dd0548e8cf3de0e669cd2be87a5a1945bc349", + "0x65127a802606ae04f5ee9995d26ca3dfc8479c1a808782e60eea9ed7332ee2f2", + "0x6ebf988ef586adc2237357c1611e0a6bf7170af1257d42fb6ef98df1f5052439", + "0xea7c0076ebef0c429d544548828ff19d5600136801cc28845bdfa9990d97a058", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x751893105B1eCe3b7fEda367B92Cd1Bcf2Abd673": { + "index": 486, + "amount": "0x01", + "proof": [ + "0x326af7c9089f8bc21e49229c32dcf692e61488e2f98b0754bd411708311e69f8", + "0x7ee6a8a9db2cb4d3c7101f89bd0781f97303b41e441a1d4b933387eef9b1f957", + "0x0cb9cf742e620c55a260b746926eab12f725e11bfe56426413054bc3c2d83746", + "0x721f15749c8ad9759a4a7d682519f25f59a5bf74daab7275c00bac9f0ddc323d", + "0xd6d09ea62a0a0959d8a1f1cbd849b805597a75fe443bbbc4d5e2555bf8225437", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x753e0Fb90EC97Cf202044d4c3B1F759210f4D8D1": { + "index": 487, + "amount": "0x02", + "proof": [ + "0x503c20f6a91d78190cfe97c2c953f2f992249b5c55a140038c4fca3733a75ea8", + "0xf27535c1fcc45333536c098b69bd0c478ffa501819eeb533f56a2075c5a4d6a8", + "0x10a0bd36bc8178ed9ea5da0e54219676f892a56ce312bd591118a0c3902c3d68", + "0xde9fcf6a43c240e1d4c7ca780516b34aba68d02c35c5ad3090d1ba1aa8d40999", + "0xcc9986a7987738d81db64db86f583aed4fde214b766f55d0f15a876c8f790fb8", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x75448866cEe7A4680dC58FE846446aF71F9f8438": { + "index": 488, + "amount": "0x01", + "proof": [ + "0xf9b0d4dfd18a87ca7b315a25cff18b884180a10a474bb1092e03d65108f793f3", + "0x23fe565318d11bbd2742a130623a8c3f9d59dc6c74a82d09a44722ebf99e19f5", + "0x3708d8178885b9269e803b79a4e0463134629db473cf8c80861afeae7084931d", + "0xa151a98046c68dc4de0dd4ca59fe7fff4ba692aa78310b499e772f0cf61a08d0", + "0x938890418edfff03e5d8f0abce65769ab79b16db349d2869a477500717305360", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x75505190362D39876a63aba6bcda940d179b98aB": { + "index": 489, + "amount": "0x01", + "proof": [ + "0x160dede3136ad40cd300c9128278ed0af24835dba3816191483700a8198a20cc", + "0x194c178a319c8d63aec64d8ab9c07d4444bf1a1678d1989d2d42ba851304c162", + "0x6ad3e4f2caa71a096b05092a987778161c94be804760a6af684872b249faf74a", + "0xd4e406b94f7009e26e52781d8bbbf71780c9ab5d8d7b9162b8469ca115683ffc", + "0x6431c24d3d46ea6b0d1959c0de03265dc474d3e67139f2bedca26b5aab0c0c5b", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7565DEdDCB83a14B185eb9520914bB918cDfE983": { + "index": 490, + "amount": "0x01", + "proof": [ + "0x5baedd77fb73439d7789229098849edbaa82ea74607ab6a8fcca4356b7d7b70b", + "0x6406e0c7b04b98936d48bb060745f5d7034b02e4e01c28519641943d242097f6", + "0x1e238294161409acd6c7ffaa2d08bd09d6a95e15ec21b6d1eed1c519054307f7", + "0x31f1720e10e01b0c3f193ea7a34f44234d915ebd6c8260e1b72970bca0201b09", + "0x140105e3fa17ce783a651f2281967c53a37a748c29442efd53ee24d8a1cff6f5", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x759dE6B9806A5F695B8FE92f58a6771fB5DB52C6": { + "index": 491, + "amount": "0x01", + "proof": [ + "0xe5f99db8332d3f70296b4f3c418ad6d34c3c6b99d175ea357b1acd67756e8694", + "0xffd2172389a725993abc199482d9cb8f1b9154eebe3f0d9300cd77fe4a94b491", + "0x7d7f94570c5fdd54e865230be00712e816eac4c23f4dbf19c8566a21bd0c5b95", + "0x46903c3e0f26b709802c8a2743505337728e1f805b4f936ec91df4b3f43fcdb9", + "0x7a545b345b30e441bb780a4fca731a87b1e941b75518a9983a312194a9e7bd46", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x75DDb7aB958135bBE2DaB48D6286826f6aa5E3b4": { + "index": 492, + "amount": "0x01", + "proof": [ + "0x76f5954c58521fcacdfd01fbec36f1ca1417567d0e1280d4b139998026105cad", + "0xf84571833c91665a6474a6810751b281ffd0ed7a81d1c52bb39837e7e9025ade", + "0xffaa2df36ce81efbe18a3f705e17efe3acf4e87e4d8a4423f01cfbe9c3278f32", + "0x08cb8a426c97a85d30cf9308f5228aadeeb1f2c3f1f22bb2fd0d6c1a680a3ff0", + "0x80cf615f05f15e9ed665dd7df5d086fcb70ed5a5086e02db7c08752fcaab6507", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x75FE6F258856dfbAED3e8460033cc4E23eb0e6c4": { + "index": 493, + "amount": "0x01", + "proof": [ + "0x613bad9e5e5818c5b0f47c3f77618d2b9dc130e4f0fb642ba78aa1d31bd95a2f", + "0x29efb108fbae46c2d17bcbd3e95fd3a32a70c89bee19d6ffcc8f682855d6edac", + "0x0d0aad0eac33ef90a443928440ec8982d70996c767cc18a515c491ce4412a27e", + "0xd1cbda0650121cdf56f6e9fac417e3ddbcea9364da64e4e29c3e50fa61aa56bf", + "0xdfdb156cb5d2b90a5253163570fe08739b17ab3fc383c79eb041c1d1a667fe84", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x75e1cEA2f649dF89F70Dde71EA934b1c6Af19C35": { + "index": 494, + "amount": "0x02", + "proof": [ + "0x8b598a84b3e1cd58e6c1a5af443699f2bf46e94d30998a2dfc3481ab463f025a", + "0x845212089b665de2d81bcc7f905c61a3f7c17bbc31a04509bf09ebd63ed26aa0", + "0xeab5b9106c246e423a3bad13324b91b16f3f43030108260127abad6f7f52e76e", + "0xe04deda4b0f0ea0bda4320a7f8e55700dc470bdcfba68775214ca25f30ccc348", + "0x8fbc13f50b0f82a781945a74ddd5c5abde0b4a8983852c66ecda77a68df50722", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x762d0629c46a1D6EC9D83F0f146F177922333039": { + "index": 495, + "amount": "0x01", + "proof": [ + "0x0e4b0718089e512cfe2cd46ec225c6b20d7b7dc7e7ce302a27df9371cea4ef0e", + "0x678751dcc192a114b1934b681b661c1eb38043deaaf0c645bd99a17346b5dbf0", + "0xcef2c8add76582c68d291ef22132fc17c35fa5b70f010e8c9388f4a93bba288f", + "0x037fa491e4b6fc74b9dccf3175d28aed9f5dacdb75dd0fc8e1154a0704619620", + "0x4bab2069d20a5d1d2f5ebdb61803a57609b7709eca9e925e31a7d14434af1326", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7663697900dd93A6D4722bc150d8e3A03C7B4866": { + "index": 496, + "amount": "0x01", + "proof": [ + "0x7ca2a830717b5f1ccc519c275d160bea541e027b69fa74edaaea5bfaa4d71b16", + "0xb953952d6c435ba5ab258661436efb2df00bead87eb57b251e0062b3e500c841", + "0xbbf16f648b89bf5c912677dc67e477a51ede03df7de459ae6574a364b5f12c66", + "0xc7b7942da27652b608d4a505a59fef704f26c49f0c2a23709d80122b3afab5bb", + "0xe2050f6c95c616c1cfdb04f4b6d0afb5afa0fb464f767c38aba0f07df915a97f", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x76B687cF4E5a4e73Fa3950D6cC642bCC64e40B88": { + "index": 497, + "amount": "0x01", + "proof": [ + "0x3f0fec3774c255b882a3cc2a70c7274ddb6ba981dcc2d552c531d0d3e6545fa5", + "0xb6e6281b7df56810176d16d01e79bd305e47c7b0e7f749d0dc6a1423c144bf03", + "0xbf879dd33cf8e5652f6897331b6d0be05a0d269a02431e4143f50adfeec86fb8", + "0x2b5ad2a01fbc178584e521e2b2e5c612407bac24dd9bf0c452060b71384720b6", + "0x98ba92b6a1d3418a3c44b684c9f0dc2177f48d3a6b666334d112dacbb6f5acae", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x76Fa5876ecEf7Cecfbe8f94566a1E7252C20BF39": { + "index": 498, + "amount": "0x01", + "proof": [ + "0x477a2bdcaaad8f1dd904a434b1940f32e57bc78d6f71ce77b89bf3f253670df1", + "0x97c775f7baf06411d34f1581e91c8e0966e8ea8fe92fceb8db9067005537537a", + "0x2bdf090ce3f01130e644c85626d9e4c382cc0c53fa0abf14823a72643b52ec85", + "0x7327dd8ef29607aaaef9bd84ab3718158a620b3e164df6976909aaef215117f7", + "0x38d4a740f3f99a827703ce6725923277f058619e98435b28078dc5b994e00a6a", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x774Aa0a8f5b41cd71d2af2145e898539440A00fF": { + "index": 499, + "amount": "0x01", + "proof": [ + "0x52bf2aa678f40aa3831152acf3bc6f3210ec799816a4a6b144e46c44ed646e4b", + "0x3a4ef6c43a568adf02bb5f0dd86f51eb13bd18b23c9c6ac87db90f9bf8517839", + "0x41a070fc9cc72447357345f29cf0f36b25fa38ec3250d2f34d6a05451b8da742", + "0xc7b00ce40d9d1f9a2921254e2bca646cf3992fb2c667a15215723d1f5a1b5352", + "0x5477c93aa7e191fd8f76e1976387fc82460220dfdcee87f9ba8926f4e0ddf45c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x778A91aDED77eCA765F4B8425eD54E088089748E": { + "index": 500, + "amount": "0x01", + "proof": [ + "0x2ffc7d887fa4dc73d69aeee85e8c69de0354144807b8e8ced101fa87a66e2e9d", + "0x0bb680215febc2981a0324aebfd2aa9bec236997a200749e08ddbf283572c109", + "0x877e3afc33780706a52d195b5d99278bc7864ecda90d6ce301c78748b13247db", + "0x7fb8279a3bf6834ff5de6f30e4ebf74889d64cf70547e9c78a27d7fd86516478", + "0x4325701890e79e85b41231157c1ced07357ce871ed6fb4f233c2f82c38bcf4bb", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x77AE5ABAa04097FcB1aF6FE7B9b608d48E2a5582": { + "index": 501, + "amount": "0x01", + "proof": [ + "0x06feb49de9143a09dbfe17893092f0f38be98ec49f9f5f4375e49d63e70516d8", + "0x101083adb9c641c2c07d6cc8ec952fdd16db10c63d3148734e4a5fe2de96ba53", + "0xaa1e85f59373f7e7d78afd5cbb2e4e9873713a471b7ed5f4fc18db819e0c2cc1", + "0x16c0b121292408782518c2e86352704bdaa5fb42c434089ea6fc2adde27ce492", + "0x6e752d8572dc933bdf463f24751c7070d8aa74bb8987a5fe56dee3b0c9f53450", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x77e125D23e6C0D081086F0D849b4350ea6206A8C": { + "index": 502, + "amount": "0x01", + "proof": [ + "0xdeb32b803a6812ad478c04f31d42faa3200e4e4d3f03665b0b3b1f8b0d88bd12", + "0x2b3965dd058fc966056ca32f21582912b205969e026f50371589e6d9d7486be0", + "0x31a842d521aec1d044113ff905ab1b4cbcfd79d2a39867e544a17434c3fae105", + "0x285f0861eec4fffdb569c07f6f01125414c98685171578e7317ed5b8c16ba373", + "0x966715df220dfbe5e11392b257b61b64c18178d1825b654f95f67d7c9558a2a2", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x77f803E81620dD4F9565d4D267FdC08Dd37695d5": { + "index": 503, + "amount": "0x01", + "proof": [ + "0x90ff599f96df11f7a87e923c7ab158bd6339fa3ee3f6b6fce449b2e6712d0bd9", + "0x8c6873c2a888fc4c2a07af4dab22058285b817378603ff3ca6a025998eaeaaa4", + "0xe08ba4e5ddf5c7b3ab07672afdf53c0a975a407af8a156203f47781efabe266e", + "0x0a650a18b5dc7e14051f590d1612c3614c677cc931a3bd72443efdbdec9b6fb6", + "0xa4e0ebcaa65c6595e7c7f0ffb89992e2b9cb58ac405c81aff220fc4b16ea3b6b", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x781b7177c43589ccD00B78cDA8d851BacD18dB74": { + "index": 504, + "amount": "0x01", + "proof": [ + "0x10fe12f125586bf2206068144625d2b7f8bc8b568fd531fed0f2092aaf922651", + "0x4c1cbbe795567fe73702ccafcb7210ae8c0400539910bddec0f986a073a2f5f4", + "0x2d080e14bc6209922a0f1386a059fdcb9274a63e7b85c402a8d63fb6bfa35125", + "0x2eb27b26c39f3350831b9042b1a0e6295ae6da1b11f07f10b4a83da8dc66b536", + "0x4bab2069d20a5d1d2f5ebdb61803a57609b7709eca9e925e31a7d14434af1326", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x782CaD9b8cDfac2D3f2811Db095d9Da449BA2cda": { + "index": 505, + "amount": "0x04", + "proof": [ + "0x8d75ecd2e0272053e27a4968566edb83f1a7693d54b3d58a19b187fcd0862928", + "0x52d97e18c6ecd74ae787f920c503bcb0c610d6485e034834edc41ab4343024ec", + "0xe0327321894dc1feb38e3fe36a354623f4288831a6705367168694406a92d9af", + "0x7217bacc0b5fadfdc27aef27f3baae246ba909c02961594a63bb24f24958cc4c", + "0x8fbc13f50b0f82a781945a74ddd5c5abde0b4a8983852c66ecda77a68df50722", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7841f2064bBaF90127CA0eed5b004020BF9ca819": { + "index": 506, + "amount": "0x01", + "proof": [ + "0xba959f6c821e2cc2fa0fd23c57eaed75a9af8c4860dcd494780b189f2155aabc", + "0x105b0fd2045a892c68ebe3190f20358a4c20be5e34d4536d800731397cd8fb61", + "0x3017eb0d540f971e8043a85f710c1ca576ba8ace44cc77d31d57c352236b7562", + "0x6a8275b9d29aafc6358bf9f174b96a6a2561ace2c21d2edeb2a14975f0d9b0c1", + "0x83e262e483a6f2ff9f4df14637dbbdfeddf0c6b0b4ca462c4375d29a3521e052", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x785bC2484a15dC9a8B644024FC142E8BCa1289Ae": { + "index": 507, + "amount": "0x03", + "proof": [ + "0xe530c6f930a46bfc6532b09f19d410974669a103be96898152cb4a9ee58dc19a", + "0x6809097d611115209e736cb5e30ef2f12f4e3424b70eca20ca114de2157c7ecf", + "0x8cfcd40e91f96163b5cf64d309e176e363224f3a7be5b7057c9ec3c6a7181408", + "0x372cbc91aed35f80f87f2c13bba747106e9ece94f8d166e828a5c70b321c5528", + "0x7968b2383e3b914ab3a36580b205f1449b51563630c77871f712e94743e3bf39", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x786c9Fb9494Cc3c82d5a47A62b4392c7004106ca": { + "index": 508, + "amount": "0x01", + "proof": [ + "0x7b92fe4ce99825e74efb91c2879a843928b91a480a62d0ef61dd411ecaf42280", + "0x839ceec5b6fe1a21ae420c1924b51de25afb51ce6d517ebae262ca9672873a21", + "0xbbf16f648b89bf5c912677dc67e477a51ede03df7de459ae6574a364b5f12c66", + "0xc7b7942da27652b608d4a505a59fef704f26c49f0c2a23709d80122b3afab5bb", + "0xe2050f6c95c616c1cfdb04f4b6d0afb5afa0fb464f767c38aba0f07df915a97f", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x787b4b7FFEf8edDaD54F311039aCF4c36FEC9593": { + "index": 509, + "amount": "0x01", + "proof": [ + "0x50d8856ce6a43ee3b16983cbae5941bebf15494bc5c6de23012b474c60499e09", + "0x42d1ff6d77f8a444cc01a0f74cf0fc10fbd154ab12d56fe95a0fd9d12a53ba5e", + "0x94ae5af5bdf40e5d21b91608a4452d0ff68fa67ab1aba8eb3e2ef57df1ed7d47", + "0x60ea05c082bde3732ec3daeb0e2bae0395932096e755b1a42d9def3042bddceb", + "0xcc9986a7987738d81db64db86f583aed4fde214b766f55d0f15a876c8f790fb8", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x789146F9BCf06008D18b785912410F93b26c2340": { + "index": 510, + "amount": "0x03", + "proof": [ + "0x47a8c6486c0636b1de1716f4bdb2930bd2876cd27cf6d2f6b9affabd9693f5a4", + "0x65342a5be1b7ecab705b436320f14e8d05cf007d9fae9b9cf173eaa094b4bd4a", + "0x2bdf090ce3f01130e644c85626d9e4c382cc0c53fa0abf14823a72643b52ec85", + "0x7327dd8ef29607aaaef9bd84ab3718158a620b3e164df6976909aaef215117f7", + "0x38d4a740f3f99a827703ce6725923277f058619e98435b28078dc5b994e00a6a", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7904aDB48351aF7b835Cb061316795d5226b7f1a": { + "index": 511, + "amount": "0x06", + "proof": [ + "0xa3848ce181c83da01f51ffef64e9626c3dc8b5e589ba1ac292bae4ec120a91a5", + "0x8f5bdb70827d32e1f57277667d8bd468cef83b4346aef4c06a3cd64f17138271", + "0x2951c6889bb57f842bbebd143d63e6a3223010b180cb5d4a43421a7db1a043b3", + "0x9d1cf6e9f51d85a77dd4eec2524ba22941ec238f140f4f63c1712d78c1e4c21f", + "0xdf701aa8bdb3ffefff1b359214087cc585fa0a0d40716a6635a8d2db4380dba1", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7911Fa8d5bfCe62ef68B714D5b51A65A5732B101": { + "index": 512, + "amount": "0x02", + "proof": [ + "0x519fd9be8d3fe804f12e630d33d8a5e93786e55da85ce2ee60df72443e7446d9", + "0x920e396325b266f2a107ddf1af2bd4d60098d29a2a5653028372b04a72136338", + "0xe9d1da07919f076017a9e46eb39c786b9ad3246e3af938c5a8bb37fcf62feac3", + "0x60ea05c082bde3732ec3daeb0e2bae0395932096e755b1a42d9def3042bddceb", + "0xcc9986a7987738d81db64db86f583aed4fde214b766f55d0f15a876c8f790fb8", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x79788917F5963880F79e138A3F01ac049df40812": { + "index": 513, + "amount": "0x01", + "proof": [ + "0xa22471cf1111bf4ca9f22113dc9cf6a6d87c3195c30607a1a50a881fe4ff79c0", + "0xd20395067e7aa297a0794f0c4430e89fb0a4e10fc725ba4473a040148c544b06", + "0x91479039fdbcfe3f9e57c85a35424ab551f951e96197067348c757ea7407d64d", + "0x9d1cf6e9f51d85a77dd4eec2524ba22941ec238f140f4f63c1712d78c1e4c21f", + "0xdf701aa8bdb3ffefff1b359214087cc585fa0a0d40716a6635a8d2db4380dba1", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7980c7eA882456f657d950B4e492B4e37281b4F3": { + "index": 514, + "amount": "0x01", + "proof": [ + "0x29e7f4eb5c7afea1cfb8a00fc6c96773865c726ecdbf6ef2a3838418ae1c1a5b", + "0x4573eb1c35530489869195138b9a3b567e6c964371a1908199f3320878c6c1c8", + "0x76ac0e61f5fb8527ae23175c183589d51da559dacc49211473b64d81eabda65c", + "0x36710d40c48dd22c4c23311fe2998a569fb56756df4d8eda7bf12408489aed56", + "0xa43a1be4a3c4bbd4e28425f3172d3522b7e954d7cf0fc72a26d8ba7bea25f197", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7A02ff81AE5dD9d2314B19C8eA17DcfDc4109526": { + "index": 515, + "amount": "0x02", + "proof": [ + "0xef6621cfa591258f4402e76f34fd0e43f2f8656ed183b037dbe42af6472f9c21", + "0x02cde154319925ca4fa9b0ddbd9e11ea6cf4a205e11465c0c51f4bcc3fac8e86", + "0x8b6f824fe42a7f1d9f569625e32995ee98e15b37301a2c7063fe65c4ed0c6e78", + "0xfbd5cea7e1eb5806f6f82efdb0e881576ab386159b1b3ff7402e4bf56a947d8c", + "0x58340ed8edb441d787ada6b1aaf2b1e42912724e1f0f7887cde9253262aa0534", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7A13BFC2f21809A0eC1c8f787DFA5136579EB6D1": { + "index": 516, + "amount": "0x01", + "proof": [ + "0xe646dbfeb5f11a5d1eea5b1c7c617ce9ce8a5666cb70778c7c62b802f7f91501", + "0x8e104a6c7a1de0e900eaeea9af8d3552c61b75ba1bf6abaac237cb9be72c64dc", + "0x46620257535f86b53d54bacefde5f7e5ba7d4ccaf37a80ee488adfb5afabf427", + "0x46903c3e0f26b709802c8a2743505337728e1f805b4f936ec91df4b3f43fcdb9", + "0x7a545b345b30e441bb780a4fca731a87b1e941b75518a9983a312194a9e7bd46", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7AA8B99093368A791e2fddbf3d34290A9091D21C": { + "index": 517, + "amount": "0x01", + "proof": [ + "0x93737b5c6deca2fae9fc41367f99a6af42826b155e8799be387b99dcb9632f18", + "0xd0d777fcf3eae923dde55021bdf0c753b10acc64f994c9f743802c9d40d7f0d8", + "0x416fc24a2fc25ba59a366a12617fa61dc7d155780e7b0cf47d4beaec91fb9776", + "0xeb79377abd71cdb891e1379260c8fb1947760c17e28c7168ccd62f5d772f861a", + "0xea7c0076ebef0c429d544548828ff19d5600136801cc28845bdfa9990d97a058", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7B719aBBED877E884533591987089C28ec0C72FB": { + "index": 518, + "amount": "0x01", + "proof": [ + "0xffc2939738b1445cfe9b9740a7ce2cc783743c59e886bb0ba404075de1b1571d", + "0xfff736e6cf8464e999e5be3671aecd92ac16c016efcab51e32f3df364a8e73af", + "0xb401b90c19bb8b2496a8fd979f240a923c20b7f409845d553fd2ad67fe7ed89d", + "0xa0af5121b49fc7ea34ad1f4c8308fd6e51803abadb614d1f15f8c87bf9fe29bd", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x7BFEe91193d9Df2Ac0bFe90191D40F23c773C060": { + "index": 519, + "amount": "0x01", + "proof": [ + "0x57a63d183d895bbd037cf1dbe086a64d48e83a0b37c1c5017cd759931fb47033", + "0x49f105d825a6d26246149e137a77f402080929c3c15d458e782dea9211d5d905", + "0x708202d8f80bdbf5dc568f0ce8b7b9af201381136571a7d967efe4f79deae3c8", + "0xe759b6546746269851513af2e7b90b699309ac7fd4eb1cefe25f45f6c49d094e", + "0x6ae25cafc683eaf0756d86c89deb0abecfbfd01e812ffbed4e7a26f11cb91f8c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7Bb9791eB21BCD77bDf700E81ba7529720AFF152": { + "index": 520, + "amount": "0x01", + "proof": [ + "0x06fbbe5d0db41c272362a9820e057a4b4a8ca6b26c572d74ab0adfc543b94a0d", + "0x101083adb9c641c2c07d6cc8ec952fdd16db10c63d3148734e4a5fe2de96ba53", + "0xaa1e85f59373f7e7d78afd5cbb2e4e9873713a471b7ed5f4fc18db819e0c2cc1", + "0x16c0b121292408782518c2e86352704bdaa5fb42c434089ea6fc2adde27ce492", + "0x6e752d8572dc933bdf463f24751c7070d8aa74bb8987a5fe56dee3b0c9f53450", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7C694D359ab799B8f68AF034Ee0f6acC783f79e1": { + "index": 521, + "amount": "0x01", + "proof": [ + "0xf423873e6213360a2729eb332805159a9e29bbf57be79f51d0a2e8ca6fe2b8e7", + "0xa5aa986edf9ff9a2895bf6dcdefd8f187b7ff65cedbd679dd4c79a609f408a03", + "0x9dbf8a188dd35869d18593fd709b3e786185f077d3f4c9439919ce6a3d6d5731", + "0x7caec6cdfba66dc7947ce7a10af67bf36737d573f70c5bcf73b71057ac86d1f9", + "0xed5c942adbfa1d9538c55e89e4a7ff4276f908ac558913b5f43dce424bab8e0a", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7C818D46ACEf870ea88137BF553594f4803872cA": { + "index": 522, + "amount": "0x01", + "proof": [ + "0x2ef0f618a783e93f438bc7b02533cbd31b530929cf678ab95f4f304451eb0657", + "0xb31f76aff2897bb69feb030b0b6e3cf44d62764931c19b15b834700897aaaa0e", + "0xf9b0841b7b62c71198361192f1c7feafd2ded284dca91596cffae95a4d3686ae", + "0x7fb8279a3bf6834ff5de6f30e4ebf74889d64cf70547e9c78a27d7fd86516478", + "0x4325701890e79e85b41231157c1ced07357ce871ed6fb4f233c2f82c38bcf4bb", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7C8263E38a6c0168015169A6B6f86EEf1f271d71": { + "index": 523, + "amount": "0x01", + "proof": [ + "0xcd4447c44579885187365529c44536f9bb8cb29072b9e8e34db64ad68c51a8e3", + "0xe3ccf3f83867e7d9fad28135680e563edb49e78ac5a50b5c7beb1086dbf460b6", + "0x80afd91747cf4aadcd0a9bfc4df210ea0e0b85434282ec9bee91d7d5f9165218", + "0xef33e9da5226ecbab5796a616b47d5f4223c729722fba46a5cf043b7bdc381ce", + "0x2e78635a0ed4a14dadd872d564c5dd2afc4f21b0307932d27d4471c48082b7f3", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7D176A8FF5b038A85923aE80b420534B9CB3B40F": { + "index": 524, + "amount": "0x01", + "proof": [ + "0xa5bba001a16fe9be19c1ca324a3314d80fd84bb074531ac20e488ba83bb10ca1", + "0x5b77b626b64a03ff54b858bda2812b9cbcd776c9ec4bd6206d29a7fa1c13fb7d", + "0xa1721ee66f5b33fb1491876c9638c9e321f4e9e99e92b69903d4c3b0954511ab", + "0xc677cbee79568f65b4882bd20044555e2bddfb473bfa6749d1d07caa3dd6fd2b", + "0xdf701aa8bdb3ffefff1b359214087cc585fa0a0d40716a6635a8d2db4380dba1", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7D501Ac2F75B01e132E667f124bE8AcF1cE546d4": { + "index": 525, + "amount": "0x03", + "proof": [ + "0x349ab468af02af1b9e4091b0125281583314fdbe95beab2d4601d0e34cbb704c", + "0x420ca624a2d053cafd2f9ce85dad8292ef3e30a3d2663979c0455d1a73e3e4b0", + "0x0d061c4a4ee6a211e679a3211e00807beb57846100abc7f5eebc13ff2b92ccdf", + "0x9c7a414e889956f4c85241ac1c103f8242a6795725b10a2a17d9a1d125767087", + "0x963cc7ad3f8f0ded379d05906b629df8cc616633784013c90731955d0b0736d8", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7E2b6a9227554f4e217c591a34DF023124B4a83c": { + "index": 526, + "amount": "0x02", + "proof": [ + "0xeac1d3e9cd00e1278824a2bf410a0d9ccbeb0543791cdeb78f0f07e66aa565d8", + "0x1ede3ffc6ccb6aec3ac77412d9d1a0c99f9bde314f2ce9189985a3a1a12dbec7", + "0xfbe53237fa258f22a663d189073b771fce11454af4eb8ec55016ffa20f6427b3", + "0xa6bb3b2aef22e52a1e0052bc5777bac639d24ffe832889b483d829660c1bbc1c", + "0x3ac4ae4a4697e2400113df3bd55f84456aff86925f45224af80fd8af20592214", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7F957B7Fe99dd0D515A2283420b6D8702Be2ff18": { + "index": 527, + "amount": "0x01", + "proof": [ + "0xe8175ca003776d07669178ffce021c672c3ff7b3b6ae519df46f7f3dab6825fd", + "0x8a0949b6156f3e32d9bb2135dd35c858d532dc65563e1a24d5bf0e3947c16d92", + "0xca244e046f3d59b7d6cc79bf3d79d36d4e16637e4322e4e66e83e8c3fc48a083", + "0x6029ed468a13d48547faf514f4c29ae1fc65bcefd1ecd17c26aeef29ec044356", + "0x7a545b345b30e441bb780a4fca731a87b1e941b75518a9983a312194a9e7bd46", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7a22E7a4d912231f9c0FB6760c59Ab560188360b": { + "index": 528, + "amount": "0x06", + "proof": [ + "0xb89837440c3c3b92277542bcdebe00d67d5b13634ff2c0d70a89ed5470433138", + "0x07c81adaefa216a3dde296f5bc0b7e27fdb5a714dbe3d2c67bd624415b3c46e1", + "0x96a51c82a51e9090e50794110f5ae30726a62fec6e8961aeea449b4515be8759", + "0x4f5594402e5d778ad5cd48b93173f203af8e62306714d707dc5f989e11faa170", + "0x83e262e483a6f2ff9f4df14637dbbdfeddf0c6b0b4ca462c4375d29a3521e052", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7a366Ebf29C9ee15Fb3E754Be1bc40368f0c1339": { + "index": 529, + "amount": "0x01", + "proof": [ + "0x19aa9ea69835a7013c403abe075b32478d0a1fb30429b583b6b96c090a5fbd06", + "0x6946ddb2039e1dfab06851980d167442f0ca7610d0fcbd02c31d6a69e793f6ec", + "0x242867d7413fcb0291041584037c07852dc6949a3340933353fcccaf1840148f", + "0x9259974d28cfc23eade84b4a12eba89f4b5d3b0064ca7ad3dcf3a6a6a2555c91", + "0x93994074bdd819d668a79fc2c79be23cb074a679cd3fe03940945d4c6f9fa9b3", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7a7892b3EF64ABeDe8348684BA57a37fd7EDC0d9": { + "index": 530, + "amount": "0x01", + "proof": [ + "0x58f665953d8c45e210e0c727ad4061566584d3377111f80be3692add5a49d931", + "0x5c28d048a86c724fdd99249b88afcd1aac2839a630a029fd026803bca49e0c58", + "0x7c23f4640cb3e1bbc8e7fda85d8fe777fabe673ab4467b36de7f64c25eef8b5f", + "0x5190cb032ba95080f88929faf2eabe8bd342a53206176fd2c3afcbef4577ab71", + "0xf9f105f90db6fe2970fb4e03b35654f9b69375879c783d3f1700e04b2e2f925b", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7aE87729A49D8679F3d7FD10b00C5970397bbbB7": { + "index": 531, + "amount": "0x01", + "proof": [ + "0x7bfac0921df3accb5fd941cf08b37afa7e20790277a5e5fba6fa38cf6597f044", + "0xb953952d6c435ba5ab258661436efb2df00bead87eb57b251e0062b3e500c841", + "0xbbf16f648b89bf5c912677dc67e477a51ede03df7de459ae6574a364b5f12c66", + "0xc7b7942da27652b608d4a505a59fef704f26c49f0c2a23709d80122b3afab5bb", + "0xe2050f6c95c616c1cfdb04f4b6d0afb5afa0fb464f767c38aba0f07df915a97f", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7aa69b5EE49C4D3170e037960ca6c83F61241395": { + "index": 532, + "amount": "0x01", + "proof": [ + "0x6f6be70bd7c7602bb7eaa7e80d4abd5c067d0c080499c12707aa7e5ad3791a20", + "0x439bfe0ba4b15551b1f214e7bdff94460c2b7ad2f79158b2b10d18db8bde0828", + "0xac8fd80a51422b299c5bf7ed366a10de6c633f04e56e7d1a93f0b71c220e8856", + "0xfe79a6356c4cd9282dab3a598f859bdcecd04fcb915a9edd66380a81697af3bf", + "0x7abccb934a7f719fa80b9a5d3157e99d45ee17a391abf85d4f60839dbf3769cd", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7b2c77e13a88081004D0474A29F03338b20F6259": { + "index": 533, + "amount": "0x01", + "proof": [ + "0x2cfeb0e854b539945857d80d178be849a50a63dce5cfcd7fdca310bc9a4406f1", + "0xfdf8763b78a0d5a586d35123aea4d38f8350ce78adc5d43e06aef4b7a46f447c", + "0x7459c50ac266878a3e428777040add9dd05d3119fa6ca0893dfe78b87af16a58", + "0x71674724de34865e988a846825d9f937ca48ef7322279591194ca7d40d8ee995", + "0xa43a1be4a3c4bbd4e28425f3172d3522b7e954d7cf0fc72a26d8ba7bea25f197", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7b820DdE9B79f8761D959b4083BF4BbCe7aA6DaE": { + "index": 534, + "amount": "0x01", + "proof": [ + "0x3e55ddae8e219dabf8bf554232366a3f79b60c110655266ca5cdbe06c5f4f213", + "0xf83ac42d644b354a382c93c5a48526f5dc76910751805d9758aa292c1c655a65", + "0xbf879dd33cf8e5652f6897331b6d0be05a0d269a02431e4143f50adfeec86fb8", + "0x2b5ad2a01fbc178584e521e2b2e5c612407bac24dd9bf0c452060b71384720b6", + "0x98ba92b6a1d3418a3c44b684c9f0dc2177f48d3a6b666334d112dacbb6f5acae", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7c74F84ab9d211b0aD306fd793c593B744135c49": { + "index": 535, + "amount": "0x01", + "proof": [ + "0x0d4aa76dfa30ff5d91b32eee81ebfbf90a03693053ce2e2d930ea635b9c5d2b0", + "0xcf558ed9c43ca44b32b5aef7afbbed2fae05da17321bda78b73d305e495908a5", + "0x32079f379faa5487ad026443f33416fad7496adb5ba59317ada9083a771610a5", + "0x037fa491e4b6fc74b9dccf3175d28aed9f5dacdb75dd0fc8e1154a0704619620", + "0x4bab2069d20a5d1d2f5ebdb61803a57609b7709eca9e925e31a7d14434af1326", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7ca2b8b8A6c81Cbd6d69267bC7854273D048294D": { + "index": 536, + "amount": "0x02", + "proof": [ + "0x187a7fe8f9b22d9f6310c7e2a5010bcdca232d53b98e1775b0b628c5b8c0f129", + "0x47a9f68dfcbca0c181297b013ef82d78dc1dfc0138770082411f36c1d724bbed", + "0xd5460b9cbd07eb643394af0ee8ffa7d20c13c474c42f8d3f770490047dfc42ec", + "0xd4e406b94f7009e26e52781d8bbbf71780c9ab5d8d7b9162b8469ca115683ffc", + "0x6431c24d3d46ea6b0d1959c0de03265dc474d3e67139f2bedca26b5aab0c0c5b", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7d00815E79b56422E384A2851bB3b4B48CCD01e2": { + "index": 537, + "amount": "0x01", + "proof": [ + "0xd0f91becc92813f31909e071cae442f3cf0812279b06be1bc23207b7566ed6a0", + "0xdfe1b471dd584259e583481eba009971c7d2d268ac2ab184d800d26b2d5e6737", + "0x45b3ee84bfaab4fdcb6b276d32ba091b4d13fb4a3385b5d29d91fb477bcd0392", + "0xd549250cf81d453ab878cb87d004bd56f5975ca86398b00d651f71d522925a30", + "0x85ada07677b521b0dd2e0d60f51f92f7b1217f46e36379a5afa5a74fd5c87a5a", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7d21D6f8e03746BeF7fB64710C1569505F76dC18": { + "index": 538, + "amount": "0x0a", + "proof": [ + "0x51c752210ab38f1acc6327c0458ef748791667392deb44542e0aef12226b5563", + "0xfa9a75aea105dc3280bb3b46fb6ac2c13645b903db9fe2c57c304bd184ed2b77", + "0x6e4e3be8c84bdf4ca5531cb1f98b5a0f91f960b234deca1bc85cd01c39319968", + "0xc7b00ce40d9d1f9a2921254e2bca646cf3992fb2c667a15215723d1f5a1b5352", + "0x5477c93aa7e191fd8f76e1976387fc82460220dfdcee87f9ba8926f4e0ddf45c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7dB5d398d3E9b1D0B1d119E53Af3E03164637eD5": { + "index": 539, + "amount": "0x02", + "proof": [ + "0x1d8d056848ed49bf0f5bab68e84286326adefd0ff2c4f18f43d8daf7b47751e4", + "0x4afa0526d5b86d02950ac3088537313121d6f732cd0356d523df486f3818c955", + "0x1cdba9e91cea35b2840b706aed8319a24d18d06c2d7b29d63283aa5645e5a6cd", + "0xaaf60b5ecf22563f090c456c87a77833a8ecad31ad25f79ce590acdcb7f64b01", + "0x8e0cc5c13324dce3ab0f042d31a9db04afe0918f70e3f4515f43739791621c97", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7eA251f8A6457fb001f7F349B27a32b404D8c268": { + "index": 540, + "amount": "0x01", + "proof": [ + "0xc854b7ec5cbf7ea311c4ef67b0f0f2d57f87d3433c276422d4e34f237b4f5869", + "0x4f2defce742d364dd56ee95d19e1cf0304d720105e0289a6c6406883b57554f0", + "0x040429b9a444021a6ff7e6c6ecf5b7ad469b7bc2acfbfd2738ff037f2995c0d2", + "0x036edc84651a6e437d2aeddbd5e5d10d4911716f37c92c584d637f9f9ebb0dec", + "0x97fbe90108c9d6db20d511e4419e4ed044f589ef1f2a9f6539187bad21502f90", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7eD52863829AB99354F3a0503A622e82AcD5F7d3": { + "index": 541, + "amount": "0x01", + "proof": [ + "0x40a14410a033d276060110aade2a12c463b8bf3d95186c08281fc66663d213b9", + "0xe93564032181ca4661779509fcdd747ffcae63e6750202b2cc89bf0d59fc7902", + "0x6cb469a96723651e405715162b9903adfe081b56ef3c5c27f903302a7ba044a3", + "0x3ae549d14256824a2b8db4d8292224eb9b3beda41a6712098d825d2a32cc6dcd", + "0x98ba92b6a1d3418a3c44b684c9f0dc2177f48d3a6b666334d112dacbb6f5acae", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7eef23aba50bf344eC95BBC0aFb0300Ed5560b48": { + "index": 542, + "amount": "0x01", + "proof": [ + "0x63465bac6b95d1073016ab49fda4ad99ffe28a234d83a504daede4814c7662b6", + "0x21ebeadacca530cc0ebe74db46cae3f7a2f1f5f88d4e8ae64ef5c4aceeefd606", + "0xafc939acce9fa59fdef6399379f0c2e101cdd8d5bc66ed4c1d5bbcb5fd709886", + "0x22784474cee51afee6127b1f3fb642ff75cdb40aeb505017bf6b1a1162a44c35", + "0xfe7d73c06bd76d1271e4b772b51e13505a812b7c919129debfd7d15fb5014d16", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7f62Fbb8a9E707e44A198584ae2e8Db67cEfC30a": { + "index": 543, + "amount": "0x02", + "proof": [ + "0xe4866d31f10f42fe4010e84aa899012c884e89c9b745aa2e14b70b0249760c0a", + "0x063478ee6e1ea794961e75204a82ec09aeae4d6e0001d581729cb36326dfcb9a", + "0x6cfbef2c974896a0631830fdf28466959c8202a21abfd2bb81bcaf67782572e1", + "0x372cbc91aed35f80f87f2c13bba747106e9ece94f8d166e828a5c70b321c5528", + "0x7968b2383e3b914ab3a36580b205f1449b51563630c77871f712e94743e3bf39", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7f9C8843926De4b2eA6cBf9381F9f2FA81C58ed6": { + "index": 544, + "amount": "0x02", + "proof": [ + "0x499713ad3ad1d86039ebe9243218713efb919dca423a1bc6123c04c59d2e14e8", + "0x7d69384a7f3bcafcda2540f733207c72df8489da61392f68b03bde28d686b9a2", + "0xa1607b1dced9e8d9d1aaa755c5c6bc84b483e3063f866818b53e0747d67d0d1d", + "0xa5e8bb53f83c3715772cbf32d53d2e1c1c9b5abd0d51618f0e2ec2960d9a33b8", + "0x43f59a603c2458850547e5a84d47e61be843b4a3c814303ed1b52e1e4d37a1b5", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7f9a5db0ecf640FA99Fd6c867b4C2c1ee98cB257": { + "index": 545, + "amount": "0x01", + "proof": [ + "0xeb9111e09036474f744cd26821d52bad96f727ce3248d199fee9a72f7851f129", + "0x9bfbd72090a3c88024b9d2ba9181c3380417587b51fc90b0b2304edc64f7e391", + "0xde0c48888840a3a312e45aefc38e872d11021fbfb1c21f69dd0002cc3205c985", + "0xa6bb3b2aef22e52a1e0052bc5777bac639d24ffe832889b483d829660c1bbc1c", + "0x3ac4ae4a4697e2400113df3bd55f84456aff86925f45224af80fd8af20592214", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7fB30B2Ab576B5Be3c23263b2FebDcf1f72e2b6d": { + "index": 546, + "amount": "0x01", + "proof": [ + "0x26471b8d7bddcf23a2ed580ede3ca4240f3e74d62a75c77d77601ec36869b6b3", + "0x535034e8f81b573b657b7678716d1a9f95a9d9057a53fc91faa82f0832a333a5", + "0x9a7506db8eb154b6d45fd70ef0e57ee187ef27ec6e42a2253be7f3ac118f3fcc", + "0x4b1c846f0a8bc448aead7f2cfec46ac450b23d2f229b5350dd63009a82a1dccf", + "0xe29ba79106b7b14c14912bb5fba509f27997ddbe5a7ebc941fa75e3475af4aef", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7fdb83703101c5990a5D67B924f2BB0c1e299945": { + "index": 547, + "amount": "0x01", + "proof": [ + "0x0d47ace1256161dd098405c995b30f58c8ecea32581996e144658a1e7d0b191b", + "0xaa8559fbbbf33b202940a5ad77168275bbb3174d53b9d138da00e70463150448", + "0x1ac17eae005e68d333e431b1be274794132926bcec9fd36924d6e7e39904133c", + "0x979cc6c181e08190bb233f0cf5b0f7b487d9aadc675c9326a9af9732d3369d45", + "0x4a36dc66177a8394f6b14fc9adbe4ad7e0cc2dead6acb72d80990e336fef8d45", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x7ff62eB8D96C94b7Ef523bB08A1Ab56489ed4458": { + "index": 548, + "amount": "0x01", + "proof": [ + "0x2675f56bcc5d032d052be645dde195f4349cf91fe8b4519892bb8b8b45c6b51e", + "0xf900254631c40f4321ed12e67f75fb641b07c400bfc53c533428c940162dd04a", + "0x937839ce24bd273187bcd1af0328a690c712a30e57af8e26d0ff2c9c1c709da2", + "0x1ff461854683a34317216055e65b6637346912d1739163d25c1a0b0a5f15c25d", + "0xe29ba79106b7b14c14912bb5fba509f27997ddbe5a7ebc941fa75e3475af4aef", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x80218A47ECE971e24863ADE43e9F05b77605da54": { + "index": 549, + "amount": "0x01", + "proof": [ + "0xed06bda7c172f63f7430e95eb52583f0415cec64be20a27a1d9c2ae0044f2e29", + "0x9979e910cd8412f79c6b818c9df9aa52c33e522ed2f43c9482969eedd52b9449", + "0x0f1c6c7aaffd63c4e9f25ab9cced8d3f13972b255c9fce8cf940b54f7722fafc", + "0x88222db835a579969caf99eebc6d7f986a78bc44f46b794a4319d01749c83a2e", + "0x6e496426985c92b04963088da4856230c781a975dbb5ce2d8eed77e7d2d4b58e", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x808378793AaEAb39ae4cD93aA6A5B78Fc29423ca": { + "index": 550, + "amount": "0x01", + "proof": [ + "0x5694bdf3d2b48cb7b398047888427d38dbebbe347add5e060cab5c17b33cf4ab", + "0xd628641a688baf1726841af70531c938cbb56bfe1545e629315338c1c8f8d6ce", + "0x782de94c988da2786f9e32de9d24aa87726a07cacc4ff5098224c6ef0c91f0d7", + "0x9104efb4441e61a09b4e458e6b45f6759c37c20733b5823cc04f759cc53d5575", + "0x6ae25cafc683eaf0756d86c89deb0abecfbfd01e812ffbed4e7a26f11cb91f8c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8091587F4DD6019196e89fe82A5Ee40400fa8Bf9": { + "index": 551, + "amount": "0x01", + "proof": [ + "0xbb68f7606b128230fbbde4725dd2a9304999a283d4af156b20d60303cde68a3f", + "0x09dacaccfeaec0ca86146e5b4dd908ef816bc3cf613f1e55bdda1a89b39d301e", + "0x676a4419b79ede64c5f134c84c12f5fa1724be03db300147c6ce62c8a2747911", + "0xdb334b0b3ac11eef22a51af7bc46c7a633665d404c70629bf6c429ed0b8d1ae6", + "0xcf36a9c08620752945fec2c3138a9b0eaede19862d6c5cb3c0489e6ab3a443d3", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x80B9e18bc11a4e02D0e3ac5427Bf480C24c174cc": { + "index": 552, + "amount": "0x01", + "proof": [ + "0xa12f2be26f641d506a8b968e9dacf33de05272909e3ec9d1c48d041dfd2bb4e8", + "0x04b4ec9a15a6d28017131f5bb5cf6cff60e552ee2716a308b8ea5a55ad7391f3", + "0x7306ff63535bc4b71716d17c36277e5ccdcae2c03cbbe50c57c9420e43b33b29", + "0x4fa24b2d1635e25dea497fe90d30db11d577f752b726d47caf1b4952bdf93c96", + "0xc36c52715656389b2693c145860adf3b1f3d4d24a139850b1fa5f2236456376e", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x81168C14e5A89f60b30e9a7f82A229406A64369d": { + "index": 553, + "amount": "0x01", + "proof": [ + "0xb0b98627078114f6104669545d41a2fef11a93d2c6198d1951f829380c79ab2b", + "0x99da9b921bff306e0398c7f0b702f8e0e0a76dfb918c04286b1a60c5b6473d88", + "0x861b6a9fa4a9a59b3537e811eda798dcbe95d882461afb4d7e9391162a287d45", + "0x49f4781ffbed71f831627c02425eed106f4714988055f5e0978de46ca35b3ae0", + "0x72373ecc225af245878bc638c49c8901db1430b7210a3008231acc8f8118d2e0", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x814A19b98A84EC9F72b7609A24Cc6cD35a2d0B9e": { + "index": 554, + "amount": "0x03", + "proof": [ + "0x2e86293aa4e0ef790e2a27ffacf0be93144cb636d5c91ccef0d72162a872590f", + "0x3f19992fce4ab826b241a152c2db7c1332d1aa389d91d453c37e20f823e44e2b", + "0x33ee9937a125c825df46cd7852ad611a4a2bd56aa65171e409297909c605ac3b", + "0x9e8ae6c0c829ef47f1fdcf07618192e842b30fccb4c38a8af79f05f97c75c097", + "0x4325701890e79e85b41231157c1ced07357ce871ed6fb4f233c2f82c38bcf4bb", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x818668A3c710028A8BCC825E6EBC6738565BE60b": { + "index": 555, + "amount": "0x01", + "proof": [ + "0xe41e6fd1d8b57ffa59b895a7698c1b28cd7bc14cf5f4eb6195bd932d891806c6", + "0xf2be2b502be1c1d29aa15870257bffc304001f94c2e1c56290ebe86e74cbfb92", + "0x567f8f869bafb76cdb1e5c86291783cf3bb6dc604902df31bd0f815d38e36ed9", + "0x1bd24f0c1d9a337a197e1feb80905be5821f1e64457aba030d18aca78646a08c", + "0x7968b2383e3b914ab3a36580b205f1449b51563630c77871f712e94743e3bf39", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x81Ae7d3B3101D6f31964d3D7b4c9d2cCC1374892": { + "index": 556, + "amount": "0x01", + "proof": [ + "0xdb5a4d8048ba84ab37cd926fa47214060756a2871064e2daf6d7770e41936feb", + "0xff32f5fdc64ac1abf84d5263d5ab1db426fecaa6425b6fa602f7067da6d648e1", + "0x80779d16ab6f1d2f1a5df7a70354491bac8b36d2f137ab7274b9fa248eb57487", + "0x3cc86f19d7ab5abe54cb84f21d19174b3158c792e08130d0d4f813b822ec451c", + "0xd8ba0ec6899e7ab5afd6774d7465b2ebc52e677b805f74deb131b1b243bae70a", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x81aA6141923Ea42fCAa763d9857418224d9b025a": { + "index": 557, + "amount": "0x01", + "proof": [ + "0x776db8b274c106fa62f1329b1ca3542ca01617836c68d104241c309da566b9f9", + "0x0e860b7153c1d2a57405f9329575ce8eab8411de3f45afc7b6e19808a7e6cefa", + "0xffaa2df36ce81efbe18a3f705e17efe3acf4e87e4d8a4423f01cfbe9c3278f32", + "0x08cb8a426c97a85d30cf9308f5228aadeeb1f2c3f1f22bb2fd0d6c1a680a3ff0", + "0x80cf615f05f15e9ed665dd7df5d086fcb70ed5a5086e02db7c08752fcaab6507", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x81f7e5dd3a12F88ef7239915a255fe8Dd22373B5": { + "index": 558, + "amount": "0x01", + "proof": [ + "0x4a1198192b6d214c86db85cc74fed875fb7307bc9a67662ec204fd397c95749e", + "0x56789b290120beface5f1a313d463e3be8c7a7b01f372a61a84dfb3ff45683fa", + "0xf51571a8d5447a22467ef7675b2c9fdf62254f3d4938a09245fc084f4e588343", + "0xf94cc4240e18301aa3e9325f55d6ec2e2e84a181037fd49b69a29a1aedce082c", + "0x43f59a603c2458850547e5a84d47e61be843b4a3c814303ed1b52e1e4d37a1b5", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x83500F5571F81FF703D014cF05198fe10016b7dB": { + "index": 559, + "amount": "0x01", + "proof": [ + "0x43078b4f41b53279a49ad8ce268b92483df3f0c1429277438b6766790a6e3c3e", + "0xde1e0e90408abbaa4fb3245e1402041c8b49a5055e5927f00d6d2f70f58d61cc", + "0xa734a0bd47ea59109ab668778330ff5bec3b192c7fc158c8d946591e657bcae3", + "0x9e0106695419683e28012ebdf11113a020b4f76869c1e66a51206a84371b717f", + "0x38d4a740f3f99a827703ce6725923277f058619e98435b28078dc5b994e00a6a", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x836EF42bDf34D09390Ac721eaF35eD73BcCBAFb5": { + "index": 560, + "amount": "0x01", + "proof": [ + "0x012321fb1da828fd817a6ec49182a138242294a36eb4fd64aa3ee01d0fc4f4dd", + "0x1f8ff13f260cad30ef176053169afb468b60d46c671780fb667ed98c55dbe7eb", + "0xf1525aa7a232fb8c1021a8aebff4bb78ffcfc5a5e00461950f235b958d5c70ec", + "0x694db95f2efeaf59bc0b92d1736ca407eeca00ef7ad545f2c27ec99a059b74f0", + "0x9be1155992502d2b75a54fc5b2a41d663a86f7d329faea1befa0e24965b01a56", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8402FC773764d6b4DF62b404381E3706aa4Bc62f": { + "index": 561, + "amount": "0x01", + "proof": [ + "0x24eed0e6fb33ada38a0e4f8e4511a66f8421fafdc1ef94c290a63efdaf2a484d", + "0x0a9d10612c3c348cf1734be9b2606c59d3e38cdbd09e971fc558d5137576590f", + "0x9a7506db8eb154b6d45fd70ef0e57ee187ef27ec6e42a2253be7f3ac118f3fcc", + "0x4b1c846f0a8bc448aead7f2cfec46ac450b23d2f229b5350dd63009a82a1dccf", + "0xe29ba79106b7b14c14912bb5fba509f27997ddbe5a7ebc941fa75e3475af4aef", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x842702F9EdaeFAFBCF5C134F84492428d97D720B": { + "index": 562, + "amount": "0x01", + "proof": [ + "0x412d7455997e7aebfd3047cca30b8b3598e3a59390729ad72e804fd7fac6b1a3", + "0x3fdfb5850e1ad0d463ae605dd97fb9c2e1f82d5cde33c885397112bf83732cc9", + "0x308e3c3f0424a4c813565e783cb4d79cc2927c1d11c780b46d52f0c53a01784a", + "0x3ae549d14256824a2b8db4d8292224eb9b3beda41a6712098d825d2a32cc6dcd", + "0x98ba92b6a1d3418a3c44b684c9f0dc2177f48d3a6b666334d112dacbb6f5acae", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x84652C0d473Fc98013AA3f3a3eA406CC8Eb03ceD": { + "index": 563, + "amount": "0x01", + "proof": [ + "0x9edfdf01cbdff82526534975de576874ea533c1dcaccb2f2b2de259eb20b3d30", + "0x16bbfe1ada20ec626f78c4d1baafd314127b368c70f11d00c82650d4fb2f54cb", + "0xd32dd306d1f42a39806611081f48b9b83cb4608e909a84d098d91b13868c6029", + "0x35b38a743320b292e89d9164e2c2e5018fa2478f9a132ef65671c9bacfe611e9", + "0xc36c52715656389b2693c145860adf3b1f3d4d24a139850b1fa5f2236456376e", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x852464cfa3530ee25f6e3AC0366d1b486aA4eFF9": { + "index": 564, + "amount": "0x01", + "proof": [ + "0xb587f338ff1609822617932a2784d409060764bebcdb046468e72c7919c37fa1", + "0xecc4b5db90bd9651d9e8363bf7c072f9221973b9de7ce564fd1a96d2dbb986fb", + "0x180e1c5787d5d2cb7c3d1a878f6ef656de538e76593c3a78aa00ca9ac631f7ff", + "0x841ca200e81dde455c9bb72802b7b377b46a9d6779eec08b07e61939b8d43c1b", + "0x529f1b48ab616d4dd60f663753a7779d8ec25952bc8c34df4aa96347bdb0d542", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x853EE8a3a30D84181302f602693AAb93CfafeC3e": { + "index": 565, + "amount": "0x01", + "proof": [ + "0xb89ac76ca3ea801c88deebf131ad19f124569ab9aa0cd4f716e7b22d5cdb328d", + "0x95a6de48685c79f5aa52dfe527186f8004d7a4548c3564e39b823d28c96c48ce", + "0x46523762bcf4ed5e79e15cfe2edb66750ed12adc7f6f405d6e19ee3580efdebd", + "0x4f5594402e5d778ad5cd48b93173f203af8e62306714d707dc5f989e11faa170", + "0x83e262e483a6f2ff9f4df14637dbbdfeddf0c6b0b4ca462c4375d29a3521e052", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x855c21A20599Dc0D1581824549347AaB5747fA6F": { + "index": 566, + "amount": "0x01", + "proof": [ + "0x39815d358e21e71e5ecb20a9846df29d3774a0ef7c3b4a6216f45222e9a18536", + "0x41ef06e62149228bca6d26c03af009a65cee42a6cdccb4feca2afdc64dc0a7d4", + "0x159b41098e36945d7d696487556ac5b02e939b80770f9f0ecd41abe3f8314c10", + "0x60583de8b96cf21d7bf97a30f8f28bb928ffecf01373b007ee5bfa1bb5a1f776", + "0xdc998377cfbadb1c2d77196acc69c259bcfcc6de58df7f5aeea2780a288f2509", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8596Aa3B7FAB52b49D2B3A9d2d731074a4737913": { + "index": 567, + "amount": "0x01", + "proof": [ + "0x63bb934c195f3a601092910d0d1053b6b38469450aa24adea682bb36a7efb77b", + "0x38af04c973fe8191b047e98c184615862817dcd1e5b530e747e2ab3e1e691325", + "0xafc939acce9fa59fdef6399379f0c2e101cdd8d5bc66ed4c1d5bbcb5fd709886", + "0x22784474cee51afee6127b1f3fb642ff75cdb40aeb505017bf6b1a1162a44c35", + "0xfe7d73c06bd76d1271e4b772b51e13505a812b7c919129debfd7d15fb5014d16", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x85D10d3c539bC4bbE13fd1631Fa09D14e742Eb71": { + "index": 568, + "amount": "0x01", + "proof": [ + "0x8e85e162ff2dd3a86690828de08e0042fcbe4c07061fc585a018d5d01c86e5ef", + "0x8539f18b2c4ad9e2b18947b2014abcc884a8b6563eaa9056b38563cc553c4b27", + "0xdf6cc73a467552881abcfe25d30eb0b4a6ee65fb03e1f816f4e39315a3ce78bf", + "0x7217bacc0b5fadfdc27aef27f3baae246ba909c02961594a63bb24f24958cc4c", + "0x8fbc13f50b0f82a781945a74ddd5c5abde0b4a8983852c66ecda77a68df50722", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x864B81C40D8314D5c4289a14eb92f03b9f43B6bc": { + "index": 569, + "amount": "0x01", + "proof": [ + "0x22dbf438acbf14b75fe693045c69789359962fd9e0d456846852a79effe0d0be", + "0xf9c69b79ac0e062b8bfbdce497faea28ffa0b427c5d8de4680e0bb026f70bdf4", + "0xaace454f3f03cf0e0a3025941926638c00df7354ff9ef7c7ea1df6506661ad57", + "0x7076b49e1dda289a132a67f2f0be7b87522da84294f2302ec4d61300a0630b79", + "0x6665ebe68e892e4e5135c09f9cdc379628aaa60a8ff322ed2ba75fab3b3a9cc0", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x868A74957D08D00B1aa9C3e0b96b53E62e900580": { + "index": 570, + "amount": "0x01", + "proof": [ + "0x89f3459e1dbacf3f7ee1c861eb1d7ae366ff23368c2730a820757a47293cca31", + "0xca7d4b33116553b088d5508cb576f443b2548689df4d4a0dca732579241ec864", + "0xaf004a51521001e3a2257071c94b92bf3ca21deaabe3c3482b0ee37b2ab2fbbe", + "0x0c15cd0e5fb4411c59b182f983d4322f33d3be8bd2c5425b705021fa316a402d", + "0xe4fc54838dec16cd3ac94713f191dc41ac7f5e070180d4843c9aaaf9c71ce29f", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x86A41524CB61edd8B115A72Ad9735F8068996688": { + "index": 571, + "amount": "0x0a", + "proof": [ + "0xbac23241aa7cefd806f7dca4e7907c09713262327e52ffb0594e102116bfdde2", + "0x105b0fd2045a892c68ebe3190f20358a4c20be5e34d4536d800731397cd8fb61", + "0x3017eb0d540f971e8043a85f710c1ca576ba8ace44cc77d31d57c352236b7562", + "0x6a8275b9d29aafc6358bf9f174b96a6a2561ace2c21d2edeb2a14975f0d9b0c1", + "0x83e262e483a6f2ff9f4df14637dbbdfeddf0c6b0b4ca462c4375d29a3521e052", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x86DAb7eBeDBB7E48D5BEba6F29d7bb0a01Ff246b": { + "index": 572, + "amount": "0x01", + "proof": [ + "0xd9b5a990975747e47c02fee0f29d615fcbb004dc7e9841a176fe6f04b147984e", + "0xb17f19e1ae2c0f1932e2ddd1cc42dab762ad9ba67bbb7221e37f7d8471e5dc14", + "0x9dffadac20c132cf7ca3085a1eadd324aefc93eb96b7e6507e8e3ff06ba89160", + "0x539804c7bf7a9b6235d14df5f64369e5a3ba52daf4ce320d3134eb569c42ebaa", + "0x57a1600e1002b648fc38956dc1d2f34be5ee3f6cf170c73bd27c43b2a01e45db", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x86F032cD94D4A681bf4B8328b0D958Fd2EA77A4D": { + "index": 573, + "amount": "0x01", + "proof": [ + "0xe6f71e7e55444d882dc9d90e1e26260d0d98f7e7c11d845d3a68b3a99fce7e05", + "0x72635e189dab9f4fd2eef5f000bce9dc96019fa030df20d034be4d0fe69ac086", + "0x1a4492318b217e4bf203e535736df5d575d869a4d6eed45535f3a69b1bc59f98", + "0x6029ed468a13d48547faf514f4c29ae1fc65bcefd1ecd17c26aeef29ec044356", + "0x7a545b345b30e441bb780a4fca731a87b1e941b75518a9983a312194a9e7bd46", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x86f6941748BeD21a8449C05a6c62208dC4C363b4": { + "index": 574, + "amount": "0x01", + "proof": [ + "0x32fd2b654471135865c87e00697a663e55773bd2f9863cab2d32038c8608760e", + "0xe44717e43041155cfd0a1bdbc104fe8428b4521d57a31abcbc9b8c353ec933a4", + "0x39cb0477c1d663a69af4e075a8fe812a6810eac47e570c671a96d933ce996528", + "0x721f15749c8ad9759a4a7d682519f25f59a5bf74daab7275c00bac9f0ddc323d", + "0xd6d09ea62a0a0959d8a1f1cbd849b805597a75fe443bbbc4d5e2555bf8225437", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8735F6C54b98d8C4da04115caee48B1ff31e7E9C": { + "index": 575, + "amount": "0x01", + "proof": [ + "0x22b38d9edbc717e08e1bc9d45d9d6f095dfca829f5d833c5d9b402357b843097", + "0xf9c69b79ac0e062b8bfbdce497faea28ffa0b427c5d8de4680e0bb026f70bdf4", + "0xaace454f3f03cf0e0a3025941926638c00df7354ff9ef7c7ea1df6506661ad57", + "0x7076b49e1dda289a132a67f2f0be7b87522da84294f2302ec4d61300a0630b79", + "0x6665ebe68e892e4e5135c09f9cdc379628aaa60a8ff322ed2ba75fab3b3a9cc0", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x87a23309D279Db2eef6bba7CAe04ebFfb2314800": { + "index": 576, + "amount": "0x01", + "proof": [ + "0x393101febb8245248aad46200ba87fc65867da671c026b5909b9ce1b0beed9d3", + "0xd04d7f5208ada5855e94f0d49d4da8da01c7c21e240837ccc6475e67c1ab11db", + "0x159b41098e36945d7d696487556ac5b02e939b80770f9f0ecd41abe3f8314c10", + "0x60583de8b96cf21d7bf97a30f8f28bb928ffecf01373b007ee5bfa1bb5a1f776", + "0xdc998377cfbadb1c2d77196acc69c259bcfcc6de58df7f5aeea2780a288f2509", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x87a8Dbda8870F9CE5AA34a78d794911cF7e3535F": { + "index": 577, + "amount": "0x01", + "proof": [ + "0x6c04d9befc49dfaef7ae0c6c63588ce90d288b1ec6388c80856fec956498c294", + "0x00438b89eb39a97864b6673425e53c07a0b0482e54cad2fdad1574c1dd029444", + "0x9d1bc2241ac02056b61650ad7cae67788655e09d14f6f80d511bc28bd1f815ee", + "0x283f6032b7beb32fcc6ac4b21c9941360bce453787f78b6251c38e3890b83a8f", + "0x1be60ce906d0d73954b2e1f2747ea1c9a23db0ad9345fa6801c551f1a39fa5ab", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8806D2eD87398BEE00Bb044c882406ba8ead0d5A": { + "index": 578, + "amount": "0x02", + "proof": [ + "0xe1ecf76dedf7765e1aa0fa8a7a12ff38ca0dfdeb28a999b32280c6236a8f2eef", + "0x62593cd2ee85631b3a0807d19161937223de09b068548e5ca4134cdfee82928d", + "0x48e789a37f032c18f647b0c6b852a88e29403e31c0f6bf94215b72507b16fbbf", + "0x60dd57debe01b07f2150f54d637bd8f574df12ac003a445ad012509f5b619671", + "0x966715df220dfbe5e11392b257b61b64c18178d1825b654f95f67d7c9558a2a2", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x880D930b4ac0B73966de27C5267E304d2093BdDE": { + "index": 579, + "amount": "0x01", + "proof": [ + "0x7fe616c0c78257495160d01d62b74c657e80f4f69eb6347abae5388a19cb5808", + "0xd9ae8cd5daaa697b02d60abc36ee0e447e48aae6ca85f0104e0efd80ff01901b", + "0x5ada5cfebfc9093074af257daae2c61d27b871598065cd29bb9a6790903c5c37", + "0x138bee476bd8ce498e2985571c0fd10b392ab6afd8c1bc3ddfe5859f552044ff", + "0x891a74fec62a569bdbcb44171dedc1926c5cbe5d803c0c17ff419a861e9ee5b3", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x883F4BF1Cd53692Bb602BFb580d4B1504539dFb8": { + "index": 580, + "amount": "0x01", + "proof": [ + "0xcb96a348a9cc64d25c16ff0395ddf18fb7eceb808d8bd988d469db9d0f546b90", + "0x6c22ebb02fa693c6f07e126e470d434a0ad3501cd78e6792ef766a226adcb4fd", + "0x44e28972482d62299900dbde770b7f615c2062b558ca8938a3d427799471882a", + "0x9bd1c3205e48cecbaefedf96e5d998ea4bb84adb658c966bfa31e3599a4a0ea7", + "0x2e78635a0ed4a14dadd872d564c5dd2afc4f21b0307932d27d4471c48082b7f3", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x884B2737F355E1Ae0C88609c10BF7BC2f761f815": { + "index": 581, + "amount": "0x01", + "proof": [ + "0x87f050d8e626fb3dde60d52b9ad39f3e98831038fa958e83e7487e824d08ea05", + "0x9db80f247660d61beb3a018a785598c1536be2f221ee38a71dbd4c64f2ff6344", + "0xf2b143b8e4bb24b0f6133a57083058573afbf3f2d5a88213d4aef21a33017990", + "0xdb5507911490bc1574fb624fe6bd570cc6afcd947118f0c9c38fe90a00ee8b29", + "0x9dda7d74fd49fdacbeb3afcd37c878516159fe4b594e491ff7ecbc80fd8d6808", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x887919b67a567A7cfd16C86c09feD29219739f39": { + "index": 582, + "amount": "0x02", + "proof": [ + "0xd29947c53079932b421b0474d5a0f8ef6a5c4060c5744c4e95151a84586026af", + "0xb492774252dc0486ab9e7c95ee7f534e1539a4ac6d26bd1f81126ef5de019917", + "0x3cded42477683fe44d3b53da8af7372eebcf3f7b5d0c072544d9d80a0220aa0b", + "0x41e64ddeb2fc55a967472c34897707f35a7b74171d5a7d21351e62fd45ccae94", + "0x7e73f337249898d15604f7c330d90e36da04007407404a4b4276d5fe3083b929", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x88988B731F597076d748f24a46C1dc45533B2b51": { + "index": 583, + "amount": "0x01", + "proof": [ + "0x0379904dd23e3936d19c8f467f1d605c7c5c32c17d1c6a309b8fac9aa13ff6c1", + "0xe31823e26371ca906b49e20cfa370baab08ff629e6ee6b1211ed6de019ceb4a8", + "0xc9a2fcc0e974df7c3918b7b263d9c6dc39dfe6718696db40d299f59e058f7949", + "0x2be850b7e0b2b6c90dd3488b90e348653e541a9cd2983b235559153dffffe1d2", + "0x9be1155992502d2b75a54fc5b2a41d663a86f7d329faea1befa0e24965b01a56", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x88f516C04969f470888473458B5E09342Da08b7a": { + "index": 584, + "amount": "0x01", + "proof": [ + "0xa18f05f8dde57b2fcde4663dcf3c938edc7d0fdde1e41da35fd9d31dd0f0f6da", + "0xfc6474a7c7bfe6b0c19f19b0b1a115c18bdb531d8b9c74c4b5d2ffbced6b0650", + "0x7306ff63535bc4b71716d17c36277e5ccdcae2c03cbbe50c57c9420e43b33b29", + "0x4fa24b2d1635e25dea497fe90d30db11d577f752b726d47caf1b4952bdf93c96", + "0xc36c52715656389b2693c145860adf3b1f3d4d24a139850b1fa5f2236456376e", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x896aF07aaed28791971827D9d1445159501F8975": { + "index": 585, + "amount": "0x01", + "proof": [ + "0x89bc13243d3762cc61e4b7493a17dbc5ec6351353d2fd478d9a3084146a1f409", + "0x5c3bf72d1c17d5703c71b8ce6c9c73e08ed23562c707cfa92268545dfedd55a8", + "0xaf004a51521001e3a2257071c94b92bf3ca21deaabe3c3482b0ee37b2ab2fbbe", + "0x0c15cd0e5fb4411c59b182f983d4322f33d3be8bd2c5425b705021fa316a402d", + "0xe4fc54838dec16cd3ac94713f191dc41ac7f5e070180d4843c9aaaf9c71ce29f", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x896b94f4f27f12369698C302e2049cAe86936BbB": { + "index": 586, + "amount": "0x01", + "proof": [ + "0x099b36877620c4060593c0a80e0dcd57f408b0f4f6fc754fb1864427c2b31b2a", + "0x0f3d869910a29584f2bb769c71a685dbb4dbd507b4f91fb90373cca58fbd1efc", + "0x4c45a6beb436ef04cc6902dca8ec98a6004150388bd0a3f1f3e1e8d205a1e2a1", + "0xc50cae5631fa8cafae8224329322dbaebc117b278a8e07f29104d255198d88a8", + "0x4a36dc66177a8394f6b14fc9adbe4ad7e0cc2dead6acb72d80990e336fef8d45", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x897CD8dB078566aAd542607303F29922EFC0c7ba": { + "index": 587, + "amount": "0x01", + "proof": [ + "0xc8bd99d69582c7d28058b671126da61c83675f6300f3ce902fe7229837b30e1a", + "0xaba5806e44586fc162ab10144b8116fb6e5ed7e6b923fc457b203479a68c05ca", + "0x906c494d7d3c4c5f521930d1042cfae9154fc6b37e57ecec673d01e269ef7429", + "0x1f4f9d2e01bb8c804693d53134cf046798ee2607f0aa015ff42b474e23cf7ed2", + "0x97fbe90108c9d6db20d511e4419e4ed044f589ef1f2a9f6539187bad21502f90", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x898C4607809945b49d65Ea51580101798931B241": { + "index": 588, + "amount": "0x01", + "proof": [ + "0x02fadcd8060792b06d1f0c5984cf804e6af1fd5e24196add03b61be5d0bcc326", + "0x17e88fa66495a8438e3aa82205c5b0d72a32230dedc0d149deff27d2d7995591", + "0x473c279a80efdd22e0652061508704656dccd4cfb6e1c6c4e5d7b17c2a8e4eaf", + "0x2be850b7e0b2b6c90dd3488b90e348653e541a9cd2983b235559153dffffe1d2", + "0x9be1155992502d2b75a54fc5b2a41d663a86f7d329faea1befa0e24965b01a56", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8996b9B51D28D11d10671443c238789560298fB7": { + "index": 589, + "amount": "0x01", + "proof": [ + "0xa27942943dff57e2cd8a70301ce4c103714d9837607c4407e6f0a330f042a22c", + "0xd20395067e7aa297a0794f0c4430e89fb0a4e10fc725ba4473a040148c544b06", + "0x91479039fdbcfe3f9e57c85a35424ab551f951e96197067348c757ea7407d64d", + "0x9d1cf6e9f51d85a77dd4eec2524ba22941ec238f140f4f63c1712d78c1e4c21f", + "0xdf701aa8bdb3ffefff1b359214087cc585fa0a0d40716a6635a8d2db4380dba1", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x89F895a36954bB5C6a32de320A463F948dC202B3": { + "index": 590, + "amount": "0x01", + "proof": [ + "0x0eab7d7aaf98654c3479952d539d17701b3838dc438a6f48307bafa5648613bc", + "0xcfe102d511b2c5bbe3ccfae55610fec5d3b30b1796e45520509e73b2a410daa6", + "0x58fc0f95394c3d85af39af4ef41b7b5365fdab351fc36f9bff4ff8482e4ecce6", + "0x2eb27b26c39f3350831b9042b1a0e6295ae6da1b11f07f10b4a83da8dc66b536", + "0x4bab2069d20a5d1d2f5ebdb61803a57609b7709eca9e925e31a7d14434af1326", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8A71A81F119d85F0750C50d3abF724817B8C7B6B": { + "index": 591, + "amount": "0x01", + "proof": [ + "0xd92d8f20a120b83da0977e193e260bc3fcb19305edfa3dd0d269577371926e02", + "0x2c78a61dda165da982b5aeedeb9bbdb3169a9946cb61db1006a3543012a0c6fa", + "0x9dffadac20c132cf7ca3085a1eadd324aefc93eb96b7e6507e8e3ff06ba89160", + "0x539804c7bf7a9b6235d14df5f64369e5a3ba52daf4ce320d3134eb569c42ebaa", + "0x57a1600e1002b648fc38956dc1d2f34be5ee3f6cf170c73bd27c43b2a01e45db", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8AE551C03afdddC50fDdAC33226f81D3Aa361a0b": { + "index": 592, + "amount": "0x01", + "proof": [ + "0x18fc129b5cb5a4f51b5dc4c99be09215e9d94a183d5dab9bddff50f0e6acf2a5", + "0xb25cd9c460d1c120af4f52034d5cb37afaa7dffda7bd5617dc929e90eb37e713", + "0xf9aa43102404b84f14eba6125f677ccda1d14a7d5704168958698912672e9e8b", + "0x9259974d28cfc23eade84b4a12eba89f4b5d3b0064ca7ad3dcf3a6a6a2555c91", + "0x93994074bdd819d668a79fc2c79be23cb074a679cd3fe03940945d4c6f9fa9b3", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8B1EA47e37A70E7FeEFc6A6945a4A7272a7934db": { + "index": 593, + "amount": "0x01", + "proof": [ + "0xda2218a375a2d68d3dfee695ea225c89b1ad8754db52520e7f32d3c079eaebc1", + "0x06ec5cd8573fd9c0be190b49a8f23299fdb9dded86622e85111682119501720a", + "0x9dabc5eec4ef62215a8dfd99f8da29641f4d2cade52a73474d7fa008bf611d21", + "0x3cc86f19d7ab5abe54cb84f21d19174b3158c792e08130d0d4f813b822ec451c", + "0xd8ba0ec6899e7ab5afd6774d7465b2ebc52e677b805f74deb131b1b243bae70a", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8C28E27ff51F17267F0aE9B478dabF549Be7D946": { + "index": 594, + "amount": "0x01", + "proof": [ + "0xecb61f190897f669923a02df686b7840d8d26ead08b0e0e1e560f087783ca9f8", + "0x04d471b3f63fdfe552b833954e762dfd65f476994a6e4890b49e6222237e2e80", + "0x77487187bcb357b4188cf608ccfa3f6f329c635c083000f639cb79cc9e5b4cb6", + "0x338979409b1c886a92a48a505a3f0b093231b3d66119d999f9bcb41baf89c59d", + "0x6e496426985c92b04963088da4856230c781a975dbb5ce2d8eed77e7d2d4b58e", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8C31FF1F7822838711DFeF8c4a88731072d6965A": { + "index": 595, + "amount": "0x01", + "proof": [ + "0x88ab25bc9afa694b63f8839a3fd44890f571aa7f26d2f46cd6225c6cfec5018c", + "0xcdbd23a21efcdb7333f3fe35459410b0d684d893849da5a8460e96b5c6be5b7a", + "0x33a345c594edaf8461f1610783c243a81449ec27186711a2d756f2e892ac478b", + "0x16f452fd982f0f4e3fe20a4b2fdefc9226e8d1db4c0b29793acf9535b6c65c66", + "0xe4fc54838dec16cd3ac94713f191dc41ac7f5e070180d4843c9aaaf9c71ce29f", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8C33F4e49088AC743777fC167A32F56c2eb32291": { + "index": 596, + "amount": "0x02", + "proof": [ + "0x36179dd79ca2a01adedd74e5ed5943df8fbfa6054a87e4c9fc4fa5230f79cd84", + "0x27b230430b5697097df335836ea1f5ac32a0e386cc383cdff7d28ca614eb1bbf", + "0xb4e3d624b4c9069a7dbee8548a7744c0c011fbd5381a1988549f867ddd3672a7", + "0xedd365a7e73c5a47a076899344b760df86cdab5eb6566dcce5b550be9bbb5324", + "0x963cc7ad3f8f0ded379d05906b629df8cc616633784013c90731955d0b0736d8", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8C8024bf5f90a06CCeD7D32BAbcCB934942c82f6": { + "index": 597, + "amount": "0x01", + "proof": [ + "0xde1f4535bcbecaf5002c74b24f578bdb708a40e2261f14a60c85f379c300464e", + "0x8959d9d3238ab37dec4eaa2554858d93b800e4362c66b491ef4fe830d0e0a903", + "0x31a842d521aec1d044113ff905ab1b4cbcfd79d2a39867e544a17434c3fae105", + "0x285f0861eec4fffdb569c07f6f01125414c98685171578e7317ed5b8c16ba373", + "0x966715df220dfbe5e11392b257b61b64c18178d1825b654f95f67d7c9558a2a2", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8D3cD61164fF9a2ddCCccE933c5b4608F6562a82": { + "index": 598, + "amount": "0x01", + "proof": [ + "0xaec29d26286083664a20698447049c0617b9bf824d56701588ebde43db9eca88", + "0x44247f6686d7515270e1655e7b675aae734b229fed9f2d979c0479460af21aef", + "0xcf221106eb3204d78b5ef9028e613c93c6b7a5954f19a30ac14d1d5567f3051c", + "0x298bc701f239e72f83c6fbd5aa5172caa103b1453ebcf9fd1dfe23628f4dad14", + "0xa952d1dc401036dd357d470bb699a7e9cfc64f0caf6dc51a638cd2487f5e73fb", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8DC4310F20d59BA458b76A62141697717f93FA41": { + "index": 599, + "amount": "0x01", + "proof": [ + "0x9cacb78b8c2c58f1e9df844ad3e99ee70b85e95ad7da91350ff9a15bda9070f6", + "0xceb14a87e05e18e322519107ae5ea9ef1fc0125141887bfe7989570d7a6fd3a0", + "0xe767c29b89a3fef6f98f344b4b24add9c02f5cb6d6e67d487d02bc732178dd9f", + "0x2710311af5d5c72181aeccf7f1e36c3065b1ac40ab236128e22d5cefe5ca9032", + "0x0b385e4882f89784f506afafe6dd217c6ad9d142ccf58713e27961d25b2c6d0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8E7bD3dc5A41971455a7e5AF99C3ab77766b964E": { + "index": 600, + "amount": "0x01", + "proof": [ + "0xd10f01ffd823eae923df6a0ef5c7e18cc49ec4d687167840995fa9b6e9439c0e", + "0xdfe1b471dd584259e583481eba009971c7d2d268ac2ab184d800d26b2d5e6737", + "0x45b3ee84bfaab4fdcb6b276d32ba091b4d13fb4a3385b5d29d91fb477bcd0392", + "0xd549250cf81d453ab878cb87d004bd56f5975ca86398b00d651f71d522925a30", + "0x85ada07677b521b0dd2e0d60f51f92f7b1217f46e36379a5afa5a74fd5c87a5a", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8a83716acd66D9e1fb18c9b79540B72E04f80aC0": { + "index": 601, + "amount": "0x03", + "proof": [ + "0x48c52a37bcf3ed269df46822b3130bd61a73b73d52d9174fffbbe405f495ee6a", + "0x0c15044f5711bd573ed2adb27d2bb70d44e0b2cc3aace5e1c5ef7031a4ba8710", + "0xa1607b1dced9e8d9d1aaa755c5c6bc84b483e3063f866818b53e0747d67d0d1d", + "0xa5e8bb53f83c3715772cbf32d53d2e1c1c9b5abd0d51618f0e2ec2960d9a33b8", + "0x43f59a603c2458850547e5a84d47e61be843b4a3c814303ed1b52e1e4d37a1b5", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8b024e6EB9Dcc2A7B162e1750a6f157b29A1a8bc": { + "index": 602, + "amount": "0x01", + "proof": [ + "0x0798a7fc874a974ba7a4f35f19cf50674c0fca55c5828c2d4a5443ae4b2f3c97", + "0x524e6a9c85a61dcaf3341df604f2c5bd9920ca0fae7e78ddb1feaa128e0292d9", + "0xdae2fa58d07da8c33da0b26d0890a4bf9f3cded6c882ce8613c4097fb454fae7", + "0x7123b37c640e8ecb7e1db656a0f1869aecd392fe2f9511dc671c16401bc54aee", + "0x6e752d8572dc933bdf463f24751c7070d8aa74bb8987a5fe56dee3b0c9f53450", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8c4B59f6ec2c02E45C2a404448DEf3a7c0465Bd3": { + "index": 603, + "amount": "0x01", + "proof": [ + "0xcd44fe95814c2e4e401c388a9be49ebede2ca2fce96791ec0f88b97e6b98b2f1", + "0xe3ccf3f83867e7d9fad28135680e563edb49e78ac5a50b5c7beb1086dbf460b6", + "0x80afd91747cf4aadcd0a9bfc4df210ea0e0b85434282ec9bee91d7d5f9165218", + "0xef33e9da5226ecbab5796a616b47d5f4223c729722fba46a5cf043b7bdc381ce", + "0x2e78635a0ed4a14dadd872d564c5dd2afc4f21b0307932d27d4471c48082b7f3", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8c82cc79371A89D47E52b62c86d4aa475ed12F92": { + "index": 604, + "amount": "0x01", + "proof": [ + "0x129312ee54b9ec2cbf7c9d5bfbebd194dbda23146251c9484e68e7046e6108cd", + "0xd5ab2d73f80cd82ad1b08edaad38e39abb311ee0e5f6604a36bea3e348789028", + "0x845cc84318cf86b31a866d4991f68f70ae915279f96750b537b675397281505c", + "0xdcab737bf32fe2edc99f37725a5c46b3f4c2b142298388f08a1bc983981697d3", + "0x6431c24d3d46ea6b0d1959c0de03265dc474d3e67139f2bedca26b5aab0c0c5b", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8d586f380846dCA988cB3B345231AF02F989C411": { + "index": 605, + "amount": "0x01", + "proof": [ + "0x1b179aba6495f3d91211b7ccb97937b1366fe7cb8b44587091eca587da2b1df7", + "0xea005bf24d9b0efdde9111776e63d08196407f392930ea92268d65f6d54ed1f1", + "0xfa32f82efe11ffd2403c559b1ec3e3004c40156be97edaa5050d9a8a56426e05", + "0x6b5b18bfb5c7b8de5b52219b51a21b6ff6e22d5cd7a147d521bbfac13cd7f7ac", + "0x93994074bdd819d668a79fc2c79be23cb074a679cd3fe03940945d4c6f9fa9b3", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8e4a4eBB5D1f689aFaaBCe37eec80BA50b0748D1": { + "index": 606, + "amount": "0x01", + "proof": [ + "0x4f6fd9d79052042569c6799c7af970051b190b04ed9065827bf962f65d330053", + "0xf0952fbd6b81dd2889aaf53103fcf949885e18dc3e92dbcaed57051d365fa9a1", + "0xe823abd564575edaba5671df2299c869d599b76d50814c956babb2392af273b8", + "0xde9fcf6a43c240e1d4c7ca780516b34aba68d02c35c5ad3090d1ba1aa8d40999", + "0xcc9986a7987738d81db64db86f583aed4fde214b766f55d0f15a876c8f790fb8", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8e4e9De7eB20a9dCf2Ae387DF2ab59f79BB6EBfB": { + "index": 607, + "amount": "0x05", + "proof": [ + "0x0778a0cac039f2e8e7e2e8b78f19f4f5f2f358e8abb162aab82b8e5d828b1ec8", + "0xb07bb32ad80d56890b18315cc49e506789f445c92b690b1ebe2546b68dd97b58", + "0xdae2fa58d07da8c33da0b26d0890a4bf9f3cded6c882ce8613c4097fb454fae7", + "0x7123b37c640e8ecb7e1db656a0f1869aecd392fe2f9511dc671c16401bc54aee", + "0x6e752d8572dc933bdf463f24751c7070d8aa74bb8987a5fe56dee3b0c9f53450", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8e70e0E614245d0B13EB549c4b6aee8CF8D9E3c8": { + "index": 608, + "amount": "0x01", + "proof": [ + "0x24dd2bc10540ee239483b66d150b8d52d97ca4bb47eca7f38ba9e7cc41e6c38f", + "0xaac75d6ad471e301ea46ccdd344d7d1f4eaa8a48e3f07d0d27329e6d0994e283", + "0xcf959dc22eda4cc1f43407713b0939306c53472c1295a5b191e90fd79f98d755", + "0x4b1c846f0a8bc448aead7f2cfec46ac450b23d2f229b5350dd63009a82a1dccf", + "0xe29ba79106b7b14c14912bb5fba509f27997ddbe5a7ebc941fa75e3475af4aef", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8f2CF9e24fb1938a693e4B2d4fF3a64E47Ba2ED8": { + "index": 609, + "amount": "0x01", + "proof": [ + "0x3e2d58b2d36882ec6d95ed444832223d30d13f2ef494ddb777d99d332b20bd69", + "0x3140324bc56dd1c226a01d20700027866c92bd334d17de81760ebc58afff952a", + "0x9bbb60a5fc709695e163323f3a6b2381dd7005d331356c8315cc8d38b4d9cbdb", + "0xaf86f597317f3202fff25068896658613bc0cbf9d7a66fd51e55c97f2358b8ee", + "0xb5bb98883f5ea232108866e1400cd4067f34fc2d70605fd2c67051a6095af7f8", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8f4AD500Be6248698773aC0c6baA159828ec4401": { + "index": 610, + "amount": "0x01", + "proof": [ + "0xee394e55aa51229e7cce954c17f3051af2fd14a131b237d1fe9683d3f9182453", + "0x765870671b1dbffda85c7d9df5b5d44b185943d93e3e939be1ddc037a995e2ee", + "0x87f9ab6301cfcfa1972d69c933df7d435beb9f98f524bff8460141fe4ae2233f", + "0x88222db835a579969caf99eebc6d7f986a78bc44f46b794a4319d01749c83a2e", + "0x6e496426985c92b04963088da4856230c781a975dbb5ce2d8eed77e7d2d4b58e", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x8f9bE4310f9AbB0E5843Cc6363908C9B01dfeB3F": { + "index": 611, + "amount": "0x01", + "proof": [ + "0xf5b8a169c6d88e331138fdc909297971f028d5138be5a04ae097b9a308cfa421", + "0x0466ec9a4b1a70eba51d5845d10e3bcbbf2fd7a84b89d599e381f4591b51a2ee", + "0x3cf18ad5ca915c66f70477dcf495054eee4647174a0cbbdc03c3a2a0a13dee2b", + "0x11f5a22099e6617cfb9a813c15cac667d29fe00a5f0d1618572f9c1368ac6385", + "0x8e7f75ccc4d864471b1a7ec71efa29a4e8cc4761c26a6987c8043d9ca642a2a0", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x8fd05381267eEf20d82536E93848E8a7801AAcF8": { + "index": 612, + "amount": "0x05", + "proof": [ + "0x02ebaff54f76956863fb78d8f79e26505f74664848fcb2301cc44e0790f462d9", + "0x17e88fa66495a8438e3aa82205c5b0d72a32230dedc0d149deff27d2d7995591", + "0x473c279a80efdd22e0652061508704656dccd4cfb6e1c6c4e5d7b17c2a8e4eaf", + "0x2be850b7e0b2b6c90dd3488b90e348653e541a9cd2983b235559153dffffe1d2", + "0x9be1155992502d2b75a54fc5b2a41d663a86f7d329faea1befa0e24965b01a56", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x90C35C60A9665A98eD03e9072cae52A0232f3376": { + "index": 613, + "amount": "0x01", + "proof": [ + "0x9f6af6fb4755a7e66f7b7170a2197155cb762422e4d1d6afdf03096be01991fe", + "0xdd9e25d6522d53a2a041c98e65409444bd656dc47ab2a56452eb2e2b43d08ef5", + "0x2fbab75f362970937a06d430bd893a654663902ac95b78c258989474b316ccb6", + "0x35b38a743320b292e89d9164e2c2e5018fa2478f9a132ef65671c9bacfe611e9", + "0xc36c52715656389b2693c145860adf3b1f3d4d24a139850b1fa5f2236456376e", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x90EDbe3E631a80b0c4724405d0C2D14e306D365f": { + "index": 614, + "amount": "0x01", + "proof": [ + "0x78ba543c430ad87db996bb45369745a0d7e1621418a7c595ae005ceba1fcce2b", + "0x4d916e54bf39855ec598f38830389e269e7f442b31a226fc8702ffd15d59d0ca", + "0x430e9eec036c03066fc0319049daaa271c11c2e68b105a49cf5a3f241fa703d0", + "0x9b12cab9303ffdb5818321d84969747034ab90e273c8fb6d0031d1f6e3e1f83c", + "0x80cf615f05f15e9ed665dd7df5d086fcb70ed5a5086e02db7c08752fcaab6507", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x90aBCf1598ed3077861bCFb3B11EFcd1D7277223": { + "index": 615, + "amount": "0x02", + "proof": [ + "0xc412ed65ba23966e7f1b7f549373f677a8fdecfd2971167853cd88663282b91e", + "0x01f7621316edcf4eee7e1a0377be2d960e83cfe48ccb0a6567b876ce7b1d1ee0", + "0xad348b0f72a246f9ea29f8876073a3c8a866ef71430904c9f0114b6bd4631fb6", + "0x65c5caf7f221e805a211309d005cab013498255a9343870184292835ae911371", + "0xcf22c1d43a94c7c6471efe1209a3b103ec0a9836b6c11fe8d2e98d18b2e9cb36", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x90ae1bA6e3d33775B97273902a06560aA6aC4c96": { + "index": 616, + "amount": "0x01", + "proof": [ + "0x368b2c486e24f3ccd41ec42a3aabbb0c0e23523cf2b27321cd63e5ba8289e82d", + "0x2376b40b0bd18445d7bacd2f46c9264d69a2dd66d8b9bdb9a6610df295422c0e", + "0xba70c400dd80e4274e96080abd494fc3d055f32a6397ae40d812707e3922a8b7", + "0x26d5243ad79c6ff0365171b12c8ef795d8c977a57cace1265e53f8b7326c312f", + "0xdc998377cfbadb1c2d77196acc69c259bcfcc6de58df7f5aeea2780a288f2509", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x910f50D0f8c5Faf30d29fb9DD1B7ed65C5A444fd": { + "index": 617, + "amount": "0x01", + "proof": [ + "0xd6908e2653acc1acbdcad5719bdb785292b6001b5495ebe6b644b99ca3a5dadb", + "0x07730ce4488fe2287bd7d607130c6e4195a27714289b2ce16b743b707fdeab7b", + "0xc38008defe51c0239555c45ec16a876cbbdd254e08722230d0d69a1db6d54953", + "0xd382b6f12ac3804a083f91e50c5b4faff460036b8bbe9e3c74b4468370b346f2", + "0x57a1600e1002b648fc38956dc1d2f34be5ee3f6cf170c73bd27c43b2a01e45db", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x91B5b2B55E326Bf6aC407d274711d01253E19c4a": { + "index": 618, + "amount": "0x01", + "proof": [ + "0x991f7beb163e1a08e7c80bcf5c29e2a8719b69101d3eda527b848b6525c12668", + "0xc6d56ed1e881993b8040ac45d275f6bed4af342064a864de32681015f370bbb5", + "0x8b0939c5da9a4351dcc809a063b8226bb4eef5b67c44f5015340b9723d256a41", + "0x0209cc90d619e0e5f56081126d2ed4018391f3d9e1dd1238794235d656c68c9b", + "0x62ba7b58fd554e8be295bf9d4baf9eefd0b518ead5cb8bab321717a08160ae0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x92228FFb485Fe39E5479837E0697829504527Fdf": { + "index": 619, + "amount": "0x01", + "proof": [ + "0x7381add88cfdef19fab9a1a5e6eba4112481f01f8593d50a065b5eeee5094a83", + "0x50065a08daec40d8d6da4d1404026c837e3a44ac741d0a9e2650ee37f2615e8f", + "0x8e6c137a880fc95bd5ee7752b07878a345c6c782dd2c5f54cd1429db575fc484", + "0x0dcce906ec5827bcb3dee3fc162b46bcd945486f9b95e6d9175120ea721c3e19", + "0x7abccb934a7f719fa80b9a5d3157e99d45ee17a391abf85d4f60839dbf3769cd", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x922e1ce088bB4Fc0295d992070B65088307957e2": { + "index": 620, + "amount": "0x02", + "proof": [ + "0xd11531cbd89e65d42b197c2554eb61a2a63674b99691902be3c50bb3823a1900", + "0x284138aafb11de2200940127ef6bc34207a21e77ade6707bebc808d0da57ab45", + "0x290beee419f0613b459c711e5b28028d47a7d1917c0eb36c686bdc2bb4991683", + "0xd549250cf81d453ab878cb87d004bd56f5975ca86398b00d651f71d522925a30", + "0x85ada07677b521b0dd2e0d60f51f92f7b1217f46e36379a5afa5a74fd5c87a5a", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9262b55E8E670826132c3b61442B02A969C12eba": { + "index": 621, + "amount": "0x02", + "proof": [ + "0x6eff4e4bb16a546bbea70a349c7e78d6f1c42571119f5072d9ad2fe257d6915b", + "0xe48907b05d0e777121c74b9df4d132da8222373c7e82e518957578d2ea67a9e7", + "0xca0621c350e7f4c10764a38942c3df34cc262e74fd6d9d2f4434fbf0443dbea1", + "0x7c0de9d8e837704a5bbfc4993fa9b20e3f698f1b885a0b593d018e35bb790c61", + "0x1be60ce906d0d73954b2e1f2747ea1c9a23db0ad9345fa6801c551f1a39fa5ab", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x92917666b0fFbD39D4CE4fCF2DF1C6C4808cfdB6": { + "index": 622, + "amount": "0x01", + "proof": [ + "0x73c1abd95c0ac66f6fc961e2f8e4dcea01cf9c3a68a4df7dc5d7e2732973d127", + "0x33f5b44265174df5a561273a42732cec68a31179b1519b8905e3d5389803eda6", + "0xd4cc5cd424ec4a17ab20cb4944d11cc81c6d34f1f8242f75b4f4111a721a2141", + "0x0dcce906ec5827bcb3dee3fc162b46bcd945486f9b95e6d9175120ea721c3e19", + "0x7abccb934a7f719fa80b9a5d3157e99d45ee17a391abf85d4f60839dbf3769cd", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x92CE21069b407256f2CDDc5E28e8285A132b62f7": { + "index": 623, + "amount": "0x02", + "proof": [ + "0x2e42dd61dd62f828700cc798d6bf8aa520a34a8d0a365918476a0c1eb00435a6", + "0x1252bb08b28cd71d6c402ca3373c01f44f8f36825248c5f0a85d4e5c4a5cbe8e", + "0xd7c1a15b710f86aade261c04d27fec83ac6b798b76f86972e953c8642432c14f", + "0x9e8ae6c0c829ef47f1fdcf07618192e842b30fccb4c38a8af79f05f97c75c097", + "0x4325701890e79e85b41231157c1ced07357ce871ed6fb4f233c2f82c38bcf4bb", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9325564ADe7683706107685Cf1993678B1163261": { + "index": 624, + "amount": "0x01", + "proof": [ + "0x3adccc66cb73c333eb8f247c03f9c78352c12492425b52715d90b61bcc289bde", + "0xa0c00fe651542ce532c519f2a8f8d135342c35e4dd428389f37c8782872d46b1", + "0xf40d9321096b33fe11dd3bb5f540443ccc3463fb86ca7e96dbab2cdec392fead", + "0x60583de8b96cf21d7bf97a30f8f28bb928ffecf01373b007ee5bfa1bb5a1f776", + "0xdc998377cfbadb1c2d77196acc69c259bcfcc6de58df7f5aeea2780a288f2509", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x941653d6e49399D85639C7d486410c0A29185118": { + "index": 625, + "amount": "0x09", + "proof": [ + "0xbdddd0bf401f4834b1c10bf5d52810310a279265fc2536c88c7cb136ec53750a", + "0x5a2edf0e885259fc44fe3d92575379bf3b1e5641428c327cf74c83d27f35667c", + "0x81438df7a27c7be027c254bdd75d2f0fd663816eed20147a4ff92559013874ae", + "0xde546e8389f64cf158f6546ecf18f3c473b0c5660810c1eba849db699f2c4883", + "0xbd7abdce9ec414fe47ea73146a2131622bdacb914ea6353abee1b0a149275092", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x94386491b7d1506eA9D29D4545F619db0e697986": { + "index": 626, + "amount": "0x01", + "proof": [ + "0x8cc868866cf78fa0e7897b976b6b439e2d4ec6a0ee13048cfd0556a0d95191fb", + "0x0b0ff71f23dfe0b91fde49e9139b4ef6ec694f8b542fa2f15e8dbf129181db35", + "0xe1eadcfc59183c7853b885552d4ed0af4a4691e55309e8d127f67718d28a68db", + "0xe04deda4b0f0ea0bda4320a7f8e55700dc470bdcfba68775214ca25f30ccc348", + "0x8fbc13f50b0f82a781945a74ddd5c5abde0b4a8983852c66ecda77a68df50722", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9452244FCD1AcD78eD22776e1f8bCdD63BB0b074": { + "index": 627, + "amount": "0x01", + "proof": [ + "0x74ed979a003fe98319c94366902c30997aaf359997bbca7f42169861c49b84f0", + "0x533638642dfa72435d172bbf5ab67254649fc8a0c9aa6cbc90bbbab4ad46ac30", + "0x1b96dde5d525085e1803041fc699ac898e6dfc685d023f0edffb1520d8a514bf", + "0x396e47c3a850c873832c034b62c0031de9378efa99594428607ab8c6bc01e27f", + "0xb78cb1aa869958030ce4a14b5fff6309166225c83e0cdd2b91deb7b1639f67c4", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x945813970115558e0fBa48330f7Adb768CcFD556": { + "index": 628, + "amount": "0x01", + "proof": [ + "0xf8541e20213745f7b78e8fdeea6e10125e3471db5529abbb766e2feafc0eea1c", + "0x275894f0417cecd9b43c98723a1d5ccbaab7fe97d29415a58006d94c8d87eb84", + "0x4bf5a604b9a09c347e1aa7d41b0a7679a3e791ff15d6e96a280af113935ff733", + "0x3aebe8d88cbaf4043e28b3d6aad9a1f79bda4dbadcd2f685785a58d155fbcc50", + "0x8e7f75ccc4d864471b1a7ec71efa29a4e8cc4761c26a6987c8043d9ca642a2a0", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x947Dcd4c2C0dDc357925D38135e350854f8C9A26": { + "index": 629, + "amount": "0x01", + "proof": [ + "0xf168dc30c1d9d7139ea873f4fa1b3f3f553436a0368d678c427f8ebb12ca428f", + "0x9cafb886246245c5f1fe460034a0280a3843cc686973b79d943b98337c62627a", + "0x7ec9bc99b06cb88cc17f324af3ce04347d9712a8cde058a864a99e2270fa22c9", + "0x27cae8e1fac7b32e83e85494312638757cf1e0afea8f4e6fe77387c412b4efd6", + "0x58340ed8edb441d787ada6b1aaf2b1e42912724e1f0f7887cde9253262aa0534", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x94E2DcF00CF7e33a4643478bb458b8123043116e": { + "index": 630, + "amount": "0x02", + "proof": [ + "0x50bae874e12af6f9f82f4f8173bbb36e46e438dfe73bbaaab24dd7670b435f10", + "0x42d1ff6d77f8a444cc01a0f74cf0fc10fbd154ab12d56fe95a0fd9d12a53ba5e", + "0x94ae5af5bdf40e5d21b91608a4452d0ff68fa67ab1aba8eb3e2ef57df1ed7d47", + "0x60ea05c082bde3732ec3daeb0e2bae0395932096e755b1a42d9def3042bddceb", + "0xcc9986a7987738d81db64db86f583aed4fde214b766f55d0f15a876c8f790fb8", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x94e64d925eA0D2ea9b143bCe58A74946cF76Da92": { + "index": 631, + "amount": "0x01", + "proof": [ + "0xb4039186eb1cb09e0a153b174d312e35b7aeb0478344b814bcbd1f81cbb6430e", + "0xa45c32314f5b903929e6a93f66558308b4064d319394966eb073163372da9364", + "0x0826ae5bb3f37697633d99d3705ae48cde39e7b0d247ca8a78e1143ad8ef0c99", + "0x575d2e3f9c311244d801f96a2b4f9fc9666f8793f898d400d71e121add7f872f", + "0x529f1b48ab616d4dd60f663753a7779d8ec25952bc8c34df4aa96347bdb0d542", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9554A1Cf07a20616778821Db521bAaCaa79a6631": { + "index": 632, + "amount": "0x02", + "proof": [ + "0x48410f6a4d851ab84c337757b46d5b96686520537409f503aeac0cd1d29fae09", + "0xb9baadc0797d79ff8f40903bdc5c0ed125727204adda4de67988ec84199044d1", + "0xc117d5a519f6e0f840872df99b897139406abd328261f34a6e382399bddb5bca", + "0xa5e8bb53f83c3715772cbf32d53d2e1c1c9b5abd0d51618f0e2ec2960d9a33b8", + "0x43f59a603c2458850547e5a84d47e61be843b4a3c814303ed1b52e1e4d37a1b5", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9590C48628DBD8a22861f0988ac6a2b6aE014665": { + "index": 633, + "amount": "0x01", + "proof": [ + "0x72b629c2241f101764909fa00e022cfcc6ce290a82d51923248d27c87425d470", + "0x50065a08daec40d8d6da4d1404026c837e3a44ac741d0a9e2650ee37f2615e8f", + "0x8e6c137a880fc95bd5ee7752b07878a345c6c782dd2c5f54cd1429db575fc484", + "0x0dcce906ec5827bcb3dee3fc162b46bcd945486f9b95e6d9175120ea721c3e19", + "0x7abccb934a7f719fa80b9a5d3157e99d45ee17a391abf85d4f60839dbf3769cd", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x95B92259AADaD128010B010622C65EEF5407de78": { + "index": 634, + "amount": "0x01", + "proof": [ + "0xddc97ef31b2a2589263c27729842ae91019a6f7ef4100deb617f5358ef0f9ccb", + "0xa17bded509fba25ac9fa8af53dfe82bf78b94bb09d35d6c304a40fc4c2f0b837", + "0xeffafc2bde50804ba4e5e2909025d61329f3df3401c7029f57fe93a263cdfa73", + "0xc84beec6531767197744c2106caed4823936b1ceed7475952444acf832b57446", + "0xd8ba0ec6899e7ab5afd6774d7465b2ebc52e677b805f74deb131b1b243bae70a", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x95Ef2c983E1888b8C266Ada6A922F98638754efD": { + "index": 635, + "amount": "0x01", + "proof": [ + "0x34460a8545b4eb15ae2f9dfa719ab6c18131fd9c9b360b0790b85493758998b8", + "0x9ca6228324b6e39fa902ad430cf1a27bd84d4cc6a7ebbe3adb02c0283b384910", + "0x0d061c4a4ee6a211e679a3211e00807beb57846100abc7f5eebc13ff2b92ccdf", + "0x9c7a414e889956f4c85241ac1c103f8242a6795725b10a2a17d9a1d125767087", + "0x963cc7ad3f8f0ded379d05906b629df8cc616633784013c90731955d0b0736d8", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x95dA76044106B710D56e6227774012A4A9fff0A5": { + "index": 636, + "amount": "0x01", + "proof": [ + "0x8004be32bfd41f1adbc8bb1022142bf57bd55df7a2530854d72721869f172556", + "0xd9ae8cd5daaa697b02d60abc36ee0e447e48aae6ca85f0104e0efd80ff01901b", + "0x5ada5cfebfc9093074af257daae2c61d27b871598065cd29bb9a6790903c5c37", + "0x138bee476bd8ce498e2985571c0fd10b392ab6afd8c1bc3ddfe5859f552044ff", + "0x891a74fec62a569bdbcb44171dedc1926c5cbe5d803c0c17ff419a861e9ee5b3", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x96C17Fc3f1dB1E11b4D5d09025a38fE50914B9Ff": { + "index": 637, + "amount": "0x01", + "proof": [ + "0xf63b9035500825551d62b06761429c1bc048f21fa39d103a0247dc78b6a4b21c", + "0x0466ec9a4b1a70eba51d5845d10e3bcbbf2fd7a84b89d599e381f4591b51a2ee", + "0x3cf18ad5ca915c66f70477dcf495054eee4647174a0cbbdc03c3a2a0a13dee2b", + "0x11f5a22099e6617cfb9a813c15cac667d29fe00a5f0d1618572f9c1368ac6385", + "0x8e7f75ccc4d864471b1a7ec71efa29a4e8cc4761c26a6987c8043d9ca642a2a0", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x96Dccda39A4029b03194E9969b24D4eaaB19AE08": { + "index": 638, + "amount": "0x01", + "proof": [ + "0x1525b275e57504e33323a751f54010a2ba6268bd603c1069ac3d518257867fdf", + "0xf9d7af9ba5ece49701dca05ac2748ebaac2ab1f6e47bb5e7af2d8c77d042f41d", + "0x6ad3e4f2caa71a096b05092a987778161c94be804760a6af684872b249faf74a", + "0xd4e406b94f7009e26e52781d8bbbf71780c9ab5d8d7b9162b8469ca115683ffc", + "0x6431c24d3d46ea6b0d1959c0de03265dc474d3e67139f2bedca26b5aab0c0c5b", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x96b215ceb2C5118141BC0c94C1401e377c6F2Bfd": { + "index": 639, + "amount": "0x01", + "proof": [ + "0x910195891bf766a2e04973751f12b3b366b2946abb2581d5589478d30d169e06", + "0xf92ef9e908151a0ae8816d2bd70c1c9356b98500d792d7dfd5910a2e36716db3", + "0xe08ba4e5ddf5c7b3ab07672afdf53c0a975a407af8a156203f47781efabe266e", + "0x0a650a18b5dc7e14051f590d1612c3614c677cc931a3bd72443efdbdec9b6fb6", + "0xa4e0ebcaa65c6595e7c7f0ffb89992e2b9cb58ac405c81aff220fc4b16ea3b6b", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x97203b7C4699230DEdce5841966930b13Ba3eC92": { + "index": 640, + "amount": "0x01", + "proof": [ + "0x6fd40abd7f41fb29591319711eda33c2a2d44c36d0eccc1d36e2dc7f5101609e", + "0x439bfe0ba4b15551b1f214e7bdff94460c2b7ad2f79158b2b10d18db8bde0828", + "0xac8fd80a51422b299c5bf7ed366a10de6c633f04e56e7d1a93f0b71c220e8856", + "0xfe79a6356c4cd9282dab3a598f859bdcecd04fcb915a9edd66380a81697af3bf", + "0x7abccb934a7f719fa80b9a5d3157e99d45ee17a391abf85d4f60839dbf3769cd", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9764E33e6593149F2dDbf2DbdF5148D56E1F1c00": { + "index": 641, + "amount": "0x01", + "proof": [ + "0x8f0bf831a14fb1da9e933f736bc0449578eecdd11a6a0583c8f7aee5c1a6c804", + "0x2145735650655b7da0477cb392e2faae0fcffe71d1bf2f1e112c39705d704ab0", + "0x71bf6e85247d9d89451b82be9a28d64d19071fd3c122e3bcc6db9f470fb854d4", + "0x1a6147d096056583b570a6da72277e79d6ef31519ab9cdbd2d1115f5eeb94a46", + "0xa4e0ebcaa65c6595e7c7f0ffb89992e2b9cb58ac405c81aff220fc4b16ea3b6b", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x97fC31117F7F252F99C696d4Cd24eFb91d30cac8": { + "index": 642, + "amount": "0x01", + "proof": [ + "0x24d075ff3b9965e521fd4d0ac05cb4f2d0aea7047be0b46de8f690a49c644f36", + "0xf77691e03e1ebfef88f8eb0b17594ebe75d4efb92ca74bea3e486c60d796e669", + "0xcf959dc22eda4cc1f43407713b0939306c53472c1295a5b191e90fd79f98d755", + "0x4b1c846f0a8bc448aead7f2cfec46ac450b23d2f229b5350dd63009a82a1dccf", + "0xe29ba79106b7b14c14912bb5fba509f27997ddbe5a7ebc941fa75e3475af4aef", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x98E073b579FD483EaC8f10d5bd0B32C8C3BBD7e0": { + "index": 643, + "amount": "0x01", + "proof": [ + "0x77937ac683e358211cd16ce9b6908c6e92de637a613f34566c1764b138a0551a", + "0x0e860b7153c1d2a57405f9329575ce8eab8411de3f45afc7b6e19808a7e6cefa", + "0xffaa2df36ce81efbe18a3f705e17efe3acf4e87e4d8a4423f01cfbe9c3278f32", + "0x08cb8a426c97a85d30cf9308f5228aadeeb1f2c3f1f22bb2fd0d6c1a680a3ff0", + "0x80cf615f05f15e9ed665dd7df5d086fcb70ed5a5086e02db7c08752fcaab6507", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x98F2105F92A12885eab8EC144653EB215062D9e1": { + "index": 644, + "amount": "0x01", + "proof": [ + "0xb8981e3851a6ed0c37cf8ef8d89b1f7ae9dbaa85801f3d4aced8fdd6d1b4ae80", + "0x07c81adaefa216a3dde296f5bc0b7e27fdb5a714dbe3d2c67bd624415b3c46e1", + "0x96a51c82a51e9090e50794110f5ae30726a62fec6e8961aeea449b4515be8759", + "0x4f5594402e5d778ad5cd48b93173f203af8e62306714d707dc5f989e11faa170", + "0x83e262e483a6f2ff9f4df14637dbbdfeddf0c6b0b4ca462c4375d29a3521e052", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x99391C6F4d33DdaC56E0856Db4eF0013851031bD": { + "index": 645, + "amount": "0x01", + "proof": [ + "0x0475d541d8c128170a97b5f7733b61b79170326020d27af98d8ee7d313225944", + "0xde1c042ea62a5e234f17de53658b441c698087f124f858cb9ecda7be560f347b", + "0x3b9ae731fb4fc0a972a141d2c931c7e4afe1020d11bb774ef3a217e73d2e8b23", + "0x2782f91cb56c53bb349c99893dffa8838299f03f96c6519b56f604653b45586d", + "0xb18758ddf98cdeec3d020c2379717281f5c0fa0133be7d006f7f753c756da43e", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x99394b41Dc263d7C85AD09e44C51E0e72ac1ffD4": { + "index": 646, + "amount": "0x02", + "proof": [ + "0x9e41b9f3311c9f5d9261efafae7ffb5f53974ff199b2df4e912f7741585cddea", + "0x16bbfe1ada20ec626f78c4d1baafd314127b368c70f11d00c82650d4fb2f54cb", + "0xd32dd306d1f42a39806611081f48b9b83cb4608e909a84d098d91b13868c6029", + "0x35b38a743320b292e89d9164e2c2e5018fa2478f9a132ef65671c9bacfe611e9", + "0xc36c52715656389b2693c145860adf3b1f3d4d24a139850b1fa5f2236456376e", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x99cD7edf3a6C90A0168C213f22935358bbEa8c38": { + "index": 647, + "amount": "0x01", + "proof": [ + "0xd6599b99ddd722e67bce78afa3c729c331c9e2c382d3d2407b55538468fe8962", + "0x9a8c170967f2ec100127e9fa78d82a6e68ff7867357e255b43c9e2b64c9aba89", + "0xf1ba16133c06bfb62c0f34a7f2c60b2d060a7b428988c8f8b9683824c0eff3f0", + "0xd382b6f12ac3804a083f91e50c5b4faff460036b8bbe9e3c74b4468370b346f2", + "0x57a1600e1002b648fc38956dc1d2f34be5ee3f6cf170c73bd27c43b2a01e45db", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9A0E30951A916EF100B11B2e93ef0B7552d61aDB": { + "index": 648, + "amount": "0x01", + "proof": [ + "0x82bcba1b8c95e076e3a2042caf19e3553150e830361888e8e067549f48966987", + "0x45b91e5e98b3e48fc5a35c7b9cdc31bc33b370e8078395ad38986a71d76d9e02", + "0x4e10e7f195c67618f3d3a7993df508e04ac06383b5ec9580c6c0aa53b1917d0d", + "0x13c4723f9c83e02f8e5d7f08a17afc4776844c18a0189a9fcccd2702d623254a", + "0x891a74fec62a569bdbcb44171dedc1926c5cbe5d803c0c17ff419a861e9ee5b3", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9A9bADF8b5d14F8f2340180EEaC1c80082f26289": { + "index": 649, + "amount": "0x01", + "proof": [ + "0x136b2061938b7c3a5b611bb2f9fbf5e1bade2bb42580e1d5baff36fa59a8828c", + "0x3cefdc6cffe7478184d2ea755a7568ec03d8e12362a5cad4206b454a8c75257e", + "0x5517cea35fc2ef88c454c0abde49cce58c62d4d8057d3493875f1024ae1a58fe", + "0xdcab737bf32fe2edc99f37725a5c46b3f4c2b142298388f08a1bc983981697d3", + "0x6431c24d3d46ea6b0d1959c0de03265dc474d3e67139f2bedca26b5aab0c0c5b", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9B1E347E7ce83caF0e64EcE41D2A4ab7F78585D7": { + "index": 650, + "amount": "0x03", + "proof": [ + "0x9a96bd77b4eed84b923a54bf32c62aef9eafbcb027416c7afba347ab7814922c", + "0xb4a6bbf4380a38c62359d66f80a459eaabc2b70e29bdf61790c4877dd9e22ffd", + "0x5f131578ec5ee52b28c08fe064f728891f9d0f557e3b97ae62418e9efc1ab06a", + "0x4e1a6e4b411d6f4beeb3ab0567980aee8895068f33d0f7cf833e4bc4887a1b83", + "0x0b385e4882f89784f506afafe6dd217c6ad9d142ccf58713e27961d25b2c6d0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9BB90CB2c6A782cac8d6f83Cf364D629Cdb8b93E": { + "index": 651, + "amount": "0x01", + "proof": [ + "0xe5579414c79f60125040e157e2e4f7cd07938490599a963ff765ad55a51ddc49", + "0x007c24f2ea2a46e6a4e4dc314f9f0e8555c067ca0a1d40ef84f82eb3e8afc959", + "0x7d7f94570c5fdd54e865230be00712e816eac4c23f4dbf19c8566a21bd0c5b95", + "0x46903c3e0f26b709802c8a2743505337728e1f805b4f936ec91df4b3f43fcdb9", + "0x7a545b345b30e441bb780a4fca731a87b1e941b75518a9983a312194a9e7bd46", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9BdCfcd6b4b4403a457FB68fd6130DA07B422669": { + "index": 652, + "amount": "0x03", + "proof": [ + "0x7ea1a0b0362426d7d2029bd315c7adfeea3b6993d17fdef5769e7c90fed521a2", + "0x1d31bfc013791d00f752484e16f7ebe79897024a866fac3b46d07b99ec064925", + "0x9e4db0ef0bf78311ccba227202728b6e9f6d7520b3721365f3c58f996096b59a", + "0x138bee476bd8ce498e2985571c0fd10b392ab6afd8c1bc3ddfe5859f552044ff", + "0x891a74fec62a569bdbcb44171dedc1926c5cbe5d803c0c17ff419a861e9ee5b3", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9C0EBe66C785d280fb3446cEf16260689276bd67": { + "index": 653, + "amount": "0x01", + "proof": [ + "0x5fb2769204bf046cbe8b622b8dfcf0705f15e6dd49bc5cc7b9985aabdcfbfae9", + "0xf6b8d38023c5743e6c46821d31d7ed277cf5ed7b06e41b9395a987864bbf9840", + "0x11c7f0494b8c0020c72e25c40dc03744caf95a5fada2bb6b4c5a083bb072f5f1", + "0xd1cbda0650121cdf56f6e9fac417e3ddbcea9364da64e4e29c3e50fa61aa56bf", + "0xdfdb156cb5d2b90a5253163570fe08739b17ab3fc383c79eb041c1d1a667fe84", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9CBBDA094cc0FA9217b783aCE7F0C103a8265cC4": { + "index": 654, + "amount": "0x02", + "proof": [ + "0xf455fa492507943967683c415a04f603cf084b9bd41731ef3ad77ec42c37c58a", + "0xd439ed65575104721c50c13d7272ad1e45bc19a9e86984bce0ab9589e0c70f29", + "0xb0010d722b0a6ca31a164d69fd41792020ef08e55c137f9e16186b7da6a1b655", + "0x3293f41caca9649b5e2565aa9f9ba63bf7c621850061b0b1b6af864bbfb07389", + "0xed5c942adbfa1d9538c55e89e4a7ff4276f908ac558913b5f43dce424bab8e0a", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9Ca2C56C0F876108A5ec1C518Baad5b86E651FB3": { + "index": 655, + "amount": "0x01", + "proof": [ + "0xf70ec8accdf255fd6d7f6488b18e23648942dafac3ef72321ddf7d808875b6fd", + "0xe5e69b49e6302f27370b2714452d7178b7e8283ad7f2d32aea38c0f82aa11448", + "0xb68e26a6daede6ed892cd902fb2f19d6f490fcf8f0dc6a9c1fc42e9c75cb8ce9", + "0x11f5a22099e6617cfb9a813c15cac667d29fe00a5f0d1618572f9c1368ac6385", + "0x8e7f75ccc4d864471b1a7ec71efa29a4e8cc4761c26a6987c8043d9ca642a2a0", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0x9D0282C49f309550691DD9d230613815F8245671": { + "index": 656, + "amount": "0x01", + "proof": [ + "0xb9d77bd398ae29b6158858d06d19869ae25090a50246e255bc5c1ad20c6b37f1", + "0x45c63d6c978313bfe1f3a2c23a57432228e5991d269747656cc77bf884c24a52", + "0x99c1bfc876cf5982f012ca12995034d51b946a2ba47a506495fe65b361451d8d", + "0x6a8275b9d29aafc6358bf9f174b96a6a2561ace2c21d2edeb2a14975f0d9b0c1", + "0x83e262e483a6f2ff9f4df14637dbbdfeddf0c6b0b4ca462c4375d29a3521e052", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9D387Ab7FF693c1c26c59c3a912678b58368e9e5": { + "index": 657, + "amount": "0x01", + "proof": [ + "0xa94816f7c94e63cedb769920a596d959bc5da3b4a1008e0da73965149c280f12", + "0x92328093f0b70d6e5e655a15b6241dbb85aabd4aa501a466d044f5d6e5cc66b2", + "0xfdae30148a910307864676cc680c0e41bb79c5b095c34c725c285354af84e7d9", + "0x68141ce9c9d3196b1db61f6e6c902aa8569304d1613ec750ac0ffed8af2bb113", + "0x32636a5315ca425c602832f925f24426ea5aec9939c73d1b2a6fcdace85ecae8", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9D7a76fD386eDEB3A871c3A096Ca875aDc1a55b7": { + "index": 658, + "amount": "0x01", + "proof": [ + "0xe0c12cd02d084bb2b4910150486824594ff59ec6635390c937a56fe43117c302", + "0xfc685189a956672a2e4ceb7ad8f74ac0e8b46f34e6aa65f8fa9070fd290c8f08", + "0xb9a7fa3b7b5b9da3469420f2d9c4c74da6b2dea922f5543ccc924907c91aaa0f", + "0x60dd57debe01b07f2150f54d637bd8f574df12ac003a445ad012509f5b619671", + "0x966715df220dfbe5e11392b257b61b64c18178d1825b654f95f67d7c9558a2a2", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9DC4c712C7030981a426f41C1A35b5b4521a8C72": { + "index": 659, + "amount": "0x01", + "proof": [ + "0xe8629f21d75f91bf90e35a48a40ee5e13072bad024e93028b10c2ca923ddea50", + "0x4fa7ce6d590033ee16a7b8a7d984006d773d9a00252a5d673993b621325745e1", + "0x4c4c1774cd1fa5133abdc712ac7336a6ec726c09e58e3dacc97192f36b62378f", + "0xa26acb471e2d600bf69b92e87438242435f7a1ed8e490016e5305ddbcea64c2c", + "0x3ac4ae4a4697e2400113df3bd55f84456aff86925f45224af80fd8af20592214", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9DC55992917aB05adBAf1B34954a34F011636D10": { + "index": 660, + "amount": "0x01", + "proof": [ + "0x814ee6dd819192b5ccd66f71ac21816a5c9dc0cfd9e3296613ba67c77695d78b", + "0x37443bc3035e1948ecfdca559717df33fdbf1cd1f5a1c6e6beb51703df7fedbc", + "0x37b7ec084798f5f5573cd70b4c713808bfabeec65ce54db1c9c6e87b7642d9e8", + "0x13c4723f9c83e02f8e5d7f08a17afc4776844c18a0189a9fcccd2702d623254a", + "0x891a74fec62a569bdbcb44171dedc1926c5cbe5d803c0c17ff419a861e9ee5b3", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9E650ef13d0893A8729B3685285Fbc918b4850C6": { + "index": 661, + "amount": "0x01", + "proof": [ + "0xb5fb0b9497e5557b16a2a6fed6ea77671d2ca63f4765667b0f20faa3570fe1f6", + "0xecc4b5db90bd9651d9e8363bf7c072f9221973b9de7ce564fd1a96d2dbb986fb", + "0x180e1c5787d5d2cb7c3d1a878f6ef656de538e76593c3a78aa00ca9ac631f7ff", + "0x841ca200e81dde455c9bb72802b7b377b46a9d6779eec08b07e61939b8d43c1b", + "0x529f1b48ab616d4dd60f663753a7779d8ec25952bc8c34df4aa96347bdb0d542", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9E7903987Fef88a83dE704748B7f653Ac627163c": { + "index": 662, + "amount": "0x01", + "proof": [ + "0x8a0e4471d35078671028086fb2d67b5e427cc5e6ccac3a621bd2f461b890990c", + "0xbaaf309b1ee404924cffa0c1527e5a7a4e7d5434954a141c90c48ba9fa786ab7", + "0x62b2963c1057263f03a882a1c74c6dd227168b925fd226563d397200dc561e0e", + "0x0c15cd0e5fb4411c59b182f983d4322f33d3be8bd2c5425b705021fa316a402d", + "0xe4fc54838dec16cd3ac94713f191dc41ac7f5e070180d4843c9aaaf9c71ce29f", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9E7943cEAc1f02B00E5f9d6E182F257efaA4653e": { + "index": 663, + "amount": "0x01", + "proof": [ + "0xad6c03806da56118fbe63bf7d38e93a7bba5e47fd57d869e600acde84f3c10b4", + "0x7bcbf70b3eb8c35daff61f962343f1a346a33afac8b2bba94116c68ec1ab3c62", + "0x98dcf697690e69aa965e2413c9bdda9a1af7d0ccf6a569bb34035b0369e22372", + "0x298bc701f239e72f83c6fbd5aa5172caa103b1453ebcf9fd1dfe23628f4dad14", + "0xa952d1dc401036dd357d470bb699a7e9cfc64f0caf6dc51a638cd2487f5e73fb", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9E817382A12D2b1D15246c4d383bEB8171BCdfA9": { + "index": 664, + "amount": "0x02", + "proof": [ + "0x3766b358c667469e4ee270a320dcef59af3e4655a3abb91dd996868f11b4f46a", + "0x01b5d3d3307b3d19e28dad9cbb2a624895297ca5653d7edb4d4f1073c1967e42", + "0xba70c400dd80e4274e96080abd494fc3d055f32a6397ae40d812707e3922a8b7", + "0x26d5243ad79c6ff0365171b12c8ef795d8c977a57cace1265e53f8b7326c312f", + "0xdc998377cfbadb1c2d77196acc69c259bcfcc6de58df7f5aeea2780a288f2509", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9E98bd387d741E7e10A2c24df67a8C745118a0F8": { + "index": 665, + "amount": "0x01", + "proof": [ + "0x5495c2147149519273962b175c1a92ccb4624e7d9c232a41d3d8f5ce06144d96", + "0xa1653af0002041626972a3030cbcfb735a6100f8a33d4a3ca3dd6d4720f5e27e", + "0xe13a3f7e9464f63c11cdf4d34aff17ba3b16eabe825f6978bf103f72f771ab75", + "0x7a5397945a42b48bf4e4ee9c21f985e9d9ccf82e57fdb87dc2e6046ed345d7ec", + "0x5477c93aa7e191fd8f76e1976387fc82460220dfdcee87f9ba8926f4e0ddf45c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9a568bFeB8CB19e4bAfcB57ee69498D57D9591cA": { + "index": 666, + "amount": "0x01", + "proof": [ + "0xa6d72c65aae8984ac06b5ff759751199552168df0c1437c5f989fd2fec903438", + "0x8cd44ffa0af5926afeddc98ee0582c4af41ce66b0832085011f5c7946257c0cf", + "0x745fb65ee3248ac54928f37f35bcfa2f7104894c9f61401a249bd637620389c4", + "0xff4bbb2da92e4f9e24f8d79cfebe3e93428702c14b9f4cc9993761fab9d19c9a", + "0x59d5a4275936eb4dfca0d17bab02b4a25bd4dc43ef3aa0e3515a07f7c0f68a93", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9b0c19000a8631c1f555bb365bDE308384E4f2Ff": { + "index": 667, + "amount": "0x01", + "proof": [ + "0x0c0c4a2f6e3f5b9b3260cb1e1efe01114ab9480870655d99520ccb76e48af51d", + "0xb5e70c1781b962c3419d544e090eee4862d34e55f6f7f93a9eb68346268fa483", + "0xbfc26260b7e6983f90908bd7c4dce14d82539f1d2bdee73c0034e9382a6e10f8", + "0x979cc6c181e08190bb233f0cf5b0f7b487d9aadc675c9326a9af9732d3369d45", + "0x4a36dc66177a8394f6b14fc9adbe4ad7e0cc2dead6acb72d80990e336fef8d45", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9b34D7c98e0ff695B7b1619fc4ffCb32f4994f4A": { + "index": 668, + "amount": "0x01", + "proof": [ + "0x1ab458f37216cbe94274b675ecee4e8efdf6523fa7cbba27d241594e8667e493", + "0xeb60657c3c5cfd2a9cb0a7796e4138235793e7855cb9d7d46bc1d7a5974600fa", + "0xfe66f2955b7edabb48cb9446e3380701b161ec72c61f6ea4206263931d17ec7e", + "0x6b5b18bfb5c7b8de5b52219b51a21b6ff6e22d5cd7a147d521bbfac13cd7f7ac", + "0x93994074bdd819d668a79fc2c79be23cb074a679cd3fe03940945d4c6f9fa9b3", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9b667FA9EF908407Dc90ad0274039fA2fd0007b3": { + "index": 669, + "amount": "0x02", + "proof": [ + "0x5b6a0a43a9d5b9fa667f8c56618e1315dfe99205f8d72dec3146ab914e86add9", + "0x739e5a6c19c00f2a778c5ba3915ce56868f3278dbd62516f76632cd8fb65eee0", + "0x1e238294161409acd6c7ffaa2d08bd09d6a95e15ec21b6d1eed1c519054307f7", + "0x31f1720e10e01b0c3f193ea7a34f44234d915ebd6c8260e1b72970bca0201b09", + "0x140105e3fa17ce783a651f2281967c53a37a748c29442efd53ee24d8a1cff6f5", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9bB43b5Bf085347B919968e1853a549afCB466Fb": { + "index": 670, + "amount": "0x01", + "proof": [ + "0xf334f57b7b0fc4c0bf0a7eeef5aabdb9737c4e9877cdf74abd2674707264c52c", + "0xdf57d14354e7bf0538b8a6efaa4596f28ff543374995dfe588b7f2fab403d15c", + "0x4fde23ae7d8b91b73ed7665e54d03801fd1fde8acd49d16d146cc40a2ff9295a", + "0x7caec6cdfba66dc7947ce7a10af67bf36737d573f70c5bcf73b71057ac86d1f9", + "0xed5c942adbfa1d9538c55e89e4a7ff4276f908ac558913b5f43dce424bab8e0a", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9c3bAcade6BBE81a6238110a28628512ABf4eC4a": { + "index": 671, + "amount": "0x01", + "proof": [ + "0x1153bf72186ed0b408e1e1dc2604566729e33665e5e044b95da3dda137caf76c", + "0x5f6a54776a06cb09b04918db76279c2bcc12f95e05e8549e6539aa9d8c0b9527", + "0x2d080e14bc6209922a0f1386a059fdcb9274a63e7b85c402a8d63fb6bfa35125", + "0x2eb27b26c39f3350831b9042b1a0e6295ae6da1b11f07f10b4a83da8dc66b536", + "0x4bab2069d20a5d1d2f5ebdb61803a57609b7709eca9e925e31a7d14434af1326", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9d137567c35d6704B9155A88c8480237c7B24705": { + "index": 672, + "amount": "0x01", + "proof": [ + "0xb071b0b637d303ce226f61fb9f6125f297d472aaac9cd040fc23ad7405df2aa0", + "0x8c5b5b4c78db6411d6b7c41f983be165845857a3fb75c15a255d438b99a598f2", + "0x3b785839cd26b611d66f8b353ee5f32ff1026532ac266e55f2864fb32246d378", + "0x577f81e56558cea5cd9d5160218e718fdbd9b124f0dd5499c3e14a238415b645", + "0x72373ecc225af245878bc638c49c8901db1430b7210a3008231acc8f8118d2e0", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9d24ffbCC1374a45abAb44B4b6EA23a28Af2Cd6b": { + "index": 673, + "amount": "0x01", + "proof": [ + "0xc03ec77cdd2c7d52f0b3ff8d8c11a3e6f9531cbac433429918cdcfacfd95e3e6", + "0xa8051827245bd1e0f7083bea29ec26d994ba088cc2f443d4ba44a2ee63434ef2", + "0x069a6e27761402124e6864e9c64d9cfd9c72eb95dfc4360c4741e8871195b5fd", + "0x56b8291821908612de8ad02adfee632a6221773b416cedb3db9fd4f3ba5d30ff", + "0xbd7abdce9ec414fe47ea73146a2131622bdacb914ea6353abee1b0a149275092", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9dC9D9D428Cd616a292A913ceb31557b6F2882C7": { + "index": 674, + "amount": "0x01", + "proof": [ + "0xa796d50efce97795bd625ffadbf457c5516cd05e1ac6185fafb1aa59b648b444", + "0x27d809de885d2242d71d52112d90854ab7b77573cab5a8aa24fa43743b76a6e3", + "0xb094c21688682ebc73d83f5ad45321b8d5314b45d9b6d95ff0e4b356a6e6a67b", + "0x21367d58d52b32234887e9e91e468488a647d2d7407cacfa709cd59618255499", + "0x59d5a4275936eb4dfca0d17bab02b4a25bd4dc43ef3aa0e3515a07f7c0f68a93", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9e6f4c45f869C77e7bc9e28676f22577B64Ac082": { + "index": 675, + "amount": "0x01", + "proof": [ + "0xd4959bef658b2a7a102a03f5f64eb71dbc44fa80ee4e1d9333d34f4ae35df38d", + "0x10aea724940dacf1e47257b194de3b628ec4b4087263aae40eda9ca264e6e9a3", + "0xcf4b0a8be134a824cf199271e2b48b713aa95add1e71d8db714ef711f58a2265", + "0x295b1cb76b1ce79cd1280bb1130a4264534288edb4c264d45d4ab36dd72b36ca", + "0x7e73f337249898d15604f7c330d90e36da04007407404a4b4276d5fe3083b929", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9eeEAa6b00E69be68F32a5a78F2CC8A872A0df57": { + "index": 676, + "amount": "0x02", + "proof": [ + "0xf591e083beb3db23fe7adfe4f6dfa252b6ccb3350ecd05b0d877ee29897011e8", + "0x33803b1d0cfd390a713164332790dbb55114507a79bbe1034649973fe4b6226b", + "0xfd0268e900a7c1ec041037fe894fcabcd46c99724b846e568ccd38d01ea0b2e0", + "0x3293f41caca9649b5e2565aa9f9ba63bf7c621850061b0b1b6af864bbfb07389", + "0xed5c942adbfa1d9538c55e89e4a7ff4276f908ac558913b5f43dce424bab8e0a", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0x9fFd98b566D449f497a1a5b0bb0Cfa1F36c44A2C": { + "index": 677, + "amount": "0x01", + "proof": [ + "0x3986416fdacb09fb5181e9bac8d5f879b91522a4cb58e95883bc030a3b2d1107", + "0x41ef06e62149228bca6d26c03af009a65cee42a6cdccb4feca2afdc64dc0a7d4", + "0x159b41098e36945d7d696487556ac5b02e939b80770f9f0ecd41abe3f8314c10", + "0x60583de8b96cf21d7bf97a30f8f28bb928ffecf01373b007ee5bfa1bb5a1f776", + "0xdc998377cfbadb1c2d77196acc69c259bcfcc6de58df7f5aeea2780a288f2509", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xA01501072139f202a81296fC6fbAdbC1Da21Bb6A": { + "index": 678, + "amount": "0x01", + "proof": [ + "0xcd8b57a8d638aee370c7941ad9e714dfe0ffe710997bd08b76e543ea2c61a37a", + "0x365d7d83f25aea48a71a7a436d343267244129ba2c8b087bdc3adb272846604c", + "0xe8a6478d83d6e44010f2e45c5e73a005e8a6798d300da5af9760a1a7319a59f2", + "0xef33e9da5226ecbab5796a616b47d5f4223c729722fba46a5cf043b7bdc381ce", + "0x2e78635a0ed4a14dadd872d564c5dd2afc4f21b0307932d27d4471c48082b7f3", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xA14964479Ebf9cD336011ad80652b08CD83dFE3A": { + "index": 679, + "amount": "0x0d", + "proof": [ + "0x4552de88196fe2c41663d3c81275a163cda7dc7d5d0ff1a5497137b6a2ee19bc", + "0x51b97128075f4e203044f1623661e702cfad19c7cdc48df545dbac7eee500521", + "0xca882a67ab86b0ef4e7ddca27b5df90183d6545fa0466cfeba52e7d10412db29", + "0x7327dd8ef29607aaaef9bd84ab3718158a620b3e164df6976909aaef215117f7", + "0x38d4a740f3f99a827703ce6725923277f058619e98435b28078dc5b994e00a6a", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xA2490947b30258b522B7D6fD8Fabec2d21c42D57": { + "index": 680, + "amount": "0x01", + "proof": [ + "0x8354146c74b6c12c659552efddf2f66554d4bf65a28ec6c12c86ae34d0c4dd61", + "0xdfc024e199a4fdbe2f7c0991bb79aa5ad167912a6fd038507cac42419b402b95", + "0xc1327fd5c0d304512764186ee58b613917e50f9a632100c058142561a8ca2611", + "0x02cef8ccb3c7906e41a7ed9d223c95f320f2860a3d5a5dc4598d02362970eeec", + "0x9dda7d74fd49fdacbeb3afcd37c878516159fe4b594e491ff7ecbc80fd8d6808", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xA2e358ABB6DAd485704F01cB479bea5ABbAe902F": { + "index": 681, + "amount": "0x03", + "proof": [ + "0x8a223ee6d900dd7f9351640b759e15cb39a9850b04b05fe5f3082c6bf45608fb", + "0xbaaf309b1ee404924cffa0c1527e5a7a4e7d5434954a141c90c48ba9fa786ab7", + "0x62b2963c1057263f03a882a1c74c6dd227168b925fd226563d397200dc561e0e", + "0x0c15cd0e5fb4411c59b182f983d4322f33d3be8bd2c5425b705021fa316a402d", + "0xe4fc54838dec16cd3ac94713f191dc41ac7f5e070180d4843c9aaaf9c71ce29f", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xA48fC0B3bc7954C6A05B81BF5BDe133fd0ea2c50": { + "index": 682, + "amount": "0x01", + "proof": [ + "0x5d7a7bece445ab26df33341c8055b1c5a8065184e151b4df94751d72f0008d6a", + "0xe659009fa1069f5a03ea9dc2499f39c63bae54235f152c79ab4e4a8415ca5136", + "0xc8194a78aa356d611f6bbcbe346bc7a996ca8addbd55a10d6fe06d7320b2f492", + "0x4bbd36041ce4968e3db3409953e198317c2cb3811d91f8fc5a98ba5c581d59e5", + "0x140105e3fa17ce783a651f2281967c53a37a748c29442efd53ee24d8a1cff6f5", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xA4Ab16a28A8567bB7e51D536f151F8bAc1D3b464": { + "index": 683, + "amount": "0x01", + "proof": [ + "0x5b45b1cbe7a5d0ffd9ea78ecfbca760c15f711d4873eac8f142a3cba7fe1ff0b", + "0x42822291c2457679ed40f4388aa0902e408bb7b05b881a5de484d47b0392e793", + "0x44e62419e6617508f01090bc15bf772f46d113e070bd339089cafb8752c6c104", + "0x31f1720e10e01b0c3f193ea7a34f44234d915ebd6c8260e1b72970bca0201b09", + "0x140105e3fa17ce783a651f2281967c53a37a748c29442efd53ee24d8a1cff6f5", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xA538311df7DC52bBE861F6e3EfDD749730503Cae": { + "index": 684, + "amount": "0x01", + "proof": [ + "0x3e53cb4c575f6e21f18054c43935ac2ab166db4640d11b34ecc3fe55c20e3e9b", + "0xf83ac42d644b354a382c93c5a48526f5dc76910751805d9758aa292c1c655a65", + "0xbf879dd33cf8e5652f6897331b6d0be05a0d269a02431e4143f50adfeec86fb8", + "0x2b5ad2a01fbc178584e521e2b2e5c612407bac24dd9bf0c452060b71384720b6", + "0x98ba92b6a1d3418a3c44b684c9f0dc2177f48d3a6b666334d112dacbb6f5acae", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xA54fe8199a186Dc5C275b3C99071ecF19E01C07B": { + "index": 685, + "amount": "0x02", + "proof": [ + "0x7e6bb3b0e29fce44f59122fbdd43b9f3c2d97560f6fff1743d386af0baf21919", + "0xb89c4e722cdd0d6075de7d9d8ee765d16850c9ef47a2a732ad04135292da2431", + "0x56bf94bfd25613c3b1c53d93baba2a4d76e076069333668d5ba3da9f1f69ce30", + "0xc7b7942da27652b608d4a505a59fef704f26c49f0c2a23709d80122b3afab5bb", + "0xe2050f6c95c616c1cfdb04f4b6d0afb5afa0fb464f767c38aba0f07df915a97f", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xA56402Fb07eCE948941a04cA2aC8C3B28D28877E": { + "index": 686, + "amount": "0x01", + "proof": [ + "0x24f8578ef359588aa858314c2ee9807caa0d218ea7b1b562196b008e0fae5a7a", + "0x0a9d10612c3c348cf1734be9b2606c59d3e38cdbd09e971fc558d5137576590f", + "0x9a7506db8eb154b6d45fd70ef0e57ee187ef27ec6e42a2253be7f3ac118f3fcc", + "0x4b1c846f0a8bc448aead7f2cfec46ac450b23d2f229b5350dd63009a82a1dccf", + "0xe29ba79106b7b14c14912bb5fba509f27997ddbe5a7ebc941fa75e3475af4aef", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xA5d40a9a0041F07e98Cc1C2AD8Bc4E6a82C7d792": { + "index": 687, + "amount": "0x01", + "proof": [ + "0xbb085c0a43645fd44867af27b4331fcfd1a98382df7ac2ec6da64c56707f98ed", + "0xd6cd14298018d0b1eb6afc73b1ec8e58665030456cca48d4ebb8f1b29a924e32", + "0x3017eb0d540f971e8043a85f710c1ca576ba8ace44cc77d31d57c352236b7562", + "0x6a8275b9d29aafc6358bf9f174b96a6a2561ace2c21d2edeb2a14975f0d9b0c1", + "0x83e262e483a6f2ff9f4df14637dbbdfeddf0c6b0b4ca462c4375d29a3521e052", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xA6144dC064f1d5FD6f364b351F21C50AfF272541": { + "index": 688, + "amount": "0x01", + "proof": [ + "0x72150c4546c63613196f414628bae4a8396aecad88a5ae2d992c36de0ca60c96", + "0x2e7bf4685f79b978110c36c7a80432e17b1e91954dc1283b06c120c54a02da5b", + "0x8be860722f0612e38d1e8acd51cfab2cbcb140685965dff7de6f05ef66a544e5", + "0xfe79a6356c4cd9282dab3a598f859bdcecd04fcb915a9edd66380a81697af3bf", + "0x7abccb934a7f719fa80b9a5d3157e99d45ee17a391abf85d4f60839dbf3769cd", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xA639583dbeE6f945c57492c63D8aEac64bD168d2": { + "index": 689, + "amount": "0x01", + "proof": [ + "0x6ab19b2a92887526566fc7bdeda11a609d9dac3461694f02c5745861ab10b553", + "0xfe9ac72de3812ca5d81e38cb720c0a6ae32a5026a19a351f4a81a581f9c3a3c2", + "0x1390b60f90b43662c35607eef4b6d21963963777720b34f19533e009d75b03e4", + "0x283f6032b7beb32fcc6ac4b21c9941360bce453787f78b6251c38e3890b83a8f", + "0x1be60ce906d0d73954b2e1f2747ea1c9a23db0ad9345fa6801c551f1a39fa5ab", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xA6bE6d0BBE99e661D5743f4e58ba40F7Af3E273B": { + "index": 690, + "amount": "0x02", + "proof": [ + "0x7eb0b1193b3d0694ef4f632471b62edfc067c82669b0a6b16003a02804c7bd86", + "0x1d31bfc013791d00f752484e16f7ebe79897024a866fac3b46d07b99ec064925", + "0x9e4db0ef0bf78311ccba227202728b6e9f6d7520b3721365f3c58f996096b59a", + "0x138bee476bd8ce498e2985571c0fd10b392ab6afd8c1bc3ddfe5859f552044ff", + "0x891a74fec62a569bdbcb44171dedc1926c5cbe5d803c0c17ff419a861e9ee5b3", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xA6cCbfb8dFDE6Ad5Fb2EBDD078EfE48945BD3391": { + "index": 691, + "amount": "0x01", + "proof": [ + "0xeb223625d7c8d097c006e4a53d146dd5e1b1d6dd1a5914ddb7cc6e259649312a", + "0xd73cb472b9aa5a987bb6ca8a1d8fd4f1fcaa05c2442838f8939121ce18677397", + "0xfbe53237fa258f22a663d189073b771fce11454af4eb8ec55016ffa20f6427b3", + "0xa6bb3b2aef22e52a1e0052bc5777bac639d24ffe832889b483d829660c1bbc1c", + "0x3ac4ae4a4697e2400113df3bd55f84456aff86925f45224af80fd8af20592214", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xA7D7Ac8Fe7e8693B5599C69cC7d4F6226677845B": { + "index": 692, + "amount": "0x01", + "proof": [ + "0x7994d831ed28d0e3ce35d40b7bf2961e2f68c1dae09742b92605e61878ead5d1", + "0x2fe684787ccf096a7b31fa11ca1398833b41c4ca2aa704e9d631ab3fd35a24bd", + "0xc2cd45a5ba91a5bddaf5f5a2e4e6330f109e68b673e248effe74f853055b5f9d", + "0x81cb79cde32d282b43e0e438fe2b6758f17fd2d569d10c780c800d4c492134d6", + "0xe2050f6c95c616c1cfdb04f4b6d0afb5afa0fb464f767c38aba0f07df915a97f", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xA7E5a837382C4B2A484BD2AFAdc8B5A5f6d74e87": { + "index": 693, + "amount": "0x01", + "proof": [ + "0x36284fca6801dad5db91c65e020121778dacee225d413c52e03c4b149831f09f", + "0x50188a232294bc0e5397947305d1c580ccd8c734563f462ddf7fb69e1e6baa4a", + "0xb4e3d624b4c9069a7dbee8548a7744c0c011fbd5381a1988549f867ddd3672a7", + "0xedd365a7e73c5a47a076899344b760df86cdab5eb6566dcce5b550be9bbb5324", + "0x963cc7ad3f8f0ded379d05906b629df8cc616633784013c90731955d0b0736d8", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xA8fD0A40d2e72737C7C58C96D486D652c7c831E8": { + "index": 694, + "amount": "0x01", + "proof": [ + "0x9b6f4d1a8919aa15ac6d886875a52c31cce944398733fc76fb5a4a18554443da", + "0x8c5e98c974561c22a3fb219e028f124672bd06d4831d97d21c4839d9aaf36be9", + "0x5f131578ec5ee52b28c08fe064f728891f9d0f557e3b97ae62418e9efc1ab06a", + "0x4e1a6e4b411d6f4beeb3ab0567980aee8895068f33d0f7cf833e4bc4887a1b83", + "0x0b385e4882f89784f506afafe6dd217c6ad9d142ccf58713e27961d25b2c6d0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xA91DEF19116fb21eFC3c6cfCfAc6e76eb2d80B46": { + "index": 695, + "amount": "0x01", + "proof": [ + "0x8438305beb6e809c4d9c1f61ee4a74912bcdbe89ccdce9d63665163079e4f0a3", + "0xa57293a23108699589e42520ced4add426c35225c4e3863ea2675a5d6895bfdc", + "0xbc2dc753cf42a1935c4d0a0882fed8a90a12f1c0a70573deb71cc2d70b40317b", + "0x02cef8ccb3c7906e41a7ed9d223c95f320f2860a3d5a5dc4598d02362970eeec", + "0x9dda7d74fd49fdacbeb3afcd37c878516159fe4b594e491ff7ecbc80fd8d6808", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xA9D89A5CAf6480496ACC8F4096fE254F24329ef0": { + "index": 696, + "amount": "0x01", + "proof": [ + "0x1bdd0c016e55a095d129d384a88c8a86d146fb1571e598add3e7db9e5765deaa", + "0x4e17a548a0c71a27602d843ea4f61b17b34c35d59d0cc6982050f1c1789ae0c5", + "0x7eec595c69d6c1d1d1d8dacd93ff7c8b18c1968069bdea1797a90eeecc155ade", + "0xc2b85fb7fbdedfff6c0826f89cbeff5a93f827eeaec8b16d80424b138de956db", + "0x8e0cc5c13324dce3ab0f042d31a9db04afe0918f70e3f4515f43739791621c97", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xABaf75A934E8b4DA85db7C79A9e8c5a0022a1660": { + "index": 697, + "amount": "0x01", + "proof": [ + "0x64f90d2a7687c95f88ba683d8249d79fa21b3ee4e74f26787f523034a71ad1f9", + "0x79cd4d0ac20e8003057deb4e3e5f3e9ff0fbe9cda84a4230079382bee6def353", + "0xcea7df5853c7450e538101f09c77eec6b3f2998d90e30a8070f1e3c1de4cd6b0", + "0xd2ab54f5e70cde7ed6caa9591ebf0def0ee5d532bfbf38a4473c6ff488c1d82b", + "0xfe7d73c06bd76d1271e4b772b51e13505a812b7c919129debfd7d15fb5014d16", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xAFcde02C4136C792ff12F23178A09537bCB2106C": { + "index": 698, + "amount": "0x01", + "proof": [ + "0x52515c35861ac7ebdd83047f69b1a10bc1df92b1bb05e264653673f1902810b2", + "0x41dc249b7a9af195f15443e58ae10327423602f5f4e89bb119eeef7f9c13b66d", + "0x6e4e3be8c84bdf4ca5531cb1f98b5a0f91f960b234deca1bc85cd01c39319968", + "0xc7b00ce40d9d1f9a2921254e2bca646cf3992fb2c667a15215723d1f5a1b5352", + "0x5477c93aa7e191fd8f76e1976387fc82460220dfdcee87f9ba8926f4e0ddf45c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5": { + "index": 699, + "amount": "0x0a", + "proof": [ + "0xfc79f88ed471aadd28056437cf43b9987f09076cd72011f92751a6a64e7899ad", + "0xf1e7edb9c90e910978cd903f50046aa421aa45ef67439f8d70c7caabcee849f6", + "0x31f79c83b956e018904202cf4279226136341311c37e609a94eae5d4c39d8942", + "0xf7b15c813ccb2cfda0fad7314544180ed758b3ac0213d482dfeb48697c2a487a", + "0x938890418edfff03e5d8f0abce65769ab79b16db349d2869a477500717305360", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0xAa66fC4433DFD254F05A720A8c8a2f1F2fbDCB58": { + "index": 700, + "amount": "0x01", + "proof": [ + "0xeb5a3506478327921c56902bbcd08df4971a0cc78b49ae1c34e7fb5ba8930670", + "0xd73cb472b9aa5a987bb6ca8a1d8fd4f1fcaa05c2442838f8939121ce18677397", + "0xfbe53237fa258f22a663d189073b771fce11454af4eb8ec55016ffa20f6427b3", + "0xa6bb3b2aef22e52a1e0052bc5777bac639d24ffe832889b483d829660c1bbc1c", + "0x3ac4ae4a4697e2400113df3bd55f84456aff86925f45224af80fd8af20592214", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xAbce94777EbD2C18A16454193a1C7483eB77dE0a": { + "index": 701, + "amount": "0x01", + "proof": [ + "0xf3257b9d7062e6b92c1e30f85cff7e1f67f8e43206874325c3fc26e7c5fdc8b4", + "0xdf57d14354e7bf0538b8a6efaa4596f28ff543374995dfe588b7f2fab403d15c", + "0x4fde23ae7d8b91b73ed7665e54d03801fd1fde8acd49d16d146cc40a2ff9295a", + "0x7caec6cdfba66dc7947ce7a10af67bf36737d573f70c5bcf73b71057ac86d1f9", + "0xed5c942adbfa1d9538c55e89e4a7ff4276f908ac558913b5f43dce424bab8e0a", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xAc27E3AF6Ce5F867cD66080E9a7D2E43D2104Df9": { + "index": 702, + "amount": "0x01", + "proof": [ + "0x9a41cdf0bc4ad3ec262d97f51ddfa4af0ec4f50a3ee9cd6161c9cd53fd50f04d", + "0x82fb3c54e4280ff876c5e9087a1eaf27371b5a05cb7a1501f569488f3dc678d5", + "0x265c302052174e496eaf88164e054aa106d99c29ee696e11b9c7df66fbb1a01c", + "0x0209cc90d619e0e5f56081126d2ed4018391f3d9e1dd1238794235d656c68c9b", + "0x62ba7b58fd554e8be295bf9d4baf9eefd0b518ead5cb8bab321717a08160ae0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xAdF48F0bd5bE920fFB49e670e6FE8Ba4bDE08024": { + "index": 703, + "amount": "0x01", + "proof": [ + "0xe033b0229c9f8cce8e38521b49ac956b6cc0e20a0384b34bcfbf154743bb5c0d", + "0xfc685189a956672a2e4ceb7ad8f74ac0e8b46f34e6aa65f8fa9070fd290c8f08", + "0xb9a7fa3b7b5b9da3469420f2d9c4c74da6b2dea922f5543ccc924907c91aaa0f", + "0x60dd57debe01b07f2150f54d637bd8f574df12ac003a445ad012509f5b619671", + "0x966715df220dfbe5e11392b257b61b64c18178d1825b654f95f67d7c9558a2a2", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xAe72Eef2a981Dffd9D5964Dd0EB669e10ae10957": { + "index": 704, + "amount": "0x03", + "proof": [ + "0xb4b66b9f649fc488053fc92e020b7680e864e006c6e925957aef430562693d1d", + "0xbbc0c9648e4d5c5f44bb2553cf70092c725cfd49de8cbaabb0740cfbd4aa9455", + "0xb2ed6280151caa17489d6fb4598efd9034b403611c60ec584929ae6e4dd1f3af", + "0x575d2e3f9c311244d801f96a2b4f9fc9666f8793f898d400d71e121add7f872f", + "0x529f1b48ab616d4dd60f663753a7779d8ec25952bc8c34df4aa96347bdb0d542", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xAf15B1b427089d5ED7C6D6304223B82CFfE11076": { + "index": 705, + "amount": "0x01", + "proof": [ + "0xaef538759515403d7a5dac0f9a1856b8f4a5a26786411d43d48af59cf579c30a", + "0x44247f6686d7515270e1655e7b675aae734b229fed9f2d979c0479460af21aef", + "0xcf221106eb3204d78b5ef9028e613c93c6b7a5954f19a30ac14d1d5567f3051c", + "0x298bc701f239e72f83c6fbd5aa5172caa103b1453ebcf9fd1dfe23628f4dad14", + "0xa952d1dc401036dd357d470bb699a7e9cfc64f0caf6dc51a638cd2487f5e73fb", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xAf69aAd6588982708d81F7d58c5e432e5B95c968": { + "index": 706, + "amount": "0x02", + "proof": [ + "0x6cd68eacd3ac17a8b7ecb6134768adc916c5f4a806ac84767f7582c2fe4099a3", + "0x9c2249c85f663730f542d3491a3925c33491fffeec05d50b68c911adf4c2b824", + "0x6739f7ef27695db5e41ccb568aa848d003419a94df0c5b9293106f211d362171", + "0x7c0de9d8e837704a5bbfc4993fa9b20e3f698f1b885a0b593d018e35bb790c61", + "0x1be60ce906d0d73954b2e1f2747ea1c9a23db0ad9345fa6801c551f1a39fa5ab", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xB0354be8EDD26d154dCf10BE3c47C88Ee6150DDB": { + "index": 707, + "amount": "0x01", + "proof": [ + "0xfe1de8302637d7b42cbb25aff24d0ab5ec7f3f91b508776b17304e90bddd8f4b", + "0xe91922f6213a6bcd8eddfb6fbfd654d2ee1800b8f245d033f39493581f6deae9", + "0x228366240da7e1e50c9fbbf0d83ef3aee5be6b101fa2d9de2745bc568f3857bb", + "0xd234d050330272d515ab9d9de470961bb799874daa015afb8d313d5141c5e8eb", + "0xa0af5121b49fc7ea34ad1f4c8308fd6e51803abadb614d1f15f8c87bf9fe29bd", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0xB0de16e4a22bb624414d5baa0d3626C10e936d50": { + "index": 708, + "amount": "0x01", + "proof": [ + "0x2f46885bf2d71d3601cafc69f1c83fee1105d02633c68c981488123e9af02215", + "0xb31f76aff2897bb69feb030b0b6e3cf44d62764931c19b15b834700897aaaa0e", + "0xf9b0841b7b62c71198361192f1c7feafd2ded284dca91596cffae95a4d3686ae", + "0x7fb8279a3bf6834ff5de6f30e4ebf74889d64cf70547e9c78a27d7fd86516478", + "0x4325701890e79e85b41231157c1ced07357ce871ed6fb4f233c2f82c38bcf4bb", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xB12bc4A0c497F1C3BaEe7031c5bfD119ECc0c906": { + "index": 709, + "amount": "0x01", + "proof": [ + "0x044c3b4c8ad2ede862ef876ed64c365f44b8bbc55d076ad968ce71768cffc106", + "0x8e2ce87c274c5cb6a31747ff7f03631923b0082b8b207e466aecb396de468a88", + "0x45a6e4aae97f2117fcad08e0d206885cb995ba10687c9b38df31960a7a1be1c7", + "0xf48849b03cf9b334d4dc7a6911b922272cb1a72dc4223db35fa6c699461d5f16", + "0xb18758ddf98cdeec3d020c2379717281f5c0fa0133be7d006f7f753c756da43e", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xB1453d5fB70106EbD5CbE8D4C96a6f9Cc95d0e3E": { + "index": 710, + "amount": "0x01", + "proof": [ + "0x23b50ec8ba34735047e84730f7f3b4403a79d1d84cf5a388a8d2fca1dd676c8d", + "0xf95b157a24d2bf26d67af175c56062d0b2a7cfe93a61a4a5dd0070331b260f68", + "0x3f50362d7d3bf3f3f84413a1792917e070daec36794eb4cb6cd5dd3720a2ae19", + "0x7076b49e1dda289a132a67f2f0be7b87522da84294f2302ec4d61300a0630b79", + "0x6665ebe68e892e4e5135c09f9cdc379628aaa60a8ff322ed2ba75fab3b3a9cc0", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xB1f72d694711FcE55C62eA97BD3739Ff11ceF986": { + "index": 711, + "amount": "0x01", + "proof": [ + "0xb4785db4a5fe89de8c3cffffd08e3d0f04fa3a189b6e825f1f41de5ad2106869", + "0xa45c32314f5b903929e6a93f66558308b4064d319394966eb073163372da9364", + "0x0826ae5bb3f37697633d99d3705ae48cde39e7b0d247ca8a78e1143ad8ef0c99", + "0x575d2e3f9c311244d801f96a2b4f9fc9666f8793f898d400d71e121add7f872f", + "0x529f1b48ab616d4dd60f663753a7779d8ec25952bc8c34df4aa96347bdb0d542", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xB2218bC679868bBaaC432Ec58fb4050870894E18": { + "index": 712, + "amount": "0x01", + "proof": [ + "0xd0f3b844ca03b01281d92d605bd3de08775a366f4ac51b75005186336cdc3b57", + "0xa2054a0f03c8e791e9bc91f47f943efd3fe29db48cf40805d468463baf7bb9b7", + "0x45b3ee84bfaab4fdcb6b276d32ba091b4d13fb4a3385b5d29d91fb477bcd0392", + "0xd549250cf81d453ab878cb87d004bd56f5975ca86398b00d651f71d522925a30", + "0x85ada07677b521b0dd2e0d60f51f92f7b1217f46e36379a5afa5a74fd5c87a5a", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xB2DF747C5D1bDadD6F7e581ade3Ad193d6A296f2": { + "index": 713, + "amount": "0x01", + "proof": [ + "0xb80d3c590cb537f3a0e9c8c5faa1aeab7ab42e1a2886bfa153e074ad8b2778c2", + "0x05ffe3b5b849c24a871c0d096a106c18d398de904a1de820121b7770db6dab67", + "0x96a51c82a51e9090e50794110f5ae30726a62fec6e8961aeea449b4515be8759", + "0x4f5594402e5d778ad5cd48b93173f203af8e62306714d707dc5f989e11faa170", + "0x83e262e483a6f2ff9f4df14637dbbdfeddf0c6b0b4ca462c4375d29a3521e052", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xB31E829F5345F8a767Fb9Dfd55e594f92f780591": { + "index": 714, + "amount": "0x01", + "proof": [ + "0xd583afe8bf2bf6cff184e2b8b7a3f62e3e9a872e6774e5cc2fe6046be3b43975", + "0x64c7578f5e31fc35001f0ab4fd9b287e89f838cd0845a4494ac79980bf49de22", + "0x19086762fd1965edfc2c6f8d382a94ec7bd76977d80206b5dfe7ff81c35524af", + "0x295b1cb76b1ce79cd1280bb1130a4264534288edb4c264d45d4ab36dd72b36ca", + "0x7e73f337249898d15604f7c330d90e36da04007407404a4b4276d5fe3083b929", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xB31a371ED6b52E1871ae6EB6ffb99b8B4FA04CED": { + "index": 715, + "amount": "0x01", + "proof": [ + "0xae300233ed81fdacab94ec8cd992c931a89b4b757748a37ebb06add07157e0e4", + "0x93b3607fa7be6339374e07e6fc6d62267063a0070e298250f7e97dd354ff9796", + "0xcf221106eb3204d78b5ef9028e613c93c6b7a5954f19a30ac14d1d5567f3051c", + "0x298bc701f239e72f83c6fbd5aa5172caa103b1453ebcf9fd1dfe23628f4dad14", + "0xa952d1dc401036dd357d470bb699a7e9cfc64f0caf6dc51a638cd2487f5e73fb", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xB3915599BD061D01A67C79d5E5372C2d288eDbEe": { + "index": 716, + "amount": "0x01", + "proof": [ + "0xb0d1fb23779b161e5a89cc730b40b7364bae381a03b3ed2ec70a3be229621830", + "0x99da9b921bff306e0398c7f0b702f8e0e0a76dfb918c04286b1a60c5b6473d88", + "0x861b6a9fa4a9a59b3537e811eda798dcbe95d882461afb4d7e9391162a287d45", + "0x49f4781ffbed71f831627c02425eed106f4714988055f5e0978de46ca35b3ae0", + "0x72373ecc225af245878bc638c49c8901db1430b7210a3008231acc8f8118d2e0", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xB3EbcAaF3FA6Df8397942EF560D4cE8044C8b04A": { + "index": 717, + "amount": "0x01", + "proof": [ + "0xefcc8986c4d4163eb6194f29a47793ebd6564b4c29a42aec3897f80bb04ca46d", + "0xf032ed1c19fedbbcb01ce00083aadbc9058bb1872bed143077449d597d0a17eb", + "0xd8a35ae28db7c81be0f42512143e3c242b1425823caa2703947a88061459e211", + "0x27cae8e1fac7b32e83e85494312638757cf1e0afea8f4e6fe77387c412b4efd6", + "0x58340ed8edb441d787ada6b1aaf2b1e42912724e1f0f7887cde9253262aa0534", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xB413A48088Cfb0074F75349C790062920434e321": { + "index": 718, + "amount": "0x01", + "proof": [ + "0xc3679ce51dc1fbc31cf12bfba2920dfbe331131eb52d770df7df17b349e91b9b", + "0xbe1532c87a477a9dd8d5ec50bdeabebfcdd9e1db4c63bc1875ae71798041f854", + "0xad348b0f72a246f9ea29f8876073a3c8a866ef71430904c9f0114b6bd4631fb6", + "0x65c5caf7f221e805a211309d005cab013498255a9343870184292835ae911371", + "0xcf22c1d43a94c7c6471efe1209a3b103ec0a9836b6c11fe8d2e98d18b2e9cb36", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xB45b74Eb35790d20e5f4225b0AC49D5bb074696E": { + "index": 719, + "amount": "0x01", + "proof": [ + "0x9c827d8ed1deedae852917dd50c924fd7b45a609f0029def6589b0f74944e09c", + "0xcd6b4952b042a60e11ea0287f2bd56d6fd7b8dae09d1e97b57efb84e331cf179", + "0x0a6684890164794e3e646f48f9ca38abf68b10540785b90fb3834ade1e101d27", + "0x4e1a6e4b411d6f4beeb3ab0567980aee8895068f33d0f7cf833e4bc4887a1b83", + "0x0b385e4882f89784f506afafe6dd217c6ad9d142ccf58713e27961d25b2c6d0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xB50c067C67fEF1124Ea20F74542FbF11dAD31b80": { + "index": 720, + "amount": "0x01", + "proof": [ + "0xdbb53abbfca18fe8d6d211c78c98bac34ab7cafe388a3de7c113f6205fb9ff73", + "0xff32f5fdc64ac1abf84d5263d5ab1db426fecaa6425b6fa602f7067da6d648e1", + "0x80779d16ab6f1d2f1a5df7a70354491bac8b36d2f137ab7274b9fa248eb57487", + "0x3cc86f19d7ab5abe54cb84f21d19174b3158c792e08130d0d4f813b822ec451c", + "0xd8ba0ec6899e7ab5afd6774d7465b2ebc52e677b805f74deb131b1b243bae70a", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xB6605F98A5562b1AC821Bc5f2B75934239e8c6D6": { + "index": 721, + "amount": "0x02", + "proof": [ + "0x318da710c20b4958064b2b4c9373a6814f89c63ca436e78e6c8170572f917e08", + "0x49cd9c4bd029d94a4fb131eb1986ac9e5247b3cec88948ffa59e93a48522cee7", + "0x7f001521588dd2e8e4ddfabfc157315a28fb70b9eaa1e5f5cd46420a6a34950f", + "0xb74deb44e6419575dd75ff4fb4c2cc26c6f8bccff72ef47a08f3f27e13f3de40", + "0xd6d09ea62a0a0959d8a1f1cbd849b805597a75fe443bbbc4d5e2555bf8225437", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xB96Dc6749Fb274dEf23a56016E426c03a32C1214": { + "index": 722, + "amount": "0x01", + "proof": [ + "0x046c6681c4e4cc0f630573835f245406b94c52cff439efa014e85282e6bfdf2a", + "0x7694c918471143645f70cf0a89f4b8d3164a1a587cc0b5b2a55b3cc8312a741e", + "0x45a6e4aae97f2117fcad08e0d206885cb995ba10687c9b38df31960a7a1be1c7", + "0xf48849b03cf9b334d4dc7a6911b922272cb1a72dc4223db35fa6c699461d5f16", + "0xb18758ddf98cdeec3d020c2379717281f5c0fa0133be7d006f7f753c756da43e", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xB9Eb8c1a688Cb64D0f8315b8ED885E4064352334": { + "index": 723, + "amount": "0x01", + "proof": [ + "0x91c44b61864041f7f76937e0410700ff4aaa249ed3a13ebaf73c13e846db020d", + "0xb2de5832d2f0af0d6a33ff4f599abcd84f2133f0113f088ee81749d253b1eddb", + "0xad5c895abbeb22965da16b0fe557d3867fbef2fd9736aeb313fd9e3058d4bdba", + "0x0a650a18b5dc7e14051f590d1612c3614c677cc931a3bd72443efdbdec9b6fb6", + "0xa4e0ebcaa65c6595e7c7f0ffb89992e2b9cb58ac405c81aff220fc4b16ea3b6b", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xBBBBBF6f45cdd6d748Dee91d4768b12576525ac6": { + "index": 724, + "amount": "0x01", + "proof": [ + "0x8f10efefd01f787b09f60688a61d69b44af00b775e415c82f2760e20fa57c793", + "0x2145735650655b7da0477cb392e2faae0fcffe71d1bf2f1e112c39705d704ab0", + "0x71bf6e85247d9d89451b82be9a28d64d19071fd3c122e3bcc6db9f470fb854d4", + "0x1a6147d096056583b570a6da72277e79d6ef31519ab9cdbd2d1115f5eeb94a46", + "0xa4e0ebcaa65c6595e7c7f0ffb89992e2b9cb58ac405c81aff220fc4b16ea3b6b", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xBD1f7d88C76A86C60d41bDDD4819fAe404e7151E": { + "index": 725, + "amount": "0x01", + "proof": [ + "0x17a720a9637f0cc13b6e0c109ed908f5b2c8c3e1004cc7e24675b903cadb0c37", + "0xec7984d82e4108cd68f03600909ac5bb276898d3aa56b76e632a57ebc9e22259", + "0xd5460b9cbd07eb643394af0ee8ffa7d20c13c474c42f8d3f770490047dfc42ec", + "0xd4e406b94f7009e26e52781d8bbbf71780c9ab5d8d7b9162b8469ca115683ffc", + "0x6431c24d3d46ea6b0d1959c0de03265dc474d3e67139f2bedca26b5aab0c0c5b", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xBEFEA1c9e6D0A95bF2a352ac1aA5fF1fadB01c8e": { + "index": 726, + "amount": "0x01", + "proof": [ + "0xc5328efbb636abb694e31a20426b46d7cf6df20389fa025521d4c27a4e71ebea", + "0x2ef6501a43ed6db323249952cad264de3e023579cd5beab9a0ab0c197e8e526a", + "0x1c0c126d67f3347f6eb5a3e70bd23a4f895f18b6418e58068e703bb374301b5f", + "0x99930015299a0435807ebbffcd0957a02cf6631c31c05ff8ed9a165cfa4bf8e6", + "0xcf22c1d43a94c7c6471efe1209a3b103ec0a9836b6c11fe8d2e98d18b2e9cb36", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xBa05FA4f86e4B33d7d75f3804Ce29Ff9C9227C38": { + "index": 727, + "amount": "0x01", + "proof": [ + "0x3e1ea4665807880df29d1a5aaf202c95056ff6abbdefd0447d21ebc907c839d4", + "0x3140324bc56dd1c226a01d20700027866c92bd334d17de81760ebc58afff952a", + "0x9bbb60a5fc709695e163323f3a6b2381dd7005d331356c8315cc8d38b4d9cbdb", + "0xaf86f597317f3202fff25068896658613bc0cbf9d7a66fd51e55c97f2358b8ee", + "0xb5bb98883f5ea232108866e1400cd4067f34fc2d70605fd2c67051a6095af7f8", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xBab147b43b244988797331E0C78e769AEF01310c": { + "index": 728, + "amount": "0x01", + "proof": [ + "0x9ee4d7324bbcc89484155d359db22b1c5a840bf982555ceab4e4820c9f1c658f", + "0xe28898e88d213717bb65da16f880dee507da43bfe760c044d587438005ab51d8", + "0x2fbab75f362970937a06d430bd893a654663902ac95b78c258989474b316ccb6", + "0x35b38a743320b292e89d9164e2c2e5018fa2478f9a132ef65671c9bacfe611e9", + "0xc36c52715656389b2693c145860adf3b1f3d4d24a139850b1fa5f2236456376e", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xBc4c9E1905e9fC4090877a779d267cD521980c37": { + "index": 729, + "amount": "0x01", + "proof": [ + "0x5cf072f52bd5637ab3c029eda363ce048199c2354882528ae07bd9ee2a54aa4b", + "0x2f61c8831a65791851700458e81b71e370f088e6410f6d67b29127c65d931550", + "0x747693e41d14ef24bc2453cf37d950f88e7f694e4fdd7fef48e85a35e7221968", + "0x4bbd36041ce4968e3db3409953e198317c2cb3811d91f8fc5a98ba5c581d59e5", + "0x140105e3fa17ce783a651f2281967c53a37a748c29442efd53ee24d8a1cff6f5", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xBcf224cB3771bB32B7a9D49D573375FfA5E29B9d": { + "index": 730, + "amount": "0x01", + "proof": [ + "0xeaa9920a3ed599f53fc37d87db03721560f0ca26700b1ca08daf2830354c746d", + "0x1ede3ffc6ccb6aec3ac77412d9d1a0c99f9bde314f2ce9189985a3a1a12dbec7", + "0xfbe53237fa258f22a663d189073b771fce11454af4eb8ec55016ffa20f6427b3", + "0xa6bb3b2aef22e52a1e0052bc5777bac639d24ffe832889b483d829660c1bbc1c", + "0x3ac4ae4a4697e2400113df3bd55f84456aff86925f45224af80fd8af20592214", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xBd44999904C59b87403A1824b3d199d520E4fa46": { + "index": 731, + "amount": "0x02", + "proof": [ + "0xa8c6af409b515fe6ed1ed3e45b960bed288583f1a635d9eb3c2c5af8ae61b61b", + "0xe7aed7aa44b9186eebdfdc871e3813cd3472e8698837fe68211825dbc917efaf", + "0x94d660904dde29f38b66932719fbb6b3f61f23334c6bed78753e9db544ffe1da", + "0x68141ce9c9d3196b1db61f6e6c902aa8569304d1613ec750ac0ffed8af2bb113", + "0x32636a5315ca425c602832f925f24426ea5aec9939c73d1b2a6fcdace85ecae8", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xBdD17ca9769145f7aB8De74B85A4FE65bdBf4D3C": { + "index": 732, + "amount": "0x01", + "proof": [ + "0xad20df23b4bf7f58c573274bab4d55cf15b30e6ba24532370d6d95b934daf259", + "0xc698bc652b758e0e6ac353da1c66360662eb63823635bfbddf0bab4e3d6bc94a", + "0x547310dbf01783252ecf8dcb1f11da8552ff7f0911e701b5e17e3f8ce6679a4b", + "0xf685abad756fc52292f02befc3f5465de8d8f16cce61117b3f5de4fc38a60819", + "0xa952d1dc401036dd357d470bb699a7e9cfc64f0caf6dc51a638cd2487f5e73fb", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xBf1F0BEcfAFae00269a68349854B52766968C550": { + "index": 733, + "amount": "0x01", + "proof": [ + "0x58637f6b49cd68195528cf64a1a05896080ae68eedee40a5158468eae11d6e0f", + "0x0790dc7bcaa6c4d6aec3b9e0636578c0d57dd05721b3ec0594a7e74573105773", + "0x708202d8f80bdbf5dc568f0ce8b7b9af201381136571a7d967efe4f79deae3c8", + "0xe759b6546746269851513af2e7b90b699309ac7fd4eb1cefe25f45f6c49d094e", + "0x6ae25cafc683eaf0756d86c89deb0abecfbfd01e812ffbed4e7a26f11cb91f8c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xBf299C79A2752F9945198B6Ab48237De20f9C063": { + "index": 734, + "amount": "0x01", + "proof": [ + "0x2f7cd682497ff69f4c2f277ec67bcd7f32a0665c6504ba78143fe1d5fd63eea8", + "0x4a32f641947cf748eedfb391350ef984318a6e6cf1cea98bc14cc35cdd1adcbc", + "0xf9b0841b7b62c71198361192f1c7feafd2ded284dca91596cffae95a4d3686ae", + "0x7fb8279a3bf6834ff5de6f30e4ebf74889d64cf70547e9c78a27d7fd86516478", + "0x4325701890e79e85b41231157c1ced07357ce871ed6fb4f233c2f82c38bcf4bb", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xBf477a8e5752153a672074a13864d187166860F1": { + "index": 735, + "amount": "0x01", + "proof": [ + "0x52dc75f172142dd083fe0dfef14d2a8cb7e4506489f500e4fbe4ec48c6324fab", + "0x00d9512d2309b56be4823526c3362ade247918c40c1baa0eb8c4ab6628d9b8f0", + "0x41a070fc9cc72447357345f29cf0f36b25fa38ec3250d2f34d6a05451b8da742", + "0xc7b00ce40d9d1f9a2921254e2bca646cf3992fb2c667a15215723d1f5a1b5352", + "0x5477c93aa7e191fd8f76e1976387fc82460220dfdcee87f9ba8926f4e0ddf45c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xBfA62BAfBE913971F9BD35eCF4c0f2aC2D7bd2dD": { + "index": 736, + "amount": "0x01", + "proof": [ + "0x52444c8e51bf0ff4f46be4306d4c476229d0aa0138e22ae529ee32534a75312a", + "0x41dc249b7a9af195f15443e58ae10327423602f5f4e89bb119eeef7f9c13b66d", + "0x6e4e3be8c84bdf4ca5531cb1f98b5a0f91f960b234deca1bc85cd01c39319968", + "0xc7b00ce40d9d1f9a2921254e2bca646cf3992fb2c667a15215723d1f5a1b5352", + "0x5477c93aa7e191fd8f76e1976387fc82460220dfdcee87f9ba8926f4e0ddf45c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xC0D7050BA38319Affdac5ca22c4aafB5a36a98c9": { + "index": 737, + "amount": "0x01", + "proof": [ + "0xe6f18344f09184462e12bae6bbdc4774e628b43f15755d9f681f73a95d5ec677", + "0x68cd967fb4360752099fe5506c783a0ff76903e24668586a2159c2f2952cbd51", + "0x1a4492318b217e4bf203e535736df5d575d869a4d6eed45535f3a69b1bc59f98", + "0x6029ed468a13d48547faf514f4c29ae1fc65bcefd1ecd17c26aeef29ec044356", + "0x7a545b345b30e441bb780a4fca731a87b1e941b75518a9983a312194a9e7bd46", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xC3314436B4A34B720c79fED859D5f57Ff5ce0fB4": { + "index": 738, + "amount": "0x01", + "proof": [ + "0x7508c909e95368979a1e0a0240e5a7432c41e8541c2f86294cf6900a3c230aea", + "0xc2a75931f9920c5db34acbbb5ad755aaae18129b7ad5e434043ca4d97d81362e", + "0x6b1d50c8f881c6c8993f73ba91868e17e454e5d10e04868fd2b9002bfa1fa4c5", + "0x2542d5bed1352bb1dd1986da7e22c1f92c0eb7a7dead185e5100d7004e8e054c", + "0xb78cb1aa869958030ce4a14b5fff6309166225c83e0cdd2b91deb7b1639f67c4", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xC344ed0081Ef485Bb9D403C93C6251f36a87F3d3": { + "index": 739, + "amount": "0x01", + "proof": [ + "0xf66ceeee1b1a9edd6003606f719f3a5a70c7a0dade88fa415fe978afbdbd2c51", + "0x44cbbeed7b88c4386570b5c8e618c9d5290e2044c47bade3d6311e3d36263b03", + "0x3cf18ad5ca915c66f70477dcf495054eee4647174a0cbbdc03c3a2a0a13dee2b", + "0x11f5a22099e6617cfb9a813c15cac667d29fe00a5f0d1618572f9c1368ac6385", + "0x8e7f75ccc4d864471b1a7ec71efa29a4e8cc4761c26a6987c8043d9ca642a2a0", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0xC363Fea8f6ac0b4D5a071291105fE9b41194964B": { + "index": 740, + "amount": "0x0b", + "proof": [ + "0x7fe38177f368f89f92950081dd8f8e4a7efa06b17cf24bd7d2899ec84bd47198", + "0x058995de9bce6a10db2a0ae1b67ed73f7d8bc604c18edefcd250fb9c62aad40f", + "0x9e4db0ef0bf78311ccba227202728b6e9f6d7520b3721365f3c58f996096b59a", + "0x138bee476bd8ce498e2985571c0fd10b392ab6afd8c1bc3ddfe5859f552044ff", + "0x891a74fec62a569bdbcb44171dedc1926c5cbe5d803c0c17ff419a861e9ee5b3", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xC43Ea5617a6b38b7560eDfB0474031a661d86BEC": { + "index": 741, + "amount": "0x03", + "proof": [ + "0x08469e53cf84749a82aa44457e077ff1dc4aee6404ad3a5d7de3dc2c7eab5996", + "0xd7eba5ca62209179dbd0b40711ac815dc26a99dad294cf14d27fb4003bf8bd2a", + "0x159ab1cba9bf6ec481ada7ab7f7a06201f1346aa831336b8b398fcd6da2de059", + "0x7123b37c640e8ecb7e1db656a0f1869aecd392fe2f9511dc671c16401bc54aee", + "0x6e752d8572dc933bdf463f24751c7070d8aa74bb8987a5fe56dee3b0c9f53450", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xC4913a9fdf5b58370f21ad2694e3d23e0b406371": { + "index": 742, + "amount": "0x01", + "proof": [ + "0x824a1b56b75d57c617faf3bfba9754ddeb2c29c000eefe99f06c902754092eba", + "0x45b91e5e98b3e48fc5a35c7b9cdc31bc33b370e8078395ad38986a71d76d9e02", + "0x4e10e7f195c67618f3d3a7993df508e04ac06383b5ec9580c6c0aa53b1917d0d", + "0x13c4723f9c83e02f8e5d7f08a17afc4776844c18a0189a9fcccd2702d623254a", + "0x891a74fec62a569bdbcb44171dedc1926c5cbe5d803c0c17ff419a861e9ee5b3", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xC54bD1f466f2F4F36dE59F4024e86885386d6f1b": { + "index": 743, + "amount": "0x01", + "proof": [ + "0xef35857ef16e79a04bfa1aeec88c2676735872c2e8890b2dbd2afe642bcd8c1a", + "0x8cc17d0f380b74dddffffa310d27cad5ff4172c9fa0cedfe83f90553757150b3", + "0x8b6f824fe42a7f1d9f569625e32995ee98e15b37301a2c7063fe65c4ed0c6e78", + "0xfbd5cea7e1eb5806f6f82efdb0e881576ab386159b1b3ff7402e4bf56a947d8c", + "0x58340ed8edb441d787ada6b1aaf2b1e42912724e1f0f7887cde9253262aa0534", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xC5592b6E87CD2195bb65A73Aaa9f83b158578FA1": { + "index": 744, + "amount": "0x01", + "proof": [ + "0xd4ebae1a1c2cc60773277db8eadfbe3fc66bc5e45161bffbbc66ec679e5a4b91", + "0x20c42b90e3c72ff03126a70d7fe423736d587aa60a80686081b6b0aada676c69", + "0xcf4b0a8be134a824cf199271e2b48b713aa95add1e71d8db714ef711f58a2265", + "0x295b1cb76b1ce79cd1280bb1130a4264534288edb4c264d45d4ab36dd72b36ca", + "0x7e73f337249898d15604f7c330d90e36da04007407404a4b4276d5fe3083b929", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xC579Ef8B14774BD15c021D2C0aaFd04bDd7dd137": { + "index": 745, + "amount": "0x04", + "proof": [ + "0x5ca74b1c9a226d516c41b11846bfc4a5eafc31056830c48efcfbff549170e9d8", + "0xaf8a6b5e57f607d9abff5e1c158cac38e624b13a570e6b2bff0aa98bc384e973", + "0x747693e41d14ef24bc2453cf37d950f88e7f694e4fdd7fef48e85a35e7221968", + "0x4bbd36041ce4968e3db3409953e198317c2cb3811d91f8fc5a98ba5c581d59e5", + "0x140105e3fa17ce783a651f2281967c53a37a748c29442efd53ee24d8a1cff6f5", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xC58Ed30b2097A95adF8d87cA7459F9012E39eF69": { + "index": 746, + "amount": "0x01", + "proof": [ + "0xe508949f84d739425f035af1557acb26f66f4eab5f1fd5d56652ad34863b6f15", + "0xe4d3a1207c58c789f1eb6f8d5714fb54e6551757d5ddb0fd5c246ec39a3b4bdc", + "0x8cfcd40e91f96163b5cf64d309e176e363224f3a7be5b7057c9ec3c6a7181408", + "0x372cbc91aed35f80f87f2c13bba747106e9ece94f8d166e828a5c70b321c5528", + "0x7968b2383e3b914ab3a36580b205f1449b51563630c77871f712e94743e3bf39", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xC5e2C6D68002aE837314DE89D600E69B94d76754": { + "index": 747, + "amount": "0x03", + "proof": [ + "0x8e50805f299c5013b965e590507625184c1b7abcd9564a307ff33d5639a757eb", + "0x8539f18b2c4ad9e2b18947b2014abcc884a8b6563eaa9056b38563cc553c4b27", + "0xdf6cc73a467552881abcfe25d30eb0b4a6ee65fb03e1f816f4e39315a3ce78bf", + "0x7217bacc0b5fadfdc27aef27f3baae246ba909c02961594a63bb24f24958cc4c", + "0x8fbc13f50b0f82a781945a74ddd5c5abde0b4a8983852c66ecda77a68df50722", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xC6634264819Cc5AC2692c9ede685774618a4198D": { + "index": 748, + "amount": "0x05", + "proof": [ + "0x526f42c37fcb381524b24b14d83b720bfc41d70549fbe4f456daef8f9eddfc37", + "0x3a4ef6c43a568adf02bb5f0dd86f51eb13bd18b23c9c6ac87db90f9bf8517839", + "0x41a070fc9cc72447357345f29cf0f36b25fa38ec3250d2f34d6a05451b8da742", + "0xc7b00ce40d9d1f9a2921254e2bca646cf3992fb2c667a15215723d1f5a1b5352", + "0x5477c93aa7e191fd8f76e1976387fc82460220dfdcee87f9ba8926f4e0ddf45c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xC6D4E5C1cd5c2142C4592bBf66766e0f5f588d84": { + "index": 749, + "amount": "0x05", + "proof": [ + "0x740a30d24eb95f276746baade83527a67b38ea69beaca86a098765a58012e614", + "0xbe6961f62085dfb7ba32c6a2f222568710a17c0dadb56d25b3bd32a65b3edff0", + "0x36984f6b1b4a1a6d888f3fa91ccc133c7a4f0e096be3777975d3fde4090b511f", + "0x396e47c3a850c873832c034b62c0031de9378efa99594428607ab8c6bc01e27f", + "0xb78cb1aa869958030ce4a14b5fff6309166225c83e0cdd2b91deb7b1639f67c4", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xC77FA6C05B4e472fEee7c0f9B20E70C5BF33a99B": { + "index": 750, + "amount": "0x01", + "proof": [ + "0x593a07e0bcd021ea3b37e341e7d78fdca9a507916514fad52ace09ea01ed8b2c", + "0x5c28d048a86c724fdd99249b88afcd1aac2839a630a029fd026803bca49e0c58", + "0x7c23f4640cb3e1bbc8e7fda85d8fe777fabe673ab4467b36de7f64c25eef8b5f", + "0x5190cb032ba95080f88929faf2eabe8bd342a53206176fd2c3afcbef4577ab71", + "0xf9f105f90db6fe2970fb4e03b35654f9b69375879c783d3f1700e04b2e2f925b", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xC7B03A887716ff4567B02509aF02C0a7851084d4": { + "index": 751, + "amount": "0x02", + "proof": [ + "0xb286f9c4236052de81cae37b438a7ad54a90fd62392e19865c08613836f34c0f", + "0x7226cab2ff9b4e932dd8353e9d8be94a42eae77d74fdb63fcc8e7dbd8aebb36c", + "0x0826ae5bb3f37697633d99d3705ae48cde39e7b0d247ca8a78e1143ad8ef0c99", + "0x575d2e3f9c311244d801f96a2b4f9fc9666f8793f898d400d71e121add7f872f", + "0x529f1b48ab616d4dd60f663753a7779d8ec25952bc8c34df4aa96347bdb0d542", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xC7e21a3A3429ABe960e8E659959F152d4Cd3F76D": { + "index": 752, + "amount": "0x02", + "proof": [ + "0xfdee22e6be995f959eafa98bfb60760465ac4310ac071373d980b9c32e260490", + "0xe816858884e4df17dc1042a829aa4cc127d6b9762732d895ee3207db7d089a5c", + "0xa7b1364c89574d145647fe0631d469a646bcc060519ae25e959ecafa4f17d9bd", + "0xf7b15c813ccb2cfda0fad7314544180ed758b3ac0213d482dfeb48697c2a487a", + "0x938890418edfff03e5d8f0abce65769ab79b16db349d2869a477500717305360", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0xC87A6405cb1f8175547e68684cE361c9c62099FE": { + "index": 753, + "amount": "0x01", + "proof": [ + "0x96e512381077365ec27c0b16d951462c18a27343f84dc0113bd7af8b07cecefc", + "0x4917c7a45d2e51f374f1f90b304fad3fee6aee02a1df1223086a532c4a075ca6", + "0xb575a968000894924ae64573326e1018adeabbc274265be52c946debcdd4eeed", + "0xb27289c273000ad0db5ed9acba0b01be05f672a2f40d51317a96231114834c95", + "0x62ba7b58fd554e8be295bf9d4baf9eefd0b518ead5cb8bab321717a08160ae0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xC881Ba24fEA61D9c629BB7EB79B3B20392584115": { + "index": 754, + "amount": "0x01", + "proof": [ + "0x32b0afdfafc6d97820eb4b1fe70530c207cb7c59208ec6321d45507976c962dd", + "0x4255b68f002660f4a1f68ac2c5699100762f34e0ac84047e1501eb89768d0532", + "0x39cb0477c1d663a69af4e075a8fe812a6810eac47e570c671a96d933ce996528", + "0x721f15749c8ad9759a4a7d682519f25f59a5bf74daab7275c00bac9f0ddc323d", + "0xd6d09ea62a0a0959d8a1f1cbd849b805597a75fe443bbbc4d5e2555bf8225437", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xC8D46eb7881975F9aE15216FeEBa2ff58E55803c": { + "index": 755, + "amount": "0x01", + "proof": [ + "0xbc71f2c2e0faecaab7d153400f27d8d0f5bafe54311c22b738cd63dc1d1c6d03", + "0x2b5fc998bf7bdafdd979d9b2dc22d08155090c5a0c5eb6adf9054dad8bf1831d", + "0x2be23c7221abc4f749899eaf8c4fed2a3ac3684b891e4cb0133f0be9d8b49ff7", + "0xdb334b0b3ac11eef22a51af7bc46c7a633665d404c70629bf6c429ed0b8d1ae6", + "0xcf36a9c08620752945fec2c3138a9b0eaede19862d6c5cb3c0489e6ab3a443d3", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xC923dD451dFb1fC6A4608982C6c077414Da06a4d": { + "index": 756, + "amount": "0x03", + "proof": [ + "0x207b0a22034919ff68730389e210a4aedb8b40aee009a64eb4f6774ca481fe1a", + "0xd593751391237b65ee599de699be5f74c8f1e4280c2e6fd0f95901db3b0990a0", + "0x8fc8a67860c71618ec1d12e3c31e1c3661720c696a607f77c198be36067f576a", + "0xc59577d42e813ea179264892414f1c8c6f09486aba6c8a1a1cfecbf6d1e7784d", + "0x6665ebe68e892e4e5135c09f9cdc379628aaa60a8ff322ed2ba75fab3b3a9cc0", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xC9848f9146a56b6B5676B06f454a62A06A66Cc03": { + "index": 757, + "amount": "0x01", + "proof": [ + "0x39a99f56c3908f44dae570ee7cea6bf63d3e94185a13b82b09974d5369a3a1eb", + "0x14dcb65260e6e607a3d88629c0bfdfd1ae9b5b3d32cdf226c99fb0a49e010a29", + "0xf40d9321096b33fe11dd3bb5f540443ccc3463fb86ca7e96dbab2cdec392fead", + "0x60583de8b96cf21d7bf97a30f8f28bb928ffecf01373b007ee5bfa1bb5a1f776", + "0xdc998377cfbadb1c2d77196acc69c259bcfcc6de58df7f5aeea2780a288f2509", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xC99D1e8E91F5Be830Fc20739FF5FCae08f2c32C4": { + "index": 758, + "amount": "0x01", + "proof": [ + "0x50dbb59878d07f7fdcef0c3c0e34204599d2690c09a7c95c394b5a96ca44118b", + "0x8b699659068c19c6585703dd41ec909bb6cfd3d4f8696feb9839c594cbbfa5a4", + "0x94ae5af5bdf40e5d21b91608a4452d0ff68fa67ab1aba8eb3e2ef57df1ed7d47", + "0x60ea05c082bde3732ec3daeb0e2bae0395932096e755b1a42d9def3042bddceb", + "0xcc9986a7987738d81db64db86f583aed4fde214b766f55d0f15a876c8f790fb8", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xCBBa4fb07D4a86267741CF1A2c363284eeD00f0f": { + "index": 759, + "amount": "0x01", + "proof": [ + "0xde3faef97e349e4521a529e6b35b6900a473cae8960769b0dc8d95d6f9dbc254", + "0x2b3965dd058fc966056ca32f21582912b205969e026f50371589e6d9d7486be0", + "0x31a842d521aec1d044113ff905ab1b4cbcfd79d2a39867e544a17434c3fae105", + "0x285f0861eec4fffdb569c07f6f01125414c98685171578e7317ed5b8c16ba373", + "0x966715df220dfbe5e11392b257b61b64c18178d1825b654f95f67d7c9558a2a2", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xCC8064474bc8B9eb1103f1f931803fFC8988eCB2": { + "index": 760, + "amount": "0x01", + "proof": [ + "0xf2e43d790af5c88621c319b6b3f92dfb551edfd2591a45ad0e0710e548f8b76d", + "0xd9895ca238040a842ca0038140e67b405a6f7cba6a467efbb3c6951596d1fa20", + "0x7ec9bc99b06cb88cc17f324af3ce04347d9712a8cde058a864a99e2270fa22c9", + "0x27cae8e1fac7b32e83e85494312638757cf1e0afea8f4e6fe77387c412b4efd6", + "0x58340ed8edb441d787ada6b1aaf2b1e42912724e1f0f7887cde9253262aa0534", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xCCa11A8EdB05D64a654092e9551F9122D70EA80e": { + "index": 761, + "amount": "0x01", + "proof": [ + "0xeff2c14ecaf7ab7be948b683e388d495adab708d498188f412ca2688cbab2d32", + "0xed750b694bb028b90d9b7935b9c4527713932e90b2cf648ce068500c7b73cbac", + "0xd8a35ae28db7c81be0f42512143e3c242b1425823caa2703947a88061459e211", + "0x27cae8e1fac7b32e83e85494312638757cf1e0afea8f4e6fe77387c412b4efd6", + "0x58340ed8edb441d787ada6b1aaf2b1e42912724e1f0f7887cde9253262aa0534", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xCD7f6b72049C3b54416f9F26392cB271e74ca3FD": { + "index": 762, + "amount": "0x01", + "proof": [ + "0xb78b7a7bda4e516a5024e146ab1aced40f25c0a931fa6ea535d51955cc94e597", + "0x05ffe3b5b849c24a871c0d096a106c18d398de904a1de820121b7770db6dab67", + "0x96a51c82a51e9090e50794110f5ae30726a62fec6e8961aeea449b4515be8759", + "0x4f5594402e5d778ad5cd48b93173f203af8e62306714d707dc5f989e11faa170", + "0x83e262e483a6f2ff9f4df14637dbbdfeddf0c6b0b4ca462c4375d29a3521e052", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xCEE1d419aF3a7e5c92D91e7CC37565b1263f0Af8": { + "index": 763, + "amount": "0x01", + "proof": [ + "0x76caca4c20b1b46fa765dac729190ca844aadd88b7dc4d60fbdfce1afceacd52", + "0xf84571833c91665a6474a6810751b281ffd0ed7a81d1c52bb39837e7e9025ade", + "0xffaa2df36ce81efbe18a3f705e17efe3acf4e87e4d8a4423f01cfbe9c3278f32", + "0x08cb8a426c97a85d30cf9308f5228aadeeb1f2c3f1f22bb2fd0d6c1a680a3ff0", + "0x80cf615f05f15e9ed665dd7df5d086fcb70ed5a5086e02db7c08752fcaab6507", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xCEFdB5f635Bfc913d12e6eaC3738E92B1681bD65": { + "index": 764, + "amount": "0x01", + "proof": [ + "0x14397340b6f6220e3098b0b1a5540b85af83fa8012a66d4330c35492d0f97b01", + "0xe1254887b3dfac54e0431444b742b3a9343bbb43159e1b34b9fa1d4dac711bed", + "0x5517cea35fc2ef88c454c0abde49cce58c62d4d8057d3493875f1024ae1a58fe", + "0xdcab737bf32fe2edc99f37725a5c46b3f4c2b142298388f08a1bc983981697d3", + "0x6431c24d3d46ea6b0d1959c0de03265dc474d3e67139f2bedca26b5aab0c0c5b", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xCF7e5D2Bbe28D27baF5e26E53135bb01e2fD5515": { + "index": 765, + "amount": "0x01", + "proof": [ + "0x56045f01d7eb46cf39639fdc68ca5ab236044188cf02889c7017fa64b6c3dc1b", + "0x3f9a3940905021f1f8b6b86941a1d2081d0d4fd2d0179e4b623586da99ad8581", + "0x782de94c988da2786f9e32de9d24aa87726a07cacc4ff5098224c6ef0c91f0d7", + "0x9104efb4441e61a09b4e458e6b45f6759c37c20733b5823cc04f759cc53d5575", + "0x6ae25cafc683eaf0756d86c89deb0abecfbfd01e812ffbed4e7a26f11cb91f8c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xCa40c11706E1DD87C9F24d90b4A8820e15f109ff": { + "index": 766, + "amount": "0x01", + "proof": [ + "0x4acdd1443c19c53068ae01fd77da9f0bf7f062ce19bbd8802bbaea5aefd6dbf6", + "0x20d7a712dc0ca54759ff1126b0cbdca4cbad34e2490974d006f14d8449942ac4", + "0xf51571a8d5447a22467ef7675b2c9fdf62254f3d4938a09245fc084f4e588343", + "0xf94cc4240e18301aa3e9325f55d6ec2e2e84a181037fd49b69a29a1aedce082c", + "0x43f59a603c2458850547e5a84d47e61be843b4a3c814303ed1b52e1e4d37a1b5", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xCaA16004955F05599C7cF215aA271a4F3544D6d2": { + "index": 767, + "amount": "0x01", + "proof": [ + "0xdaaf8a83a906884962d691b571cfd92c848a3f9b5c783948d976698bde75ccc8", + "0xef33961067e67291172ee5009aaca63fd8997b0fe7859746ead185acd9e89cfc", + "0x80779d16ab6f1d2f1a5df7a70354491bac8b36d2f137ab7274b9fa248eb57487", + "0x3cc86f19d7ab5abe54cb84f21d19174b3158c792e08130d0d4f813b822ec451c", + "0xd8ba0ec6899e7ab5afd6774d7465b2ebc52e677b805f74deb131b1b243bae70a", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xCb28061e2153ca181830D3864646b4473F4125D6": { + "index": 768, + "amount": "0x01", + "proof": [ + "0xb233e94890245757fc1af075e283880fd0f20c14f894ef1deb7ba8a819339ede", + "0x2b8ccd99af23429cdf432903596a90f7c4c538ed69414fc53b41e6b1fc46eff7", + "0x29019a0cb0bda0ba23b44ca59094eb26fe840748f490419f63051f2087caee0d", + "0x49f4781ffbed71f831627c02425eed106f4714988055f5e0978de46ca35b3ae0", + "0x72373ecc225af245878bc638c49c8901db1430b7210a3008231acc8f8118d2e0", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xCcD9C5465faC5C0Df86fD9B7d524a5949dEFcef6": { + "index": 769, + "amount": "0x01", + "proof": [ + "0xad6d9f80102b4cdb073ac3b119c9e7040f5770dfade250e4fc0558c31e9ce32d", + "0x7bcbf70b3eb8c35daff61f962343f1a346a33afac8b2bba94116c68ec1ab3c62", + "0x98dcf697690e69aa965e2413c9bdda9a1af7d0ccf6a569bb34035b0369e22372", + "0x298bc701f239e72f83c6fbd5aa5172caa103b1453ebcf9fd1dfe23628f4dad14", + "0xa952d1dc401036dd357d470bb699a7e9cfc64f0caf6dc51a638cd2487f5e73fb", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xCd0D4CDb238Eec15Fcf4ff9d13d5a59051E507D7": { + "index": 770, + "amount": "0x01", + "proof": [ + "0xbe3a928a1a07e4a517b5c52659ddbfe60689e20fdf3919f69bd575c73346722a", + "0x5a2edf0e885259fc44fe3d92575379bf3b1e5641428c327cf74c83d27f35667c", + "0x81438df7a27c7be027c254bdd75d2f0fd663816eed20147a4ff92559013874ae", + "0xde546e8389f64cf158f6546ecf18f3c473b0c5660810c1eba849db699f2c4883", + "0xbd7abdce9ec414fe47ea73146a2131622bdacb914ea6353abee1b0a149275092", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xCf05F1B88760803634Aa827Dd71d89fcA67996CA": { + "index": 771, + "amount": "0x01", + "proof": [ + "0x07ed19ef89727f8aa436ba6424e4de86fb63bfb699210fd6278d0acfce2fe431", + "0xc60c20faa140eef468595154b1c6b51502c5f5f41262b005375fe5c32a5c127d", + "0x159ab1cba9bf6ec481ada7ab7f7a06201f1346aa831336b8b398fcd6da2de059", + "0x7123b37c640e8ecb7e1db656a0f1869aecd392fe2f9511dc671c16401bc54aee", + "0x6e752d8572dc933bdf463f24751c7070d8aa74bb8987a5fe56dee3b0c9f53450", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xCf50fB42926b255747fb8b0EA8E26D4e66952CA4": { + "index": 772, + "amount": "0x01", + "proof": [ + "0x0512838e7e11c51a958847ebe67a32ad6ac90e74554dd5e176650046d518db33", + "0x24409cd3f82bc55de621ccecaf54842dc6fae2367889f37ad3ad85d6af19900b", + "0x3b9ae731fb4fc0a972a141d2c931c7e4afe1020d11bb774ef3a217e73d2e8b23", + "0x2782f91cb56c53bb349c99893dffa8838299f03f96c6519b56f604653b45586d", + "0xb18758ddf98cdeec3d020c2379717281f5c0fa0133be7d006f7f753c756da43e", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD068E0ea1A8488320cfBEb8F4B4c0FB91707d22B": { + "index": 773, + "amount": "0x01", + "proof": [ + "0x29354eded7cab0ee69b798f39fe758d319228117c4c0fc37a3705595a49a7fd6", + "0x29bdd026c94c93d3f0d201334bedf4443413e2d5823a8fe03af99efb02da7b92", + "0xc62b818bd2a34acad67723e97f8667eec6de397168029a2670ec2681852c4b26", + "0x1ff461854683a34317216055e65b6637346912d1739163d25c1a0b0a5f15c25d", + "0xe29ba79106b7b14c14912bb5fba509f27997ddbe5a7ebc941fa75e3475af4aef", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD072FC7E9906Bd76E150CB20C874BA5A1e6bB015": { + "index": 774, + "amount": "0x03", + "proof": [ + "0x2a1157e826a9cb1516b4348c5d8ab6ef7c48ef5e698696092fac284d7a3b383a", + "0x2b9ac8a58419cd916c053d21623bcce9944655930b577d24647136c40eac20b1", + "0x76ac0e61f5fb8527ae23175c183589d51da559dacc49211473b64d81eabda65c", + "0x36710d40c48dd22c4c23311fe2998a569fb56756df4d8eda7bf12408489aed56", + "0xa43a1be4a3c4bbd4e28425f3172d3522b7e954d7cf0fc72a26d8ba7bea25f197", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD07D7fC9D70e703723CC08EE060a5969666934A6": { + "index": 775, + "amount": "0x01", + "proof": [ + "0x2a81eb10e7c8bea37cb05dd01f6c0c2d026659d2f96ffbb84a76c5a75837b360", + "0xed67150d4f25c766c8ef79515226a6142e6c2e84ccd39078ebf7263afa3315a0", + "0xf55ee0666a9187169654a25df74d4fda1a91ed9900daa14c5b2ca79408f70443", + "0x36710d40c48dd22c4c23311fe2998a569fb56756df4d8eda7bf12408489aed56", + "0xa43a1be4a3c4bbd4e28425f3172d3522b7e954d7cf0fc72a26d8ba7bea25f197", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD0F0b33573950C4fd9faD0Fc04B321996F958Dd6": { + "index": 776, + "amount": "0x01", + "proof": [ + "0x67efa53365958fc24ac8fbb5ee7d0a8f71964b8178dced93df4c6021ec39d025", + "0xb3b75ef503e13ac814c5959f75334bedc7a15658bd3edbf729a191f090bad8df", + "0x9feb249fa051b9c4d2179c5c0a8ed76334b875245fb0c811161d3bc057ef51ab", + "0x5fee000564bb97bedb499d3b5c01f147f4e4ad76f5f6443565804721f95dcda3", + "0x245190f95f5e09d43d1da7e9757fa066be1942b52f7e4962cbbe6a5f2e0981bc", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD18001F022154654149ed45888C9c29Def6d3CE6": { + "index": 777, + "amount": "0x01", + "proof": [ + "0x0e55d060c076aca0b3547be8c12772354f5b8f64f4f0834f42bb06a2d03eb501", + "0x678751dcc192a114b1934b681b661c1eb38043deaaf0c645bd99a17346b5dbf0", + "0xcef2c8add76582c68d291ef22132fc17c35fa5b70f010e8c9388f4a93bba288f", + "0x037fa491e4b6fc74b9dccf3175d28aed9f5dacdb75dd0fc8e1154a0704619620", + "0x4bab2069d20a5d1d2f5ebdb61803a57609b7709eca9e925e31a7d14434af1326", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD1ddC0F727935F376Ba6f9F51B1e0Fb481c25FB1": { + "index": 778, + "amount": "0x01", + "proof": [ + "0xee3eaea1d080978ad4f7635bd44e103c229b69a4297dda91b5b608de6bfdd1bb", + "0xa321537092d4c7524a40ba1944dc98d90da4a775200897b7d3cfc79f7a8d9e0f", + "0x87f9ab6301cfcfa1972d69c933df7d435beb9f98f524bff8460141fe4ae2233f", + "0x88222db835a579969caf99eebc6d7f986a78bc44f46b794a4319d01749c83a2e", + "0x6e496426985c92b04963088da4856230c781a975dbb5ce2d8eed77e7d2d4b58e", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD2b13E3144034b95ED0560a6c4b27caDa1bA23B4": { + "index": 779, + "amount": "0x01", + "proof": [ + "0x66dabbaf52d337258779c24cddbfb4d28eabb2e60931dbd0ed54c3de1bd1eb68", + "0xfbe15ec8abd0c306b1b03386edbe3c180fd84fe76020dda49887719c7446b125", + "0x9feb249fa051b9c4d2179c5c0a8ed76334b875245fb0c811161d3bc057ef51ab", + "0x5fee000564bb97bedb499d3b5c01f147f4e4ad76f5f6443565804721f95dcda3", + "0x245190f95f5e09d43d1da7e9757fa066be1942b52f7e4962cbbe6a5f2e0981bc", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD490Cadd3D078255b309Ad32fE307d51E3A139e2": { + "index": 780, + "amount": "0x01", + "proof": [ + "0x15f490835facac9b9eaddd468e30f2e0a83322d98bf301794c01c6e24154a4c6", + "0x194c178a319c8d63aec64d8ab9c07d4444bf1a1678d1989d2d42ba851304c162", + "0x6ad3e4f2caa71a096b05092a987778161c94be804760a6af684872b249faf74a", + "0xd4e406b94f7009e26e52781d8bbbf71780c9ab5d8d7b9162b8469ca115683ffc", + "0x6431c24d3d46ea6b0d1959c0de03265dc474d3e67139f2bedca26b5aab0c0c5b", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD5157866F7bB8f490E13Aba960f689178635EAD2": { + "index": 781, + "amount": "0x01", + "proof": [ + "0x71f708499240470d24063ea8fe90ef7aa8ec3984303ae5dfeb6f0624404d0f3e", + "0x2e7bf4685f79b978110c36c7a80432e17b1e91954dc1283b06c120c54a02da5b", + "0x8be860722f0612e38d1e8acd51cfab2cbcb140685965dff7de6f05ef66a544e5", + "0xfe79a6356c4cd9282dab3a598f859bdcecd04fcb915a9edd66380a81697af3bf", + "0x7abccb934a7f719fa80b9a5d3157e99d45ee17a391abf85d4f60839dbf3769cd", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD5257a3909f522CE44f1aeE6Ecf52b5F99422581": { + "index": 782, + "amount": "0x05", + "proof": [ + "0x7ed2855833eb424d5b03d739dc0e894e5f2c5ce1aeca7e8f41626b967ebdb7e4", + "0x058995de9bce6a10db2a0ae1b67ed73f7d8bc604c18edefcd250fb9c62aad40f", + "0x9e4db0ef0bf78311ccba227202728b6e9f6d7520b3721365f3c58f996096b59a", + "0x138bee476bd8ce498e2985571c0fd10b392ab6afd8c1bc3ddfe5859f552044ff", + "0x891a74fec62a569bdbcb44171dedc1926c5cbe5d803c0c17ff419a861e9ee5b3", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD5a4D485429D24652D797E5da34DA0a5FeD6203b": { + "index": 783, + "amount": "0x45", + "proof": [ + "0x687f70229395268b9310207f2eb65e1fff39d6c407fcd828a9645a59749f4b5f", + "0xdad13a5f20613b56b4713919259a1223c244ee31a78e9f17acaef2803039532c", + "0x41d6fd233f2e0eec852b23d812e880270cb6012eea56144ea5d03648def773de", + "0x2b5637be96c5474a58c9ffbe0539171817312be59bc8b7c71e23242dd20afa66", + "0x245190f95f5e09d43d1da7e9757fa066be1942b52f7e4962cbbe6a5f2e0981bc", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD69517e958EcC2ae83077341cD829849962241Cc": { + "index": 784, + "amount": "0x01", + "proof": [ + "0x0c2eb7ae08a83fcfa8054faa45bfc5745b70209ce16b05d9e850d39a385576df", + "0xb5e70c1781b962c3419d544e090eee4862d34e55f6f7f93a9eb68346268fa483", + "0xbfc26260b7e6983f90908bd7c4dce14d82539f1d2bdee73c0034e9382a6e10f8", + "0x979cc6c181e08190bb233f0cf5b0f7b487d9aadc675c9326a9af9732d3369d45", + "0x4a36dc66177a8394f6b14fc9adbe4ad7e0cc2dead6acb72d80990e336fef8d45", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD6AB3210442765D0BD806Db6643Da28d307eb422": { + "index": 785, + "amount": "0x01", + "proof": [ + "0x2cacc5ad81cd3ce43606e5a16449ef00fc443b3b8d04ceb8d157bb1e5c384a99", + "0x55256e5d206f28cd13ee2563bcd663c01134ed0ffbed2cfa249bd7c244949343", + "0x4463b6536e661f9a88a746064d45ba478e857effdf8bd2e7636f7fd61b93acaa", + "0x71674724de34865e988a846825d9f937ca48ef7322279591194ca7d40d8ee995", + "0xa43a1be4a3c4bbd4e28425f3172d3522b7e954d7cf0fc72a26d8ba7bea25f197", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD6a6027D168cE1f8036D8d01c2918F8Cb610271b": { + "index": 786, + "amount": "0x01", + "proof": [ + "0x331569e4a367996f8d40ee23e6eabced467a89c9c109c4522596ac3026002ee9", + "0xe44717e43041155cfd0a1bdbc104fe8428b4521d57a31abcbc9b8c353ec933a4", + "0x39cb0477c1d663a69af4e075a8fe812a6810eac47e570c671a96d933ce996528", + "0x721f15749c8ad9759a4a7d682519f25f59a5bf74daab7275c00bac9f0ddc323d", + "0xd6d09ea62a0a0959d8a1f1cbd849b805597a75fe443bbbc4d5e2555bf8225437", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD75D580bE38DbDAF64Bd9a725e80A7e154612F62": { + "index": 787, + "amount": "0x0a", + "proof": [ + "0x568cead4c324c67b78b1320da5a8d42977b82269fa49fad7acdb87db8b43cad1", + "0xd628641a688baf1726841af70531c938cbb56bfe1545e629315338c1c8f8d6ce", + "0x782de94c988da2786f9e32de9d24aa87726a07cacc4ff5098224c6ef0c91f0d7", + "0x9104efb4441e61a09b4e458e6b45f6759c37c20733b5823cc04f759cc53d5575", + "0x6ae25cafc683eaf0756d86c89deb0abecfbfd01e812ffbed4e7a26f11cb91f8c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD77900479EF30963F4B5aA7d752b15795192eE15": { + "index": 788, + "amount": "0x01", + "proof": [ + "0xbd165aaabbac381690bcce41ef0c95c34e298f7db4677ee60b27447c856407b1", + "0xd1c4e02a846378a98e14a96757b4ddbb29039ba3dd27df01d9dfa5f342c0f252", + "0x8afb93098421e3e4b6478f7ea0a2cf7b3f942d556afab74785ace4a5071dee41", + "0x3886e44b7873439ef0a83b4119fca7dc640ee0f9551983449d038a076169bb1d", + "0xcf36a9c08620752945fec2c3138a9b0eaede19862d6c5cb3c0489e6ab3a443d3", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD7E630AFCf128feb8b9071A8412914478c00C22a": { + "index": 789, + "amount": "0x04", + "proof": [ + "0xe8b5e705f0d7b5b8825ef241a12c2b2409d105c478f28e26b1e1e4a5a4409ae9", + "0x2f192b17ef358123b3875dbf7d351a6e43c9a6355261b9b9458df4b2564259d2", + "0x4c4c1774cd1fa5133abdc712ac7336a6ec726c09e58e3dacc97192f36b62378f", + "0xa26acb471e2d600bf69b92e87438242435f7a1ed8e490016e5305ddbcea64c2c", + "0x3ac4ae4a4697e2400113df3bd55f84456aff86925f45224af80fd8af20592214", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD87B658dCF5d87552bdfb9d195b59926d002aa07": { + "index": 790, + "amount": "0x01", + "proof": [ + "0x62855d9e446555e3f9209782e382a514a82e17803b41732692651ee6e67db2b0", + "0x90f6565e3b102f483504a56b75ca2597a11b83f3a4b855a44b6c5788890cbefc", + "0xc7139805f0a4080488e635a7b81ed8c230c27ff6fa0f383174e4da67d2bc4f72", + "0x22784474cee51afee6127b1f3fb642ff75cdb40aeb505017bf6b1a1162a44c35", + "0xfe7d73c06bd76d1271e4b772b51e13505a812b7c919129debfd7d15fb5014d16", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD88d5B3DBE8790369799012310c31Eb210EeeC81": { + "index": 791, + "amount": "0x03", + "proof": [ + "0x579b42249e76a2857e125e35c3f24437799897d4fefed6055587c52716f8d4f7", + "0xcfd16bece7c014ad6f62b5a351f1ce42141ca93cccfd4f049bbf7d5041d60b05", + "0xc2728ddd0ac297fcc2105abf09903a984517755b402fc34c874d56a464249392", + "0xe759b6546746269851513af2e7b90b699309ac7fd4eb1cefe25f45f6c49d094e", + "0x6ae25cafc683eaf0756d86c89deb0abecfbfd01e812ffbed4e7a26f11cb91f8c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD8b896B3f6Cb4eDFA3353EfC5ac59443aB50c596": { + "index": 792, + "amount": "0x09", + "proof": [ + "0x8fdf4962a7d14027a4c2e4539ff172634fd79bf954baa487da68c47f2604bfd6", + "0x891a6ab73a892bb29b6aca07841d16d6180b4f12ce3b74b3add5e926d04aaadf", + "0xef1d4406d91ca16cad3c2ae3fcec81605fde6f08b915d8de8717673e99c1746a", + "0x1a6147d096056583b570a6da72277e79d6ef31519ab9cdbd2d1115f5eeb94a46", + "0xa4e0ebcaa65c6595e7c7f0ffb89992e2b9cb58ac405c81aff220fc4b16ea3b6b", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD965952823153E5CBc611be87e8322cfc329f056": { + "index": 793, + "amount": "0x01", + "proof": [ + "0x9da8e62018e6cb306fd8a784f5932ebf70336726a236b3bd3af5172c274cca5d", + "0x9328b04a1f2ec75cab2cd704d50fee1066b62fdf28fa706f82acfd6fa3c135c8", + "0x8b2d67a4a9f2f8b679f7d72eda0998f5c76a314b4711b6f34f4158126ea31f89", + "0x2710311af5d5c72181aeccf7f1e36c3065b1ac40ab236128e22d5cefe5ca9032", + "0x0b385e4882f89784f506afafe6dd217c6ad9d142ccf58713e27961d25b2c6d0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD9A220FC883d60aeb81D99EbE668f1b990F63CDD": { + "index": 794, + "amount": "0x01", + "proof": [ + "0xe0240cdc86ff6924028f9fce81df328c0fa105f66bd1237dd10f1889f1afa8e3", + "0xc600b81b925f70134b23cd4d85751355b23c441e5bf5760e1a7da8c1a3146e8e", + "0xb9a7fa3b7b5b9da3469420f2d9c4c74da6b2dea922f5543ccc924907c91aaa0f", + "0x60dd57debe01b07f2150f54d637bd8f574df12ac003a445ad012509f5b619671", + "0x966715df220dfbe5e11392b257b61b64c18178d1825b654f95f67d7c9558a2a2", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD9cfab54f1234AeEA22B2818AB919866A2809c1C": { + "index": 795, + "amount": "0x02", + "proof": [ + "0x799119c9bbf074a9c68aa02fde52cf353745d220a1ad0b292fce9b7b157b5c51", + "0x2fe684787ccf096a7b31fa11ca1398833b41c4ca2aa704e9d631ab3fd35a24bd", + "0xc2cd45a5ba91a5bddaf5f5a2e4e6330f109e68b673e248effe74f853055b5f9d", + "0x81cb79cde32d282b43e0e438fe2b6758f17fd2d569d10c780c800d4c492134d6", + "0xe2050f6c95c616c1cfdb04f4b6d0afb5afa0fb464f767c38aba0f07df915a97f", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xD9d3414FbFD1fda594a9295580e47a37B706BA4C": { + "index": 796, + "amount": "0x01", + "proof": [ + "0x1172e912dd7d54997de847645b5bc48c2452f999bdf3a6fe2d58f67d966a1adc", + "0xd5ab2d73f80cd82ad1b08edaad38e39abb311ee0e5f6604a36bea3e348789028", + "0x845cc84318cf86b31a866d4991f68f70ae915279f96750b537b675397281505c", + "0xdcab737bf32fe2edc99f37725a5c46b3f4c2b142298388f08a1bc983981697d3", + "0x6431c24d3d46ea6b0d1959c0de03265dc474d3e67139f2bedca26b5aab0c0c5b", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xDBFB0e80143dd737e04925fFd7AF8C355c0d25F9": { + "index": 797, + "amount": "0x01", + "proof": [ + "0xa69823e9777a39d181771a9d2c250510f688a8308dbd2853c82262a2cd94cf1a", + "0x699e30c44e6749aec3e313644e66b04a345a9f0a09b33e149fd580b8543fd5e9", + "0x749ec840687b0c3028d9ebbc2bee7d5e4b09957fcc6d0764cc748253b597e007", + "0xff4bbb2da92e4f9e24f8d79cfebe3e93428702c14b9f4cc9993761fab9d19c9a", + "0x59d5a4275936eb4dfca0d17bab02b4a25bd4dc43ef3aa0e3515a07f7c0f68a93", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xDD0DDAd1cA7B57aCAc3E1eD2ceAC6ebC5526431a": { + "index": 798, + "amount": "0x02", + "proof": [ + "0x8d96aa165f50911f79b089f7f4c0245dfddf1e520812c3a819017aa4c79a430c", + "0x52d97e18c6ecd74ae787f920c503bcb0c610d6485e034834edc41ab4343024ec", + "0xe0327321894dc1feb38e3fe36a354623f4288831a6705367168694406a92d9af", + "0x7217bacc0b5fadfdc27aef27f3baae246ba909c02961594a63bb24f24958cc4c", + "0x8fbc13f50b0f82a781945a74ddd5c5abde0b4a8983852c66ecda77a68df50722", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xDF900B0638107680f4D31A7DAA28c9A3a64e30C0": { + "index": 799, + "amount": "0x02", + "proof": [ + "0x2ddfdc006514b2b171eae8d4a79286ddd93294f21611790c1919cb6a6ec0eb21", + "0xe2426c24b394b169d07d68462d6d6d52a3ee51c08ed5371353a8d28def069712", + "0xd7c1a15b710f86aade261c04d27fec83ac6b798b76f86972e953c8642432c14f", + "0x9e8ae6c0c829ef47f1fdcf07618192e842b30fccb4c38a8af79f05f97c75c097", + "0x4325701890e79e85b41231157c1ced07357ce871ed6fb4f233c2f82c38bcf4bb", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xDFedDc98ae6eDcb5F63178A8589f41B6477F6C42": { + "index": 800, + "amount": "0x01", + "proof": [ + "0xad372b1376c87cb07ac9a5b666088229044b62c2afa5d9fce83b4a189f095068", + "0x05a502a53d1b07fe2bed7d2b2c4a37e626b6fb6cbc1751fedada4af414510237", + "0xd7ee782e7b8b92e8ee009d7874df94ca08040bfb250a415f26b44bde9008b154", + "0xf685abad756fc52292f02befc3f5465de8d8f16cce61117b3f5de4fc38a60819", + "0xa952d1dc401036dd357d470bb699a7e9cfc64f0caf6dc51a638cd2487f5e73fb", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xDa6F04DA05D4c6644b2923dCeF66F588De5dCa40": { + "index": 801, + "amount": "0x01", + "proof": [ + "0xcdcb221e0cabc8527b1cfbe73f2541c4f5cd53b7050eeffd447089f6f1b7e68f", + "0x1f342de2928cc7674f737763ca390af80258c8a948b47cc6218acc2dabf34851", + "0xe8a6478d83d6e44010f2e45c5e73a005e8a6798d300da5af9760a1a7319a59f2", + "0xef33e9da5226ecbab5796a616b47d5f4223c729722fba46a5cf043b7bdc381ce", + "0x2e78635a0ed4a14dadd872d564c5dd2afc4f21b0307932d27d4471c48082b7f3", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xDaeDbDdaC9B3cB88d163271C851Ad8564E12Bf82": { + "index": 802, + "amount": "0x06", + "proof": [ + "0xcd351b180f196fd2e21c44d58774d6e617c3025ee4e2bb8c116c9b123ac5875e", + "0xa9ab7a810e9efa28245ab6cd8c9cfc6865cf4e6eaec31c0760739c529377b269", + "0x80afd91747cf4aadcd0a9bfc4df210ea0e0b85434282ec9bee91d7d5f9165218", + "0xef33e9da5226ecbab5796a616b47d5f4223c729722fba46a5cf043b7bdc381ce", + "0x2e78635a0ed4a14dadd872d564c5dd2afc4f21b0307932d27d4471c48082b7f3", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xDc9a2EC181F287c7aCc6FFb4aBDf5ba5109d9E07": { + "index": 803, + "amount": "0x01", + "proof": [ + "0xf726052e6f84dbb8a70897bbbc6027ed0b4952fa29dbb09c7c6109a715b94f55", + "0xe5e69b49e6302f27370b2714452d7178b7e8283ad7f2d32aea38c0f82aa11448", + "0xb68e26a6daede6ed892cd902fb2f19d6f490fcf8f0dc6a9c1fc42e9c75cb8ce9", + "0x11f5a22099e6617cfb9a813c15cac667d29fe00a5f0d1618572f9c1368ac6385", + "0x8e7f75ccc4d864471b1a7ec71efa29a4e8cc4761c26a6987c8043d9ca642a2a0", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0xDcC80419783982EaB77e7BB82d57CEb04B899bb2": { + "index": 804, + "amount": "0x01", + "proof": [ + "0x0cd6197c23b37918b343f60a915577acc6401f87db66c74ff0016c90c9fb9424", + "0x8682d699b4b1fae82553ca6d03c7e4554aa9e2a6839dc9d70506ef88a7a00695", + "0x1ac17eae005e68d333e431b1be274794132926bcec9fd36924d6e7e39904133c", + "0x979cc6c181e08190bb233f0cf5b0f7b487d9aadc675c9326a9af9732d3369d45", + "0x4a36dc66177a8394f6b14fc9adbe4ad7e0cc2dead6acb72d80990e336fef8d45", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xDd3541B99Fa7d65dD1DA1653b87B2483e7cD6a00": { + "index": 805, + "amount": "0x01", + "proof": [ + "0x307e2304d0d873d138be2dbaa408105e2e76efcdb26b04ea661e75b812706d66", + "0x18670715cedd004222eff8ed92839622a139cb89a9a1ad0d61ac57d1d8ca178a", + "0x877e3afc33780706a52d195b5d99278bc7864ecda90d6ce301c78748b13247db", + "0x7fb8279a3bf6834ff5de6f30e4ebf74889d64cf70547e9c78a27d7fd86516478", + "0x4325701890e79e85b41231157c1ced07357ce871ed6fb4f233c2f82c38bcf4bb", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xDe6b2a06407575B98724818445178C1f5fD53361": { + "index": 806, + "amount": "0x10", + "proof": [ + "0x5e4d0b949ba592fcc71e0a4b37ed21809bb744c91323222cbce93cc33b680f8e", + "0x6fc7c8af509151e1cbb2b27c3a61e6ef14f892ba565b0a9f88eb86f3adef9a8b", + "0x392e4357413d2c40440f7c7366dd2b7e4169a71d8580214634fe41a4c322d037", + "0x70db17f5bfc52cce1e5c71a7571d4c960efb51e88d7fc8b1162dd074c38f333e", + "0xdfdb156cb5d2b90a5253163570fe08739b17ab3fc383c79eb041c1d1a667fe84", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xDe8589960DA34eeFB00Ca879D8CC12B11F52Cb12": { + "index": 807, + "amount": "0x01", + "proof": [ + "0xcc35a608f8d8c108a143f8536d9e4bce20bf45edc9e04a398197411f0fdf2c24", + "0x100c90050d686ceef1ea638893036da3b576b84dfdad93442b36888a87b33aaa", + "0x283f3fb0109ecec757290961e9c3e0c9092dd7697857daa95c6c89647800e706", + "0x9bd1c3205e48cecbaefedf96e5d998ea4bb84adb658c966bfa31e3599a4a0ea7", + "0x2e78635a0ed4a14dadd872d564c5dd2afc4f21b0307932d27d4471c48082b7f3", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xDeAdb8d2878EffDb9886520ee84b6f26E46EAFB4": { + "index": 808, + "amount": "0x02", + "proof": [ + "0x8e183be08f5a64274e228a3d558e9a59c9d125f8e60c08c897cc44ae868cc4c2", + "0x2ef90a79596d02d1b760abfd4fee820b144bef7c0323bac4c9d032212a6c2907", + "0xdf6cc73a467552881abcfe25d30eb0b4a6ee65fb03e1f816f4e39315a3ce78bf", + "0x7217bacc0b5fadfdc27aef27f3baae246ba909c02961594a63bb24f24958cc4c", + "0x8fbc13f50b0f82a781945a74ddd5c5abde0b4a8983852c66ecda77a68df50722", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xE01f94F635028394cB15B572179DaEbbfC231761": { + "index": 809, + "amount": "0x01", + "proof": [ + "0xab17fc20c89b25cc52c1093486259a759991c0abddb2e9a126bafe779b95b8ad", + "0xa15e189886ddcb5c066beb8935e0591ef17452ba42bc2af450f5eef9545795b5", + "0x8d09decc88251c44f7a49a4b85d4449eb023b2742a6cd38b9c5de1b9936589c6", + "0xd7f4836e54488e91267fda42072073873c17b5d47a5a1cb5374c07d89c92ff21", + "0x32636a5315ca425c602832f925f24426ea5aec9939c73d1b2a6fcdace85ecae8", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xE3782B93FaC19BcFb2209b72D406380b569b89d9": { + "index": 810, + "amount": "0x01", + "proof": [ + "0x7a215fcb89b52b485b9d58a26b9d9f407a3034e002ec1b8fdff3e38cc2812c4f", + "0x65aa36556359ae164c529dc578c2336c35b88a8f9ba2ca015c081db3fd0ff159", + "0x4c323856e3ed5872317143e057e5eb0b9c02e5efcad37c36801f077d7c535fbf", + "0x81cb79cde32d282b43e0e438fe2b6758f17fd2d569d10c780c800d4c492134d6", + "0xe2050f6c95c616c1cfdb04f4b6d0afb5afa0fb464f767c38aba0f07df915a97f", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xE3939654Deae5f54fD3e6B84b3A7F75f245062d8": { + "index": 811, + "amount": "0x02", + "proof": [ + "0x35fe3da8ae6e659be5a961d3751b66054688187e240f5b120e4df8217a78f9f4", + "0x27b230430b5697097df335836ea1f5ac32a0e386cc383cdff7d28ca614eb1bbf", + "0xb4e3d624b4c9069a7dbee8548a7744c0c011fbd5381a1988549f867ddd3672a7", + "0xedd365a7e73c5a47a076899344b760df86cdab5eb6566dcce5b550be9bbb5324", + "0x963cc7ad3f8f0ded379d05906b629df8cc616633784013c90731955d0b0736d8", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xE3f892174190b3F0Fa502Eb84c8208c7c0998c50": { + "index": 812, + "amount": "0x05", + "proof": [ + "0x658b8fb3cbd99cf20cc4d9e1280cf83e993c488494d60ac2248dee9f38e93eb9", + "0x9d3379dd89b837e80d954d49a78363365ad7ca622608809cb18a5a2d20375148", + "0xcea7df5853c7450e538101f09c77eec6b3f2998d90e30a8070f1e3c1de4cd6b0", + "0xd2ab54f5e70cde7ed6caa9591ebf0def0ee5d532bfbf38a4473c6ff488c1d82b", + "0xfe7d73c06bd76d1271e4b772b51e13505a812b7c919129debfd7d15fb5014d16", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xE510058152640c40266D910eEA4c42bf58ceD7f2": { + "index": 813, + "amount": "0x01", + "proof": [ + "0x2e30c9aef42797484072b11aab4a32c1f02bbfb8680ace82949612971bcbcecd", + "0x1252bb08b28cd71d6c402ca3373c01f44f8f36825248c5f0a85d4e5c4a5cbe8e", + "0xd7c1a15b710f86aade261c04d27fec83ac6b798b76f86972e953c8642432c14f", + "0x9e8ae6c0c829ef47f1fdcf07618192e842b30fccb4c38a8af79f05f97c75c097", + "0x4325701890e79e85b41231157c1ced07357ce871ed6fb4f233c2f82c38bcf4bb", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xE52436fC77186101FCc92bbA1735D153daaE9aed": { + "index": 814, + "amount": "0x01", + "proof": [ + "0x67ff29b4c5e261470bf09e32e48e0d0aa33b166d51648aa67017924f082662f6", + "0x97c4a13ef90643fc14b83e447b6db03e2c2dbb64f17fdb9b0d3f7a47b8de3e36", + "0x12739444750a786d216e7862d022a412d833ffcaf4cf4f6b1414e14f4ff27db5", + "0x5fee000564bb97bedb499d3b5c01f147f4e4ad76f5f6443565804721f95dcda3", + "0x245190f95f5e09d43d1da7e9757fa066be1942b52f7e4962cbbe6a5f2e0981bc", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xE52eF21875615682dc5Fa75D6a33a546e200f5f6": { + "index": 815, + "amount": "0x01", + "proof": [ + "0x64936d1f72b9474031006f877bc2054a93592037a16b364cf8041bb4631a4cc6", + "0x5844cb72495f4fca3d8067551b02520bc93ecd7253d2b23394cd0848326b47d2", + "0xbb9d492cdff2f5113de60e7e37bb69fd0a5139cac96538ff8fefb20c479105bf", + "0xd2ab54f5e70cde7ed6caa9591ebf0def0ee5d532bfbf38a4473c6ff488c1d82b", + "0xfe7d73c06bd76d1271e4b772b51e13505a812b7c919129debfd7d15fb5014d16", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xE54795c2c07bd8fA4fcD2fF853AACFa9d609B814": { + "index": 816, + "amount": "0x02", + "proof": [ + "0x2bca74f1f850d4df096db44d9c7d638026051fc1223298ca96a81e118c78a50b", + "0xab5b019169f5ab38f7196d7cd6c96fe89ca012f385ef7d24412c29193bb860fe", + "0x4463b6536e661f9a88a746064d45ba478e857effdf8bd2e7636f7fd61b93acaa", + "0x71674724de34865e988a846825d9f937ca48ef7322279591194ca7d40d8ee995", + "0xa43a1be4a3c4bbd4e28425f3172d3522b7e954d7cf0fc72a26d8ba7bea25f197", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xE54FfbD968f803a704e74b983bF448F2C76902a6": { + "index": 817, + "amount": "0x01", + "proof": [ + "0x5868543f4295661056b185177d59e401d89181c193800e740d7c8e2ea9134531", + "0x3863e91deb132a16fcb6977c0a9dfb96b8b531f2e35f96dcb9343757a7429e31", + "0x136170c6f928bfc56e43011f019f3a590b74ac414acde4927d918d53fd5e8ef8", + "0x5190cb032ba95080f88929faf2eabe8bd342a53206176fd2c3afcbef4577ab71", + "0xf9f105f90db6fe2970fb4e03b35654f9b69375879c783d3f1700e04b2e2f925b", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xE5B314Fa02F366B136685Ef322a91586EF2364De": { + "index": 818, + "amount": "0x01", + "proof": [ + "0xc3fe5e0b7196ac821d8cfed5dc167bb4edfdcb0629789bc896c14636983540e6", + "0xbe1532c87a477a9dd8d5ec50bdeabebfcdd9e1db4c63bc1875ae71798041f854", + "0xad348b0f72a246f9ea29f8876073a3c8a866ef71430904c9f0114b6bd4631fb6", + "0x65c5caf7f221e805a211309d005cab013498255a9343870184292835ae911371", + "0xcf22c1d43a94c7c6471efe1209a3b103ec0a9836b6c11fe8d2e98d18b2e9cb36", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xE5D12B67755d2d68Dd69821fed9d7cC9c92fEf33": { + "index": 819, + "amount": "0x01", + "proof": [ + "0xc908b3caf8538de2faa66d9be045783854da17a3eae2104cfecdc829c85e501f", + "0xc8c7b3b0ecdba6665a7605b904bec7c7da98c3aa20cd783dc262daadd15cc021", + "0xbbe257abf6239029d7b9473e959941b7ffd9cc84496254335d553ed2f9334fd2", + "0x1f4f9d2e01bb8c804693d53134cf046798ee2607f0aa015ff42b474e23cf7ed2", + "0x97fbe90108c9d6db20d511e4419e4ed044f589ef1f2a9f6539187bad21502f90", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xE5E1DAf68eadca9dd55D57cb355839010c06c69b": { + "index": 820, + "amount": "0x01", + "proof": [ + "0xa6af86778653beadf05460a0105312d27f15196ca0c56e3d3858a426187775fb", + "0x699e30c44e6749aec3e313644e66b04a345a9f0a09b33e149fd580b8543fd5e9", + "0x749ec840687b0c3028d9ebbc2bee7d5e4b09957fcc6d0764cc748253b597e007", + "0xff4bbb2da92e4f9e24f8d79cfebe3e93428702c14b9f4cc9993761fab9d19c9a", + "0x59d5a4275936eb4dfca0d17bab02b4a25bd4dc43ef3aa0e3515a07f7c0f68a93", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xE5e58Cf23a648dC2ba89355d76e04Dc2869BE98D": { + "index": 821, + "amount": "0x01", + "proof": [ + "0x5f7a699f23ff9f679a2d942e0e26b014f64262b5a6e435d241f920791a8157a6", + "0x67791dcb4b866491f2d6208a6071883bf8999654049486544c9a5540e6391435", + "0x235df6c4bfff7e5ae5051713ca9a7dc5664282cfc88bace4488c612d23aaec19", + "0x70db17f5bfc52cce1e5c71a7571d4c960efb51e88d7fc8b1162dd074c38f333e", + "0xdfdb156cb5d2b90a5253163570fe08739b17ab3fc383c79eb041c1d1a667fe84", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xE65cEE7B4C759bC1857414557b232884e7412EBE": { + "index": 822, + "amount": "0x01", + "proof": [ + "0x1896733521dec3f9c073d261dcbc6dde86171397510d88e92ac98627f803ee0d", + "0xadccb699b553a9eb87afcfa8bbdba744ed39f16591a1e3c3b3dde43b861f87c3", + "0xf9aa43102404b84f14eba6125f677ccda1d14a7d5704168958698912672e9e8b", + "0x9259974d28cfc23eade84b4a12eba89f4b5d3b0064ca7ad3dcf3a6a6a2555c91", + "0x93994074bdd819d668a79fc2c79be23cb074a679cd3fe03940945d4c6f9fa9b3", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xE672e3403732e6bFf2c36209E6dbd3A63dc0eF61": { + "index": 823, + "amount": "0x01", + "proof": [ + "0xbee7f1a34e1ba3555ac7a09ea2e8111be308945bb7f3b85bac9748eaf3fe89e2", + "0xc13a59afb72f6b99e40d7476264dfdfb0bfb8e74edba3803b60e51694c5d9e64", + "0xb8ba31195c91c8c313866172aa3210fabaf1ae5dc11c67181101d637d0e73050", + "0xde546e8389f64cf158f6546ecf18f3c473b0c5660810c1eba849db699f2c4883", + "0xbd7abdce9ec414fe47ea73146a2131622bdacb914ea6353abee1b0a149275092", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xE8149B815388948db4ad05680fFf1145e0975C7d": { + "index": 824, + "amount": "0x01", + "proof": [ + "0xbe628207c50e7d105b901cc450f26def745d566473a60dcd3159d69c0b547a81", + "0x414bbbb883d903a8f82d7965dacc34f2cf3fd42e7c76c5d9433f028fb5515d8a", + "0x81438df7a27c7be027c254bdd75d2f0fd663816eed20147a4ff92559013874ae", + "0xde546e8389f64cf158f6546ecf18f3c473b0c5660810c1eba849db699f2c4883", + "0xbd7abdce9ec414fe47ea73146a2131622bdacb914ea6353abee1b0a149275092", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xE849C585Fb1711aCa53d880f99Fa0B2c77452078": { + "index": 825, + "amount": "0x03", + "proof": [ + "0x4aacce42db96e72009effde2be23ceac37816cebf9745f81892f1e3990e0cb49", + "0x20d7a712dc0ca54759ff1126b0cbdca4cbad34e2490974d006f14d8449942ac4", + "0xf51571a8d5447a22467ef7675b2c9fdf62254f3d4938a09245fc084f4e588343", + "0xf94cc4240e18301aa3e9325f55d6ec2e2e84a181037fd49b69a29a1aedce082c", + "0x43f59a603c2458850547e5a84d47e61be843b4a3c814303ed1b52e1e4d37a1b5", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xE867d7b38DE80B7be24EcB9bBB2F7c4564BeE5Dd": { + "index": 826, + "amount": "0x01", + "proof": [ + "0xee29447823a7bd326622a3db179d56967d4083c6139c76dcd105000f5f8295f9", + "0x5246e03ede7c4f11729527196e0ca2938b6a5d1248a0f39c4ec3f76e4095df7c", + "0x0f1c6c7aaffd63c4e9f25ab9cced8d3f13972b255c9fce8cf940b54f7722fafc", + "0x88222db835a579969caf99eebc6d7f986a78bc44f46b794a4319d01749c83a2e", + "0x6e496426985c92b04963088da4856230c781a975dbb5ce2d8eed77e7d2d4b58e", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xE97a8888C89951ED4567d61FbcA8a6c6C7E762c2": { + "index": 827, + "amount": "0x01", + "proof": [ + "0x3d813c0318f4a76381c6de7d1caba5659a356277ecb64dfcf8e2cacb93550c98", + "0xc08ca60352ddd810165535a8fdaf0147da6f7ad444c5957a1ed0cd91c475a172", + "0x9bbb60a5fc709695e163323f3a6b2381dd7005d331356c8315cc8d38b4d9cbdb", + "0xaf86f597317f3202fff25068896658613bc0cbf9d7a66fd51e55c97f2358b8ee", + "0xb5bb98883f5ea232108866e1400cd4067f34fc2d70605fd2c67051a6095af7f8", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xEB79561A4Ccd197941B40FC6625Ffe3b47920f08": { + "index": 828, + "amount": "0x01", + "proof": [ + "0x78a10323f20a738095db1ba4bc7fd1d3d0dd65b2f8194f74a2c979abad469949", + "0xd7f214ca7ca4b7f3eeda982d1033c6c109dd9327a692fd65ffa8f185241e3b5f", + "0x430e9eec036c03066fc0319049daaa271c11c2e68b105a49cf5a3f241fa703d0", + "0x9b12cab9303ffdb5818321d84969747034ab90e273c8fb6d0031d1f6e3e1f83c", + "0x80cf615f05f15e9ed665dd7df5d086fcb70ed5a5086e02db7c08752fcaab6507", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xEC46DD165eE2D4aF460a9c3d01B5A4C9516C9c3F": { + "index": 829, + "amount": "0x01", + "proof": [ + "0xfc6f5227981e4b40fba0f063854c05c53dc8f021ac44837c511bfa7152759d3a", + "0x53f2003067f80e2b869e2ccb7123e5d153eeaeb600680ee6aaaa39ae2590b1b2", + "0x31f79c83b956e018904202cf4279226136341311c37e609a94eae5d4c39d8942", + "0xf7b15c813ccb2cfda0fad7314544180ed758b3ac0213d482dfeb48697c2a487a", + "0x938890418edfff03e5d8f0abce65769ab79b16db349d2869a477500717305360", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0xEE6021EaedFd72d791ceED89f191F6913cb641C6": { + "index": 830, + "amount": "0x01", + "proof": [ + "0x0ac2688b825b7ca3fa9e56048ee8787576dbfa96664d07496a4315eb5fe83965", + "0x306a8cb80a4fa105c174f23a915a866242d63632d3e7c3a81d8040f1b2bae200", + "0xb1717c21808d3d48c3df9715b61089ddd54dbf21e63f04ad434821ef229b5e7b", + "0xc50cae5631fa8cafae8224329322dbaebc117b278a8e07f29104d255198d88a8", + "0x4a36dc66177a8394f6b14fc9adbe4ad7e0cc2dead6acb72d80990e336fef8d45", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xEE622122BC71Ee46285C3BbD36E0F134a7271c85": { + "index": 831, + "amount": "0x07", + "proof": [ + "0x93d672e75b3e056e45aa6bb167dd066db4d368876e2a334dd7d28e17db25a726", + "0x74c533b7fa0735fd933986ca7fe1ccfd029b4c093241467a5c239155dc1a54cc", + "0x75bfc221d8f7e7fad04c48ba5ad53c5e62ff5db03c3799cd4e3b45e76de5d2c9", + "0x6ebf988ef586adc2237357c1611e0a6bf7170af1257d42fb6ef98df1f5052439", + "0xea7c0076ebef0c429d544548828ff19d5600136801cc28845bdfa9990d97a058", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xEF3E33334851212b4Ebe16601e5adBE5afA0103A": { + "index": 832, + "amount": "0x01", + "proof": [ + "0x58ee075eca2f5290bbc4621a7751018b134ae2350b1a8885dbf6ea05903ee061", + "0xafa897eb3992378b60da47cce9d93aaf41c389cf48f7bdce168e37187933cdc8", + "0x7c23f4640cb3e1bbc8e7fda85d8fe777fabe673ab4467b36de7f64c25eef8b5f", + "0x5190cb032ba95080f88929faf2eabe8bd342a53206176fd2c3afcbef4577ab71", + "0xf9f105f90db6fe2970fb4e03b35654f9b69375879c783d3f1700e04b2e2f925b", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xEFde6a97AF618AD407211C3D5d494BC257948208": { + "index": 833, + "amount": "0x02", + "proof": [ + "0x3a4c48ea4990b41f3adb428c0c7ca5f72a30b324ee865c001c02568c0ded4a2c", + "0x14dcb65260e6e607a3d88629c0bfdfd1ae9b5b3d32cdf226c99fb0a49e010a29", + "0xf40d9321096b33fe11dd3bb5f540443ccc3463fb86ca7e96dbab2cdec392fead", + "0x60583de8b96cf21d7bf97a30f8f28bb928ffecf01373b007ee5bfa1bb5a1f776", + "0xdc998377cfbadb1c2d77196acc69c259bcfcc6de58df7f5aeea2780a288f2509", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xEbCD54d901596cE65fa504D96A397E8463d6262d": { + "index": 834, + "amount": "0x01", + "proof": [ + "0x2942e7e0d7591993b188c6a2408aa187aa2293aa3e30db7e8ee4536cf25b7577", + "0x29bdd026c94c93d3f0d201334bedf4443413e2d5823a8fe03af99efb02da7b92", + "0xc62b818bd2a34acad67723e97f8667eec6de397168029a2670ec2681852c4b26", + "0x1ff461854683a34317216055e65b6637346912d1739163d25c1a0b0a5f15c25d", + "0xe29ba79106b7b14c14912bb5fba509f27997ddbe5a7ebc941fa75e3475af4aef", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xEbb42EB7e42e8E7a007f766933fF2709C90FAD45": { + "index": 835, + "amount": "0x05", + "proof": [ + "0x6377cc65c8e921760d18e438e7777937cfe4311ee5717d5d7028a888ab035fd6", + "0x38af04c973fe8191b047e98c184615862817dcd1e5b530e747e2ab3e1e691325", + "0xafc939acce9fa59fdef6399379f0c2e101cdd8d5bc66ed4c1d5bbcb5fd709886", + "0x22784474cee51afee6127b1f3fb642ff75cdb40aeb505017bf6b1a1162a44c35", + "0xfe7d73c06bd76d1271e4b772b51e13505a812b7c919129debfd7d15fb5014d16", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xEcB50F1F8098F3D62FB5d8A1fE0fe8b5def621Fa": { + "index": 836, + "amount": "0x03", + "proof": [ + "0xc76b0fa8d64083a67423881bf42012fe1530639e3423e7be8fbdc9bfc804c0e4", + "0x43beb4795c28b95c64d9e451dd152e82eab265ba25c79b9c00c5017c77c0919d", + "0x28953c726ef8579e21b5a30c7fb4f81f31e6a2af517a1f8948b50dc1a62e1f25", + "0x99930015299a0435807ebbffcd0957a02cf6631c31c05ff8ed9a165cfa4bf8e6", + "0xcf22c1d43a94c7c6471efe1209a3b103ec0a9836b6c11fe8d2e98d18b2e9cb36", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xEdb54d30F854212063f5134a97616B7Af997C043": { + "index": 837, + "amount": "0x01", + "proof": [ + "0xe25a59af3910d3ceb94cc37c515c702a40b614d4da688da1af18e26ce4a801c0", + "0x30074ee218e0b71dc7c293c02d1466bc7409e5bd7a2ef3059c4c0f5f785f95d0", + "0xe245c0cfce194010f5d1ba4d1e2acebcbce7ee3beb09abd2da7ac09a58a6c76a", + "0x1bd24f0c1d9a337a197e1feb80905be5821f1e64457aba030d18aca78646a08c", + "0x7968b2383e3b914ab3a36580b205f1449b51563630c77871f712e94743e3bf39", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xF00Bf178E3372C4eF6E15A1676fd770DAD2aDdfB": { + "index": 838, + "amount": "0x01", + "proof": [ + "0x247bf946675833b1e709eaf92c45c465908bce1aa0d654801422ede56141ec69", + "0xf77691e03e1ebfef88f8eb0b17594ebe75d4efb92ca74bea3e486c60d796e669", + "0xcf959dc22eda4cc1f43407713b0939306c53472c1295a5b191e90fd79f98d755", + "0x4b1c846f0a8bc448aead7f2cfec46ac450b23d2f229b5350dd63009a82a1dccf", + "0xe29ba79106b7b14c14912bb5fba509f27997ddbe5a7ebc941fa75e3475af4aef", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xF058d89c974C2A8b4f38CbB05901Cfa055091fC3": { + "index": 839, + "amount": "0x01", + "proof": [ + "0x383808ce9b33609e97ae45ec287ed6799b1012309243964b68ff6ed4d92171c1", + "0xdf3a8571dbd4b3486be86fdd95d51d6597479efca978e36d91f63ce8ccb25aab", + "0x96659af2623f9d5820946e88ce636546f77239bf7c47b826a73c1355654c5cdc", + "0x26d5243ad79c6ff0365171b12c8ef795d8c977a57cace1265e53f8b7326c312f", + "0xdc998377cfbadb1c2d77196acc69c259bcfcc6de58df7f5aeea2780a288f2509", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xF0F32C3c8DEf7b43caA14fEd5752AbC5381C8374": { + "index": 840, + "amount": "0x01", + "proof": [ + "0x29f02edfed680143b64f531053be9a3da56c34cc408eb6da9f885a435eef1a72", + "0x4573eb1c35530489869195138b9a3b567e6c964371a1908199f3320878c6c1c8", + "0x76ac0e61f5fb8527ae23175c183589d51da559dacc49211473b64d81eabda65c", + "0x36710d40c48dd22c4c23311fe2998a569fb56756df4d8eda7bf12408489aed56", + "0xa43a1be4a3c4bbd4e28425f3172d3522b7e954d7cf0fc72a26d8ba7bea25f197", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xF17Df1DfC97A121159E0f816Cd74ad01B47D1469": { + "index": 841, + "amount": "0x01", + "proof": [ + "0xccb3303fc0dc8c1aef33f1168a93110bd1cc950cb6878a029f4ccfb66659f473", + "0x31f76a6505bf96c91720a067f25fa54ed53ee8f7085494c0546bbc204fe10c46", + "0x283f3fb0109ecec757290961e9c3e0c9092dd7697857daa95c6c89647800e706", + "0x9bd1c3205e48cecbaefedf96e5d998ea4bb84adb658c966bfa31e3599a4a0ea7", + "0x2e78635a0ed4a14dadd872d564c5dd2afc4f21b0307932d27d4471c48082b7f3", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xF17FE1018A7B67B4aA2c529d765F648861668E12": { + "index": 842, + "amount": "0x01", + "proof": [ + "0xd082f32202d153e8ddb71389285e63267991ba635c5d738dff55970c0ee92589", + "0xc1b89b474544b6e6adcdc933653bf7c223d6d679e1ef42967df729937e28d7eb", + "0xda6a400b1d206393ae5c21fe289d6b139252aa072673d47cca7709e41439c7e9", + "0xcea68af505202af90a0679269376e373d9ceca250970bcb6953e0f30f5dcfc7d", + "0x85ada07677b521b0dd2e0d60f51f92f7b1217f46e36379a5afa5a74fd5c87a5a", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xF2052f01d4E750542f54562D17d23d17380FBA29": { + "index": 843, + "amount": "0x01", + "proof": [ + "0x6c872b84553f630d39a115a9eeeddb4e20bca27e3c3e4e98fba657c428942d0f", + "0x29171de8e69c0df7038ea595c755f1fb3a103106e457d750228773eaf0b99954", + "0x9d1bc2241ac02056b61650ad7cae67788655e09d14f6f80d511bc28bd1f815ee", + "0x283f6032b7beb32fcc6ac4b21c9941360bce453787f78b6251c38e3890b83a8f", + "0x1be60ce906d0d73954b2e1f2747ea1c9a23db0ad9345fa6801c551f1a39fa5ab", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xF22d91bd4E3319657273534fC3fe0c93c8F9F01d": { + "index": 844, + "amount": "0x01", + "proof": [ + "0x92bbb27583b570892da43a5f8bc83d01117f7c9121a8a6f77a1ccdeacfcb272a", + "0x5942421f32a242b9590366d4604591e357d73486a5442dee6f47c406b8c3f74c", + "0xf7812c617fd43b12d11ba57fd1f9b80022f8cbcc05f057d95b7bb516ebef605c", + "0xeb79377abd71cdb891e1379260c8fb1947760c17e28c7168ccd62f5d772f861a", + "0xea7c0076ebef0c429d544548828ff19d5600136801cc28845bdfa9990d97a058", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xF2398a92aF4619843A08e3C34e5A23918EB4cD5A": { + "index": 845, + "amount": "0x01", + "proof": [ + "0xecc031ba41d6706bc611352b2ceb037aa308fe3b5f9387c84302eacf833854b5", + "0x9979e910cd8412f79c6b818c9df9aa52c33e522ed2f43c9482969eedd52b9449", + "0x0f1c6c7aaffd63c4e9f25ab9cced8d3f13972b255c9fce8cf940b54f7722fafc", + "0x88222db835a579969caf99eebc6d7f986a78bc44f46b794a4319d01749c83a2e", + "0x6e496426985c92b04963088da4856230c781a975dbb5ce2d8eed77e7d2d4b58e", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xF2baa666e9D04e29147353EBa49E9f621990CE24": { + "index": 846, + "amount": "0x02", + "proof": [ + "0x3293b3237ddf65e27ed14d4783e578ee83eddd1bbf4a6e680d7bc52be8ab2f68", + "0x6eb82aca8c25ed06e3730d00db4e59f0b68b528127b4c6f35791f94d58ff3d85", + "0x0cb9cf742e620c55a260b746926eab12f725e11bfe56426413054bc3c2d83746", + "0x721f15749c8ad9759a4a7d682519f25f59a5bf74daab7275c00bac9f0ddc323d", + "0xd6d09ea62a0a0959d8a1f1cbd849b805597a75fe443bbbc4d5e2555bf8225437", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xF312216447aeA92718Bbd0b437175B1d239fe4B5": { + "index": 847, + "amount": "0x01", + "proof": [ + "0xc4900f682c8212e11b5b1b45282043f6e5f18d0eb65715ea34453c108d1cbea7", + "0xa5de5e56fa567b318aa22a6212bbe256c05d18f8c78ae1cad177efc01f132d7c", + "0x1c0c126d67f3347f6eb5a3e70bd23a4f895f18b6418e58068e703bb374301b5f", + "0x99930015299a0435807ebbffcd0957a02cf6631c31c05ff8ed9a165cfa4bf8e6", + "0xcf22c1d43a94c7c6471efe1209a3b103ec0a9836b6c11fe8d2e98d18b2e9cb36", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xF3676Dc97400b23F8b4486D1E360AfCca749FC60": { + "index": 848, + "amount": "0x01", + "proof": [ + "0xd8ae9779a6974a5707a971b83b820caf96a7fbd362a02a6f3a6094561aed91aa", + "0xdb07be86a0e5d42b4e40902901be148f366c533c1de45a64750e06d31ea21108", + "0xe5131f39e8805c0037f27f127ffa4446b615fb4b7a3617c4bc555a5d8c3944ab", + "0x539804c7bf7a9b6235d14df5f64369e5a3ba52daf4ce320d3134eb569c42ebaa", + "0x57a1600e1002b648fc38956dc1d2f34be5ee3f6cf170c73bd27c43b2a01e45db", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xF38D868aA43d4F662C0c1b18950a999828A562ef": { + "index": 849, + "amount": "0x01", + "proof": [ + "0xa6e90ed9ce5ba8f03e77b1d4d856ef8071d4487a0ef17c870e3001e14e79c2ea", + "0x701a70dc7a9d2ffcefdbb1ba00a9f529929c3ce9593a76e5fa4328b4f73e6012", + "0x745fb65ee3248ac54928f37f35bcfa2f7104894c9f61401a249bd637620389c4", + "0xff4bbb2da92e4f9e24f8d79cfebe3e93428702c14b9f4cc9993761fab9d19c9a", + "0x59d5a4275936eb4dfca0d17bab02b4a25bd4dc43ef3aa0e3515a07f7c0f68a93", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xF5E58BaFf94Af88a395e863a9AD4e37649B35D25": { + "index": 850, + "amount": "0x01", + "proof": [ + "0xeed50d536b74239caf2677e914342a18535275c10136726ae5463e35979d5e96", + "0x238cbcd3ce5b90d05a442db0b684759240a8b4865b0b8d86c26c98bd3d538242", + "0xc71ffc537d3b73c4d65d5ec902214853d0ca3a6ef44a38e578c0f12fbc4929f0", + "0xfbd5cea7e1eb5806f6f82efdb0e881576ab386159b1b3ff7402e4bf56a947d8c", + "0x58340ed8edb441d787ada6b1aaf2b1e42912724e1f0f7887cde9253262aa0534", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xF5a9cA279a99365D83c6C744cA5D3e0B87ec060d": { + "index": 851, + "amount": "0x01", + "proof": [ + "0x07bbcbbe23038c961582a61163562ae20c346825b083fdf4c5a6e41f0e6ba5f8", + "0x524e6a9c85a61dcaf3341df604f2c5bd9920ca0fae7e78ddb1feaa128e0292d9", + "0xdae2fa58d07da8c33da0b26d0890a4bf9f3cded6c882ce8613c4097fb454fae7", + "0x7123b37c640e8ecb7e1db656a0f1869aecd392fe2f9511dc671c16401bc54aee", + "0x6e752d8572dc933bdf463f24751c7070d8aa74bb8987a5fe56dee3b0c9f53450", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xF6A6E036a10F0475C16C202C20646b2A54171bb1": { + "index": 852, + "amount": "0x01", + "proof": [ + "0xb8da71cc87a0e2c595ca5e0a00a17b98fd00d859f827c72b2bd1156a449b4e47", + "0x95a6de48685c79f5aa52dfe527186f8004d7a4548c3564e39b823d28c96c48ce", + "0x46523762bcf4ed5e79e15cfe2edb66750ed12adc7f6f405d6e19ee3580efdebd", + "0x4f5594402e5d778ad5cd48b93173f203af8e62306714d707dc5f989e11faa170", + "0x83e262e483a6f2ff9f4df14637dbbdfeddf0c6b0b4ca462c4375d29a3521e052", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xF7A8bC03f8edb6F492ecb7A6282e3617d938D4dd": { + "index": 853, + "amount": "0x01", + "proof": [ + "0xa6bb18f85167467c89c44973a24cea5f188ca25f727665ee3b7e4f8603fa5d49", + "0x8cd44ffa0af5926afeddc98ee0582c4af41ce66b0832085011f5c7946257c0cf", + "0x745fb65ee3248ac54928f37f35bcfa2f7104894c9f61401a249bd637620389c4", + "0xff4bbb2da92e4f9e24f8d79cfebe3e93428702c14b9f4cc9993761fab9d19c9a", + "0x59d5a4275936eb4dfca0d17bab02b4a25bd4dc43ef3aa0e3515a07f7c0f68a93", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xF7B10D603907658F690Da534E9b7dbC4dAB3E2D6": { + "index": 854, + "amount": "0x01", + "proof": [ + "0xc4442811f92d3fb390063e07028db6c57b16f63b1d26fef11323e1e8c53c307e", + "0x01f7621316edcf4eee7e1a0377be2d960e83cfe48ccb0a6567b876ce7b1d1ee0", + "0xad348b0f72a246f9ea29f8876073a3c8a866ef71430904c9f0114b6bd4631fb6", + "0x65c5caf7f221e805a211309d005cab013498255a9343870184292835ae911371", + "0xcf22c1d43a94c7c6471efe1209a3b103ec0a9836b6c11fe8d2e98d18b2e9cb36", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xF7B18e107eb36797f4cE36dE756630B9C30969ad": { + "index": 855, + "amount": "0x02", + "proof": [ + "0x34fa189758de60759db272534b0af202fd8804b54a44244bdb6bb48966e6ef8d", + "0x420ca624a2d053cafd2f9ce85dad8292ef3e30a3d2663979c0455d1a73e3e4b0", + "0x0d061c4a4ee6a211e679a3211e00807beb57846100abc7f5eebc13ff2b92ccdf", + "0x9c7a414e889956f4c85241ac1c103f8242a6795725b10a2a17d9a1d125767087", + "0x963cc7ad3f8f0ded379d05906b629df8cc616633784013c90731955d0b0736d8", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xF844989aB675Cb7Da9F2EAa3d274dFE66C9502ce": { + "index": 856, + "amount": "0x01", + "proof": [ + "0xf45d119bf2a8fe35805bf45386cff78ba637e0b56391c4bd80716d656aa23529", + "0xade8d41148f1cd920291c4dd68b68a72acee43e11b776574010473e9d96ef929", + "0xb0010d722b0a6ca31a164d69fd41792020ef08e55c137f9e16186b7da6a1b655", + "0x3293f41caca9649b5e2565aa9f9ba63bf7c621850061b0b1b6af864bbfb07389", + "0xed5c942adbfa1d9538c55e89e4a7ff4276f908ac558913b5f43dce424bab8e0a", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xF9107317B0fF77eD5b7ADea15e50514A3564002B": { + "index": 857, + "amount": "0x01", + "proof": [ + "0x05a513b0bf692287f4162744f1387e6dcfdee0e87fe6e5850bc3658389b609fe", + "0xe27a53b9b3b393ae2faf4749921dcdf07cfc0f32b6fdef0b5445d41b9f636ce3", + "0x42e42c172851a01dcca036d4a1ac633d24b1e05844cd3c0ddb1534c3c30a1710", + "0x16c0b121292408782518c2e86352704bdaa5fb42c434089ea6fc2adde27ce492", + "0x6e752d8572dc933bdf463f24751c7070d8aa74bb8987a5fe56dee3b0c9f53450", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xF963837cF127d561c8e0c4691ebd5C2E4828c5eE": { + "index": 858, + "amount": "0x01", + "proof": [ + "0xbcb67bdda020e41cb01f2f182feb5abcc196fc468920b9c06c49315b3007344c", + "0xb17e98ce8dad0ddf08271ec2497a3fe0011f9f409537bb4781b30248e5e1845c", + "0x8afb93098421e3e4b6478f7ea0a2cf7b3f942d556afab74785ace4a5071dee41", + "0x3886e44b7873439ef0a83b4119fca7dc640ee0f9551983449d038a076169bb1d", + "0xcf36a9c08620752945fec2c3138a9b0eaede19862d6c5cb3c0489e6ab3a443d3", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xF9Be5602775B96457d6Aed434a31D7E6c6a482Ec": { + "index": 859, + "amount": "0x01", + "proof": [ + "0x81aa386f067f98e38178a6b7083fe1f6776ca77e01b9aa103582d6b4d1158615", + "0x6551e77778689e9477074f8f5acc7acf96e86b0b80626a3ed7a23f2d9b11d85b", + "0x37b7ec084798f5f5573cd70b4c713808bfabeec65ce54db1c9c6e87b7642d9e8", + "0x13c4723f9c83e02f8e5d7f08a17afc4776844c18a0189a9fcccd2702d623254a", + "0x891a74fec62a569bdbcb44171dedc1926c5cbe5d803c0c17ff419a861e9ee5b3", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xFAba10F87e84a8a725a330Dd86618778E8e2Fc14": { + "index": 860, + "amount": "0x01", + "proof": [ + "0xbb9b5c2ccfe552c3f8bde858d9ee99e5958904350f61f2f7ac40cd75f6826028", + "0xe8abdd64909c625ba1ee074a24af6939d962f4e53e9b1e45e3b645ccfbd04fbb", + "0x676a4419b79ede64c5f134c84c12f5fa1724be03db300147c6ce62c8a2747911", + "0xdb334b0b3ac11eef22a51af7bc46c7a633665d404c70629bf6c429ed0b8d1ae6", + "0xcf36a9c08620752945fec2c3138a9b0eaede19862d6c5cb3c0489e6ab3a443d3", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xFE442cB744a92D91fd0850F3383f6f574c6149ee": { + "index": 861, + "amount": "0x01", + "proof": [ + "0x034d7ea29e9721cc20b1cfcf92a057755c4e68b0dd41376b257685ce8dfe1fdb", + "0xe31823e26371ca906b49e20cfa370baab08ff629e6ee6b1211ed6de019ceb4a8", + "0xc9a2fcc0e974df7c3918b7b263d9c6dc39dfe6718696db40d299f59e058f7949", + "0x2be850b7e0b2b6c90dd3488b90e348653e541a9cd2983b235559153dffffe1d2", + "0x9be1155992502d2b75a54fc5b2a41d663a86f7d329faea1befa0e24965b01a56", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xFF6d6Ae87B6431564737834BF733a13aF4B734F4": { + "index": 862, + "amount": "0x02", + "proof": [ + "0x13955ea2856644aa0baf3ed70a0a4b4005a64d06cf70f0318637d71f98a7b09d", + "0xe1254887b3dfac54e0431444b742b3a9343bbb43159e1b34b9fa1d4dac711bed", + "0x5517cea35fc2ef88c454c0abde49cce58c62d4d8057d3493875f1024ae1a58fe", + "0xdcab737bf32fe2edc99f37725a5c46b3f4c2b142298388f08a1bc983981697d3", + "0x6431c24d3d46ea6b0d1959c0de03265dc474d3e67139f2bedca26b5aab0c0c5b", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xFFD2DF7Ba9A04672933748dc86ce71F131ff4D50": { + "index": 863, + "amount": "0x0a", + "proof": [ + "0x313f5b0fb2281807f1375fa545b6071c2178d460789a287cc187e792c1e5acfa", + "0xcbe695b3a12ae5889bef0525be3bebef1f076ae65086879df4d6138e923e0838", + "0x84397224dcf960c935f9f1d840b696834d2c96bc90fb990bf0e58178e4151092", + "0xb74deb44e6419575dd75ff4fb4c2cc26c6f8bccff72ef47a08f3f27e13f3de40", + "0xd6d09ea62a0a0959d8a1f1cbd849b805597a75fe443bbbc4d5e2555bf8225437", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xFaf878dCD715ae2eeffC33183B36a54D48061A16": { + "index": 864, + "amount": "0x01", + "proof": [ + "0xe58451d01e4fe6bf4bfe1599e903abfa93f76135487eaef93f41026288c28fe9", + "0x007c24f2ea2a46e6a4e4dc314f9f0e8555c067ca0a1d40ef84f82eb3e8afc959", + "0x7d7f94570c5fdd54e865230be00712e816eac4c23f4dbf19c8566a21bd0c5b95", + "0x46903c3e0f26b709802c8a2743505337728e1f805b4f936ec91df4b3f43fcdb9", + "0x7a545b345b30e441bb780a4fca731a87b1e941b75518a9983a312194a9e7bd46", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xFbb376D5BA941bdAe7455d17cC8302159e19be02": { + "index": 865, + "amount": "0x01", + "proof": [ + "0x11671bee6db786093c83f7a1fdae69018e392cff6bb91b411649d9456bfe7bd5", + "0x5f6a54776a06cb09b04918db76279c2bcc12f95e05e8549e6539aa9d8c0b9527", + "0x2d080e14bc6209922a0f1386a059fdcb9274a63e7b85c402a8d63fb6bfa35125", + "0x2eb27b26c39f3350831b9042b1a0e6295ae6da1b11f07f10b4a83da8dc66b536", + "0x4bab2069d20a5d1d2f5ebdb61803a57609b7709eca9e925e31a7d14434af1326", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xFbcdE59CfDdB74FE367876400F1B74cE459a2d78": { + "index": 866, + "amount": "0x01", + "proof": [ + "0x5124f670473003fbacf8806f0456bc83e973fca332839266f11f55680fdc80a2", + "0x8b699659068c19c6585703dd41ec909bb6cfd3d4f8696feb9839c594cbbfa5a4", + "0x94ae5af5bdf40e5d21b91608a4452d0ff68fa67ab1aba8eb3e2ef57df1ed7d47", + "0x60ea05c082bde3732ec3daeb0e2bae0395932096e755b1a42d9def3042bddceb", + "0xcc9986a7987738d81db64db86f583aed4fde214b766f55d0f15a876c8f790fb8", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xFbd63B3555F69034Cfd6eEFc3Cf6c7032673cD9c": { + "index": 867, + "amount": "0x01", + "proof": [ + "0x3fecbe6d0d59286382480b985d05c644e76deeb6cae23a4a6308333653802dde", + "0x8fbceccd6e6484920af81c777735be8f05f7ee7b13e0dfbedbf53d52b89f6e35", + "0x8f2a101ee77b78dee9cb982af71dce833445b338ef84d162c17a123bd6df03bd", + "0x2b5ad2a01fbc178584e521e2b2e5c612407bac24dd9bf0c452060b71384720b6", + "0x98ba92b6a1d3418a3c44b684c9f0dc2177f48d3a6b666334d112dacbb6f5acae", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa0f838d02983161EE469bFF969964b7051aC1cD9": { + "index": 868, + "amount": "0x01", + "proof": [ + "0x8ca444c4e3f1ef9ea4bc4a770ab17a2c3110cbc2e8a332f748b1fd7c9d6f89d7", + "0x0b0ff71f23dfe0b91fde49e9139b4ef6ec694f8b542fa2f15e8dbf129181db35", + "0xe1eadcfc59183c7853b885552d4ed0af4a4691e55309e8d127f67718d28a68db", + "0xe04deda4b0f0ea0bda4320a7f8e55700dc470bdcfba68775214ca25f30ccc348", + "0x8fbc13f50b0f82a781945a74ddd5c5abde0b4a8983852c66ecda77a68df50722", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa1A670d5fCD74Dd496a93644c11EB750b18e1526": { + "index": 869, + "amount": "0x01", + "proof": [ + "0xb9ab03fd81773e6f5b889dbb0c5d82c6134613df4240d49a3509e84626f11463", + "0xa3defd41de9e21a5eff42dc10d21461c2c17c7aadc6fe3a007b43bd80b235fc1", + "0x46523762bcf4ed5e79e15cfe2edb66750ed12adc7f6f405d6e19ee3580efdebd", + "0x4f5594402e5d778ad5cd48b93173f203af8e62306714d707dc5f989e11faa170", + "0x83e262e483a6f2ff9f4df14637dbbdfeddf0c6b0b4ca462c4375d29a3521e052", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa1Ae13999DF5740B709af82A727980C113A2527f": { + "index": 870, + "amount": "0x01", + "proof": [ + "0xfbff2ab9196fb3575b1b4e852efa621005a4e9c69e807825aea9656ac1f573ee", + "0xbb9aa2b40da00d58de10b82a81634ab95eb772f61293757de863a2d000c4fb18", + "0xa2bfc6b37e4189ddb762b679e4a5c9ece35447f0664935e074375ef5ac0ce2fd", + "0xa151a98046c68dc4de0dd4ca59fe7fff4ba692aa78310b499e772f0cf61a08d0", + "0x938890418edfff03e5d8f0abce65769ab79b16db349d2869a477500717305360", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0xa1C6bf9a94E603c0C7e0559A9BBe6329137239f7": { + "index": 871, + "amount": "0x01", + "proof": [ + "0x5f3bf4954e6858885f5409242e93a96bdf6c857f83d072f01a0d9514abee12c7", + "0x39e5f351ff4ff104cf70385f930a615df447ffb3d06f0de2535820f8749532b6", + "0x392e4357413d2c40440f7c7366dd2b7e4169a71d8580214634fe41a4c322d037", + "0x70db17f5bfc52cce1e5c71a7571d4c960efb51e88d7fc8b1162dd074c38f333e", + "0xdfdb156cb5d2b90a5253163570fe08739b17ab3fc383c79eb041c1d1a667fe84", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa267F3A4a92531f47811E05E890E977a0fe375b4": { + "index": 872, + "amount": "0x02", + "proof": [ + "0xd5bf912869925c544103990484c185b6aab8373aaf0f02e7b958f75f26d05b0b", + "0x64c7578f5e31fc35001f0ab4fd9b287e89f838cd0845a4494ac79980bf49de22", + "0x19086762fd1965edfc2c6f8d382a94ec7bd76977d80206b5dfe7ff81c35524af", + "0x295b1cb76b1ce79cd1280bb1130a4264534288edb4c264d45d4ab36dd72b36ca", + "0x7e73f337249898d15604f7c330d90e36da04007407404a4b4276d5fe3083b929", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa2D638ADa840080dE73971e49A52EaF00ce18474": { + "index": 873, + "amount": "0x01", + "proof": [ + "0xb058ab79a7e796f8d5d94b9795a5bf83cf42a60a73909939768843c37129ea0a", + "0x8c5b5b4c78db6411d6b7c41f983be165845857a3fb75c15a255d438b99a598f2", + "0x3b785839cd26b611d66f8b353ee5f32ff1026532ac266e55f2864fb32246d378", + "0x577f81e56558cea5cd9d5160218e718fdbd9b124f0dd5499c3e14a238415b645", + "0x72373ecc225af245878bc638c49c8901db1430b7210a3008231acc8f8118d2e0", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa2f632cc085C3604e080E09812658c5696b1A81f": { + "index": 874, + "amount": "0x01", + "proof": [ + "0x2674c18d085cb8a3569637dbbad76c588a90f199d6aca335cfa045353522c30a", + "0xf900254631c40f4321ed12e67f75fb641b07c400bfc53c533428c940162dd04a", + "0x937839ce24bd273187bcd1af0328a690c712a30e57af8e26d0ff2c9c1c709da2", + "0x1ff461854683a34317216055e65b6637346912d1739163d25c1a0b0a5f15c25d", + "0xe29ba79106b7b14c14912bb5fba509f27997ddbe5a7ebc941fa75e3475af4aef", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa3b531037003eaF965D31c2E0eB45Bc41728E45E": { + "index": 875, + "amount": "0x01", + "proof": [ + "0xf74bccc17ee1715de80a6de90a2e5833d4b55843bab01d87c6034d1ca845fe07", + "0x9fb5f4a4bd513d564fa850ee9f32a558bdb7e894dcbf8b67ae342e594b785c7d", + "0xb68e26a6daede6ed892cd902fb2f19d6f490fcf8f0dc6a9c1fc42e9c75cb8ce9", + "0x11f5a22099e6617cfb9a813c15cac667d29fe00a5f0d1618572f9c1368ac6385", + "0x8e7f75ccc4d864471b1a7ec71efa29a4e8cc4761c26a6987c8043d9ca642a2a0", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0xa428556F0e6F32517f7C1723F1f3F917725EFF22": { + "index": 876, + "amount": "0x01", + "proof": [ + "0xfd7d04d30d36300d04b0d2db9e3e63a405e2193bd78f8daa578584e6b857bf32", + "0xe816858884e4df17dc1042a829aa4cc127d6b9762732d895ee3207db7d089a5c", + "0xa7b1364c89574d145647fe0631d469a646bcc060519ae25e959ecafa4f17d9bd", + "0xf7b15c813ccb2cfda0fad7314544180ed758b3ac0213d482dfeb48697c2a487a", + "0x938890418edfff03e5d8f0abce65769ab79b16db349d2869a477500717305360", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0xa4317aB9d7DF7453d8E0853415e04f7e3a78f78F": { + "index": 877, + "amount": "0x01", + "proof": [ + "0x3950e708de62ec5c94ec634321981a63d2f258aeb8cec2745220a2518bd24f23", + "0xd04d7f5208ada5855e94f0d49d4da8da01c7c21e240837ccc6475e67c1ab11db", + "0x159b41098e36945d7d696487556ac5b02e939b80770f9f0ecd41abe3f8314c10", + "0x60583de8b96cf21d7bf97a30f8f28bb928ffecf01373b007ee5bfa1bb5a1f776", + "0xdc998377cfbadb1c2d77196acc69c259bcfcc6de58df7f5aeea2780a288f2509", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa43770859D2DC103E231a4A9aC290e7655aedF84": { + "index": 878, + "amount": "0x01", + "proof": [ + "0xf05fe0fd4f7e0dcea6238318b7dc56dd5690c47738944f9785ec242b4c8c4904", + "0x9cafb886246245c5f1fe460034a0280a3843cc686973b79d943b98337c62627a", + "0x7ec9bc99b06cb88cc17f324af3ce04347d9712a8cde058a864a99e2270fa22c9", + "0x27cae8e1fac7b32e83e85494312638757cf1e0afea8f4e6fe77387c412b4efd6", + "0x58340ed8edb441d787ada6b1aaf2b1e42912724e1f0f7887cde9253262aa0534", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa4E227Aa97a10276B011C7e7B5A5EA5D96BA3B1E": { + "index": 879, + "amount": "0x01", + "proof": [ + "0xdec0cc59c6dd65a8806ab56cf9b2817c53906ffa421517a5f17b008f29fc5bd1", + "0x16b5a68d45bd1b4a0b677c7305fd29d2942d1d93601d756ac76386d36544226c", + "0x1b6e78ed9f82ec1c3081d1383366405b44866f8b35969ff88549384d481f717c", + "0x285f0861eec4fffdb569c07f6f01125414c98685171578e7317ed5b8c16ba373", + "0x966715df220dfbe5e11392b257b61b64c18178d1825b654f95f67d7c9558a2a2", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa502361e69F55bb1F01fC1334EFe9d2c30522f65": { + "index": 880, + "amount": "0x01", + "proof": [ + "0x5ecb7c33435b05eb6cf85a0a7ca25e201360fa9317b583d77594c739e9695c88", + "0x39e5f351ff4ff104cf70385f930a615df447ffb3d06f0de2535820f8749532b6", + "0x392e4357413d2c40440f7c7366dd2b7e4169a71d8580214634fe41a4c322d037", + "0x70db17f5bfc52cce1e5c71a7571d4c960efb51e88d7fc8b1162dd074c38f333e", + "0xdfdb156cb5d2b90a5253163570fe08739b17ab3fc383c79eb041c1d1a667fe84", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa59e113fbef3B4129bAef6b5355dFf683851aFA7": { + "index": 881, + "amount": "0x01", + "proof": [ + "0x19bd4a73300a0ad690d863777576000a29f03eb5f21b3d61be3852d0f9d630c9", + "0x6946ddb2039e1dfab06851980d167442f0ca7610d0fcbd02c31d6a69e793f6ec", + "0x242867d7413fcb0291041584037c07852dc6949a3340933353fcccaf1840148f", + "0x9259974d28cfc23eade84b4a12eba89f4b5d3b0064ca7ad3dcf3a6a6a2555c91", + "0x93994074bdd819d668a79fc2c79be23cb074a679cd3fe03940945d4c6f9fa9b3", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa64d7EE21f4b7230fAEB123d8FD2453583F19092": { + "index": 882, + "amount": "0x01", + "proof": [ + "0x309c2d8997430c8d28daa4a86327fd59fe1a3eef29b99b66e0bf3edae27589a8", + "0x18670715cedd004222eff8ed92839622a139cb89a9a1ad0d61ac57d1d8ca178a", + "0x877e3afc33780706a52d195b5d99278bc7864ecda90d6ce301c78748b13247db", + "0x7fb8279a3bf6834ff5de6f30e4ebf74889d64cf70547e9c78a27d7fd86516478", + "0x4325701890e79e85b41231157c1ced07357ce871ed6fb4f233c2f82c38bcf4bb", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa66B7E13467084f248E7d731eb2f9FF8E43dB1CF": { + "index": 883, + "amount": "0x01", + "proof": [ + "0x1e3162ea83cf8ef3a9dc651bf05beb642d5740c016bcad6272692512a4ea4f79", + "0xe6e3d5d7d65a8285a97cb7f48ca8690869c862c7e5b3a356e4c2195630282403", + "0x02c2372e8c71ba8e5b843247d27450214c544f74b4dd4d34e7ba17d64e09a617", + "0xaaf60b5ecf22563f090c456c87a77833a8ecad31ad25f79ce590acdcb7f64b01", + "0x8e0cc5c13324dce3ab0f042d31a9db04afe0918f70e3f4515f43739791621c97", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa6b6fB6a424f4d107fbdd6F3BCA610B568cCB2EA": { + "index": 884, + "amount": "0x01", + "proof": [ + "0xd022e77bc8671f73fb1334900e993bcaa43715270c28e59b835d6d056f8fb9cc", + "0xc1b89b474544b6e6adcdc933653bf7c223d6d679e1ef42967df729937e28d7eb", + "0xda6a400b1d206393ae5c21fe289d6b139252aa072673d47cca7709e41439c7e9", + "0xcea68af505202af90a0679269376e373d9ceca250970bcb6953e0f30f5dcfc7d", + "0x85ada07677b521b0dd2e0d60f51f92f7b1217f46e36379a5afa5a74fd5c87a5a", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa76A8E68CF6284543D19DA9C12f446ab860cC831": { + "index": 885, + "amount": "0x01", + "proof": [ + "0xadf95299dcd564ea78d3cd3461311c1caca7b54d81fae4c1ecd4f9cd31191690", + "0x04d02269b25155fbc9a34072518480cc8ba1806ee9df4cb2d6e207542bbeefd0", + "0x98dcf697690e69aa965e2413c9bdda9a1af7d0ccf6a569bb34035b0369e22372", + "0x298bc701f239e72f83c6fbd5aa5172caa103b1453ebcf9fd1dfe23628f4dad14", + "0xa952d1dc401036dd357d470bb699a7e9cfc64f0caf6dc51a638cd2487f5e73fb", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa76B3A88dEcbDBa8a392240A275C7Fba434234Af": { + "index": 886, + "amount": "0x01", + "proof": [ + "0x97d7b7d0c5425ad0bdd204e6d37789193fa0bcaa704f1d14de4d344b5036abb2", + "0xd9a4f82d0ecb4a87e98eccc2fe9603a032e2174c62c7237f3c0dec6622d24ec5", + "0xb575a968000894924ae64573326e1018adeabbc274265be52c946debcdd4eeed", + "0xb27289c273000ad0db5ed9acba0b01be05f672a2f40d51317a96231114834c95", + "0x62ba7b58fd554e8be295bf9d4baf9eefd0b518ead5cb8bab321717a08160ae0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa788C59880F31d6a9c3511A8064286682b01756b": { + "index": 887, + "amount": "0x01", + "proof": [ + "0x2c9452634f0b9edb461077f30f96c44dcdd1bbd0f11342f771a1404d5dbaddfb", + "0x55256e5d206f28cd13ee2563bcd663c01134ed0ffbed2cfa249bd7c244949343", + "0x4463b6536e661f9a88a746064d45ba478e857effdf8bd2e7636f7fd61b93acaa", + "0x71674724de34865e988a846825d9f937ca48ef7322279591194ca7d40d8ee995", + "0xa43a1be4a3c4bbd4e28425f3172d3522b7e954d7cf0fc72a26d8ba7bea25f197", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa7F881702b28ECF1838681bC02A4C5553247D232": { + "index": 888, + "amount": "0x01", + "proof": [ + "0xc09acef43596bba111eeb012b1f270155eccfd6e9b2043cce88490c6451446cf", + "0x7d917920580fee841bc99aa999a2a20981f2d1eda669d945b56207b3c94b00e5", + "0x71e3366d76c55a2318750b2a51d86a41babf197eaec484325789436df87b8918", + "0x56b8291821908612de8ad02adfee632a6221773b416cedb3db9fd4f3ba5d30ff", + "0xbd7abdce9ec414fe47ea73146a2131622bdacb914ea6353abee1b0a149275092", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa7dfFAC8974ec0550C7EEa9dF10ea4ba7B12A861": { + "index": 889, + "amount": "0x01", + "proof": [ + "0x57232d2226cc07596666673aee9ab764515643bd891939a6115d808401fe42c7", + "0x618fcae394b9be93ebf5368a54b5a6244a2176fb031c7b6bfbae4387442d4ec6", + "0xc2728ddd0ac297fcc2105abf09903a984517755b402fc34c874d56a464249392", + "0xe759b6546746269851513af2e7b90b699309ac7fd4eb1cefe25f45f6c49d094e", + "0x6ae25cafc683eaf0756d86c89deb0abecfbfd01e812ffbed4e7a26f11cb91f8c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa86271026a587C4BEB528F46452f5c8375E2E95B": { + "index": 890, + "amount": "0x01", + "proof": [ + "0x88176636126efe10b7e14a9ee23debf171940f25059047e196c18f22fcdffa60", + "0x862b72ffc0bfa563cacf0989fb22d5df29d68045f7ed433db932a0e34fb5da17", + "0x33a345c594edaf8461f1610783c243a81449ec27186711a2d756f2e892ac478b", + "0x16f452fd982f0f4e3fe20a4b2fdefc9226e8d1db4c0b29793acf9535b6c65c66", + "0xe4fc54838dec16cd3ac94713f191dc41ac7f5e070180d4843c9aaaf9c71ce29f", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa882e53F63859807eF67f3bE69442168a38bF1D4": { + "index": 891, + "amount": "0x01", + "proof": [ + "0x35cbd50be2c0fe442fde2e3961d60555d3dade6b03b6df8ab0d4ad8189a19ae0", + "0x79e0453dbcd297307880b358dbdca2207f4d7d4f2e8950df96e16de25dd0aa66", + "0x82aad805335c91e7011dd8396f6c0293becb55858091bc89dd18a07093b2dd7b", + "0xedd365a7e73c5a47a076899344b760df86cdab5eb6566dcce5b550be9bbb5324", + "0x963cc7ad3f8f0ded379d05906b629df8cc616633784013c90731955d0b0736d8", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa946174c101C8631AA1967d2Db1477558f174649": { + "index": 892, + "amount": "0x01", + "proof": [ + "0x938ca9efb7b6d465d3ca07dea93586782c232c19e02cb62ce5b5ecc81fdbee6c", + "0x0cf3571f41808535d0f25037fe2644ce6e90e556619b94ba28f805f35191b1fd", + "0x75bfc221d8f7e7fad04c48ba5ad53c5e62ff5db03c3799cd4e3b45e76de5d2c9", + "0x6ebf988ef586adc2237357c1611e0a6bf7170af1257d42fb6ef98df1f5052439", + "0xea7c0076ebef0c429d544548828ff19d5600136801cc28845bdfa9990d97a058", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xa99E5d5AeC0F681f3a2B1DD75E817A31f9B24A0A": { + "index": 893, + "amount": "0x01", + "proof": [ + "0xff352ddf9976b4c8be27178a022bbc5bbaec1690c0520886d73029529d2c27e5", + "0xf9a4e21cd50151ff68403ad7778f3fa566a7ce23f2def18225d9c0287c76622a", + "0x4f0777a7470c7d964ac693f72cf12d27e2160fcad1a3a0fb364048f8088e3278", + "0xd234d050330272d515ab9d9de470961bb799874daa015afb8d313d5141c5e8eb", + "0xa0af5121b49fc7ea34ad1f4c8308fd6e51803abadb614d1f15f8c87bf9fe29bd", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0xa9f078B3b6DD6C04308f19DEF394b6D5a1B8b732": { + "index": 894, + "amount": "0x01", + "proof": [ + "0x056a566e63a3848c9fc1201c43212ced15fb98dc51687cd4d2bdadb9d94f7df9", + "0x42c5f3acaf4f94511c0f3f4a1e44998db049884754b804e8eb70ff681db14584", + "0x42e42c172851a01dcca036d4a1ac633d24b1e05844cd3c0ddb1534c3c30a1710", + "0x16c0b121292408782518c2e86352704bdaa5fb42c434089ea6fc2adde27ce492", + "0x6e752d8572dc933bdf463f24751c7070d8aa74bb8987a5fe56dee3b0c9f53450", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xaA4Fa4DC414326cCBE04962A8737c468D519BBD7": { + "index": 895, + "amount": "0x01", + "proof": [ + "0x05642ca625c2eccd87d8ec4573de6b6775e6c5fe1da510b01fc0d0613e5fa032", + "0xe7434d9c0e857b8959f43a7031f7655e71f24de6adeaa653f113420d97fd3b65", + "0xfb73c958d3ccb8e44a37fe3c5e674c657e61258ba6390076a46270ed22699002", + "0x2782f91cb56c53bb349c99893dffa8838299f03f96c6519b56f604653b45586d", + "0xb18758ddf98cdeec3d020c2379717281f5c0fa0133be7d006f7f753c756da43e", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xaAaC34d30d6938787c653AAfB922bc20bFa9C512": { + "index": 896, + "amount": "0x01", + "proof": [ + "0x2d41b988de6191abd6beb6a4b031c91960e923aa5fd4d39143a29df1542a48a3", + "0x5d6de4795bab1e85d49eed3991058c8526b26f028f851798e64c44b02b219533", + "0x7459c50ac266878a3e428777040add9dd05d3119fa6ca0893dfe78b87af16a58", + "0x71674724de34865e988a846825d9f937ca48ef7322279591194ca7d40d8ee995", + "0xa43a1be4a3c4bbd4e28425f3172d3522b7e954d7cf0fc72a26d8ba7bea25f197", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xaD4489f64a8be791294116D3E99D2721C7f0a72A": { + "index": 897, + "amount": "0x01", + "proof": [ + "0x05c8537565427959fef111a050c20706f80d6a66c401684ef93b7e6fdc58324c", + "0xe27a53b9b3b393ae2faf4749921dcdf07cfc0f32b6fdef0b5445d41b9f636ce3", + "0x42e42c172851a01dcca036d4a1ac633d24b1e05844cd3c0ddb1534c3c30a1710", + "0x16c0b121292408782518c2e86352704bdaa5fb42c434089ea6fc2adde27ce492", + "0x6e752d8572dc933bdf463f24751c7070d8aa74bb8987a5fe56dee3b0c9f53450", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xaaFdd768fA83EF7af0e19707F2BE9d1DB1924766": { + "index": 898, + "amount": "0x01", + "proof": [ + "0x596b18e1e4cac2c42fa8c8d24f078083fac851b3c5edf271e58416ac918062cb", + "0x8b5c5f7cc90e98ef66e6fc6d4b4df374ebcb03878274494f7fb3e7f08a16b0d8", + "0xf605611ce1c692b9714072be746e6b2642baaa0e106fff51378e6de24bb39de1", + "0xd34d09ef2d0160dc3204b5dba612749c3a92de5f38fe30c9dfc3d0d199e36074", + "0xf9f105f90db6fe2970fb4e03b35654f9b69375879c783d3f1700e04b2e2f925b", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xad6EE7C40d7D80a6c404E82e77Cde5c5088E98a5": { + "index": 899, + "amount": "0x01", + "proof": [ + "0xabb92951ca9b72b2200ff1ebfac69624fe963b44e4ee0f6f6f7cf388cf339ff9", + "0xf7eaf0a13cafa52265f4c34aa29e1918289d49a85bcbcc5eeacf9e8df51452a2", + "0x2d96d77142897c826da134ecca3727222ddacbe2424e5b5b3155c87241c4bbb3", + "0xd7f4836e54488e91267fda42072073873c17b5d47a5a1cb5374c07d89c92ff21", + "0x32636a5315ca425c602832f925f24426ea5aec9939c73d1b2a6fcdace85ecae8", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xb14d56ce29dADE0316EA5Df06D491636a7c4F3C8": { + "index": 900, + "amount": "0x01", + "proof": [ + "0x7408839b235eefe6da9dbdf0b1e344ae8b87af32ec3c247d897234fbe14104a2", + "0xbe6961f62085dfb7ba32c6a2f222568710a17c0dadb56d25b3bd32a65b3edff0", + "0x36984f6b1b4a1a6d888f3fa91ccc133c7a4f0e096be3777975d3fde4090b511f", + "0x396e47c3a850c873832c034b62c0031de9378efa99594428607ab8c6bc01e27f", + "0xb78cb1aa869958030ce4a14b5fff6309166225c83e0cdd2b91deb7b1639f67c4", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xb269EdE1cE37E7b726ea384c3Fa747b91d21f8E2": { + "index": 901, + "amount": "0x01", + "proof": [ + "0x1f44776382f8681a9a4e9907f576aed919a4cbf5b35a316ab32ae4c77fb27833", + "0x1116f0c67ce5efe4b4f7d12b998bc63753b3211b6de2acf65031bb791bfac4cc", + "0x8fc8a67860c71618ec1d12e3c31e1c3661720c696a607f77c198be36067f576a", + "0xc59577d42e813ea179264892414f1c8c6f09486aba6c8a1a1cfecbf6d1e7784d", + "0x6665ebe68e892e4e5135c09f9cdc379628aaa60a8ff322ed2ba75fab3b3a9cc0", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xb271769c54B07E33e7F9f337faC2988C404e1da9": { + "index": 902, + "amount": "0x01", + "proof": [ + "0x944c69a5caf29f8266bfe3d9658acdb61f401187aa706bfe7af019f9d940ada6", + "0xca27fcaa9e81967982f07653736dd0548e8cf3de0e669cd2be87a5a1945bc349", + "0x65127a802606ae04f5ee9995d26ca3dfc8479c1a808782e60eea9ed7332ee2f2", + "0x6ebf988ef586adc2237357c1611e0a6bf7170af1257d42fb6ef98df1f5052439", + "0xea7c0076ebef0c429d544548828ff19d5600136801cc28845bdfa9990d97a058", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xb2814532d004e5C784095B7eb5C45dAe7485f925": { + "index": 903, + "amount": "0x01", + "proof": [ + "0xd93cbbd585722172b2e10730f3528830c2e85ed0df54b37347534059619a00fa", + "0x2c78a61dda165da982b5aeedeb9bbdb3169a9946cb61db1006a3543012a0c6fa", + "0x9dffadac20c132cf7ca3085a1eadd324aefc93eb96b7e6507e8e3ff06ba89160", + "0x539804c7bf7a9b6235d14df5f64369e5a3ba52daf4ce320d3134eb569c42ebaa", + "0x57a1600e1002b648fc38956dc1d2f34be5ee3f6cf170c73bd27c43b2a01e45db", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xb43A03A66C0C66268aa5Ba25Df0b8D9C62138A10": { + "index": 904, + "amount": "0x01", + "proof": [ + "0x3d86163b5c27e9b4d6cc288b68c01e1d79fce7f864bfe58102f080bcd3054477", + "0xc08ca60352ddd810165535a8fdaf0147da6f7ad444c5957a1ed0cd91c475a172", + "0x9bbb60a5fc709695e163323f3a6b2381dd7005d331356c8315cc8d38b4d9cbdb", + "0xaf86f597317f3202fff25068896658613bc0cbf9d7a66fd51e55c97f2358b8ee", + "0xb5bb98883f5ea232108866e1400cd4067f34fc2d70605fd2c67051a6095af7f8", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xb4630Ce451831107fEbA573C74BE6FB667Dfd2CE": { + "index": 905, + "amount": "0x01", + "proof": [ + "0xd9eb877269b1b9ead373b51aef471782e7db6629a808273eee61b0cf1f48864a", + "0x06ec5cd8573fd9c0be190b49a8f23299fdb9dded86622e85111682119501720a", + "0x9dabc5eec4ef62215a8dfd99f8da29641f4d2cade52a73474d7fa008bf611d21", + "0x3cc86f19d7ab5abe54cb84f21d19174b3158c792e08130d0d4f813b822ec451c", + "0xd8ba0ec6899e7ab5afd6774d7465b2ebc52e677b805f74deb131b1b243bae70a", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xb543573d43215Ba2a30233B54A7b3d09Eb275dA3": { + "index": 906, + "amount": "0x01", + "proof": [ + "0x20a22a19e6928219b0a2de4f5c73d220a85817c8a0ff0d2240cd7467c1f2415b", + "0xd593751391237b65ee599de699be5f74c8f1e4280c2e6fd0f95901db3b0990a0", + "0x8fc8a67860c71618ec1d12e3c31e1c3661720c696a607f77c198be36067f576a", + "0xc59577d42e813ea179264892414f1c8c6f09486aba6c8a1a1cfecbf6d1e7784d", + "0x6665ebe68e892e4e5135c09f9cdc379628aaa60a8ff322ed2ba75fab3b3a9cc0", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xb565EA05ABA01ea9015fF65432FDC775cD2FeF0f": { + "index": 907, + "amount": "0x01", + "proof": [ + "0x5f921047ecac7a9c280ed0ee701d570784fd7a961368e00228aa2c2c00467ba8", + "0x7197f5b66cfae7d5cf1b82a59d2bc154552e6c3451db4c193ada7e46662a658d", + "0x235df6c4bfff7e5ae5051713ca9a7dc5664282cfc88bace4488c612d23aaec19", + "0x70db17f5bfc52cce1e5c71a7571d4c960efb51e88d7fc8b1162dd074c38f333e", + "0xdfdb156cb5d2b90a5253163570fe08739b17ab3fc383c79eb041c1d1a667fe84", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xb6F93F039DBbb1Ac0Afb487331D381db603b217d": { + "index": 908, + "amount": "0x01", + "proof": [ + "0x47801e4fe4fa5db445d0f224e5a2ab0c78c1781fc9dabf5cebeb94b7616f620b", + "0x65342a5be1b7ecab705b436320f14e8d05cf007d9fae9b9cf173eaa094b4bd4a", + "0x2bdf090ce3f01130e644c85626d9e4c382cc0c53fa0abf14823a72643b52ec85", + "0x7327dd8ef29607aaaef9bd84ab3718158a620b3e164df6976909aaef215117f7", + "0x38d4a740f3f99a827703ce6725923277f058619e98435b28078dc5b994e00a6a", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xb730d3908B9B83aC4d876Ae5c70AA9804f39694a": { + "index": 909, + "amount": "0x01", + "proof": [ + "0x44ba766a2ab1785379d32b96330f1ee5ef3b4b74d187605450c4b638033f08f7", + "0x4bdebf74ae5bea3e62fa046ed0e6852222b97f367fb121cdc5159a2aec87950a", + "0x11143bf2cd84ebb9924b71d24ab1df210835583a66325b911ee5fca2778d0f13", + "0x9e0106695419683e28012ebdf11113a020b4f76869c1e66a51206a84371b717f", + "0x38d4a740f3f99a827703ce6725923277f058619e98435b28078dc5b994e00a6a", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xb78afC3695870310E7C337aFBA7925308C1D946f": { + "index": 910, + "amount": "0x03", + "proof": [ + "0x62b0f6e78bc7d5233750f7347e4113f6bcda12dcfd7d0b861f918a8fc5fc63fa", + "0x90f6565e3b102f483504a56b75ca2597a11b83f3a4b855a44b6c5788890cbefc", + "0xc7139805f0a4080488e635a7b81ed8c230c27ff6fa0f383174e4da67d2bc4f72", + "0x22784474cee51afee6127b1f3fb642ff75cdb40aeb505017bf6b1a1162a44c35", + "0xfe7d73c06bd76d1271e4b772b51e13505a812b7c919129debfd7d15fb5014d16", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xb80A3488Bd3f1c5A2D6Fce9B095707ec62172Fb5": { + "index": 911, + "amount": "0x01", + "proof": [ + "0x046eeddc5ae196e58120b2fac1eb1387f1a7eed1300cce12d191e3173eebde7f", + "0x7694c918471143645f70cf0a89f4b8d3164a1a587cc0b5b2a55b3cc8312a741e", + "0x45a6e4aae97f2117fcad08e0d206885cb995ba10687c9b38df31960a7a1be1c7", + "0xf48849b03cf9b334d4dc7a6911b922272cb1a72dc4223db35fa6c699461d5f16", + "0xb18758ddf98cdeec3d020c2379717281f5c0fa0133be7d006f7f753c756da43e", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xb80c61fD9B4df38500aa99df9d7b2570866577Ce": { + "index": 912, + "amount": "0x01", + "proof": [ + "0x00c16bae3e9fb16eb9ac4e24ad7895be66a656ef0448144ad55b0f8c2bc4e3d6", + "0x30952d388dbe3075410c6e7280fcb7bb0aac6e789051f268dd015bdff379ec3c", + "0xf1525aa7a232fb8c1021a8aebff4bb78ffcfc5a5e00461950f235b958d5c70ec", + "0x694db95f2efeaf59bc0b92d1736ca407eeca00ef7ad545f2c27ec99a059b74f0", + "0x9be1155992502d2b75a54fc5b2a41d663a86f7d329faea1befa0e24965b01a56", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xb81ab8a53E09e9c430c736d53D455A99C4F8e9Da": { + "index": 913, + "amount": "0x01", + "proof": [ + "0x702307a82fcbb812f29fc0c81334dcaca1e0f82e7e587f17758653571fb6401c", + "0xd8ecc241adb71b21090c3d9062fbf295740ba6152d7b65532e91ef4721ec2e4b", + "0xac8fd80a51422b299c5bf7ed366a10de6c633f04e56e7d1a93f0b71c220e8856", + "0xfe79a6356c4cd9282dab3a598f859bdcecd04fcb915a9edd66380a81697af3bf", + "0x7abccb934a7f719fa80b9a5d3157e99d45ee17a391abf85d4f60839dbf3769cd", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xb820055165e6e269FC75f2E451bc3cfEdB466ae5": { + "index": 914, + "amount": "0x01", + "proof": [ + "0x5184fff867715f5bdaf3e16858268c656c7967fa8140daac9c2426399c5336b7", + "0x191e46e84ff679a225a39d89a8aa67c729f341715aec8dc7b3e5edfb35d6b3e9", + "0xe9d1da07919f076017a9e46eb39c786b9ad3246e3af938c5a8bb37fcf62feac3", + "0x60ea05c082bde3732ec3daeb0e2bae0395932096e755b1a42d9def3042bddceb", + "0xcc9986a7987738d81db64db86f583aed4fde214b766f55d0f15a876c8f790fb8", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xb90A59F77315F6FFA221e3320dAcFBE32d72487c": { + "index": 915, + "amount": "0x04", + "proof": [ + "0xfee04bd975feffc53dfa9e114e6fcfcbabd91ea4a84b67bd04bb30e9c60f7bce", + "0xf9a4e21cd50151ff68403ad7778f3fa566a7ce23f2def18225d9c0287c76622a", + "0x4f0777a7470c7d964ac693f72cf12d27e2160fcad1a3a0fb364048f8088e3278", + "0xd234d050330272d515ab9d9de470961bb799874daa015afb8d313d5141c5e8eb", + "0xa0af5121b49fc7ea34ad1f4c8308fd6e51803abadb614d1f15f8c87bf9fe29bd", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0xb960E449DB279fF4aeb6D9b08627e0291F31C4d7": { + "index": 916, + "amount": "0x01", + "proof": [ + "0xe2a448f9f727ec952410085c8ac7e9b5be1f4b3638be7453162586bfbc8ff928", + "0x30074ee218e0b71dc7c293c02d1466bc7409e5bd7a2ef3059c4c0f5f785f95d0", + "0xe245c0cfce194010f5d1ba4d1e2acebcbce7ee3beb09abd2da7ac09a58a6c76a", + "0x1bd24f0c1d9a337a197e1feb80905be5821f1e64457aba030d18aca78646a08c", + "0x7968b2383e3b914ab3a36580b205f1449b51563630c77871f712e94743e3bf39", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xb989C3717405569398750983aD5934308759287e": { + "index": 917, + "amount": "0x01", + "proof": [ + "0x35eadfa109841bdb39e29b0501c7b484cc0747efe1c7faa548320ff73566460c", + "0x79e0453dbcd297307880b358dbdca2207f4d7d4f2e8950df96e16de25dd0aa66", + "0x82aad805335c91e7011dd8396f6c0293becb55858091bc89dd18a07093b2dd7b", + "0xedd365a7e73c5a47a076899344b760df86cdab5eb6566dcce5b550be9bbb5324", + "0x963cc7ad3f8f0ded379d05906b629df8cc616633784013c90731955d0b0736d8", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xb9dc2fbBEeeaEF6aE0082FFE0afF3FB798c5E735": { + "index": 918, + "amount": "0x01", + "proof": [ + "0x0af2ced2678dee13f90f01c31e7c96a47b35fc2896e82b95e090c684dfe0ae90", + "0x7b286a39d827ec0a6301858dae95ddc36ec440065ea92f65731980cfa57bb970", + "0xb1717c21808d3d48c3df9715b61089ddd54dbf21e63f04ad434821ef229b5e7b", + "0xc50cae5631fa8cafae8224329322dbaebc117b278a8e07f29104d255198d88a8", + "0x4a36dc66177a8394f6b14fc9adbe4ad7e0cc2dead6acb72d80990e336fef8d45", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xb9f889C223Aa3e33D9B26a3bf7C496C3c3E8c241": { + "index": 919, + "amount": "0x01", + "proof": [ + "0x6011d39f1a8bf115779f8be694c4bbe35d34d6e3b0ac6be3ccea41cfaf13b323", + "0xf6b8d38023c5743e6c46821d31d7ed277cf5ed7b06e41b9395a987864bbf9840", + "0x11c7f0494b8c0020c72e25c40dc03744caf95a5fada2bb6b4c5a083bb072f5f1", + "0xd1cbda0650121cdf56f6e9fac417e3ddbcea9364da64e4e29c3e50fa61aa56bf", + "0xdfdb156cb5d2b90a5253163570fe08739b17ab3fc383c79eb041c1d1a667fe84", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xbB4A12647054460b8630851d7a6DC83584b6462f": { + "index": 920, + "amount": "0x01", + "proof": [ + "0x6175ad4222e21b21d13833322e81f21978673ea0ea0efb699dc937bb8c17c3bb", + "0x30623ea638bdfbe5c0f91a8c7ff1b7dc5e497ff57b36806a8c7aa063b45892f1", + "0x0d0aad0eac33ef90a443928440ec8982d70996c767cc18a515c491ce4412a27e", + "0xd1cbda0650121cdf56f6e9fac417e3ddbcea9364da64e4e29c3e50fa61aa56bf", + "0xdfdb156cb5d2b90a5253163570fe08739b17ab3fc383c79eb041c1d1a667fe84", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xbBcE15Ee9bdE24B77031ed6a82e9DD9B6C7492dC": { + "index": 921, + "amount": "0x02", + "proof": [ + "0x67df55d2a943f0cfbdda741ce4fbf9678e756b9602a7b3d22d484442b9b8d4f2", + "0xb3b75ef503e13ac814c5959f75334bedc7a15658bd3edbf729a191f090bad8df", + "0x9feb249fa051b9c4d2179c5c0a8ed76334b875245fb0c811161d3bc057ef51ab", + "0x5fee000564bb97bedb499d3b5c01f147f4e4ad76f5f6443565804721f95dcda3", + "0x245190f95f5e09d43d1da7e9757fa066be1942b52f7e4962cbbe6a5f2e0981bc", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xbC279E434C1522cC4dEEd22118e292D831B7E8c4": { + "index": 922, + "amount": "0x01", + "proof": [ + "0x24d64e0f437d0e790eb860bd33006cf1ba749d1434b853a05c63009f0ee5332c", + "0xaac75d6ad471e301ea46ccdd344d7d1f4eaa8a48e3f07d0d27329e6d0994e283", + "0xcf959dc22eda4cc1f43407713b0939306c53472c1295a5b191e90fd79f98d755", + "0x4b1c846f0a8bc448aead7f2cfec46ac450b23d2f229b5350dd63009a82a1dccf", + "0xe29ba79106b7b14c14912bb5fba509f27997ddbe5a7ebc941fa75e3475af4aef", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xbC90B3Ce40fc3Ed921D910f3e046C65954fFF7cB": { + "index": 923, + "amount": "0x08", + "proof": [ + "0x452b2e7f4be0b0e7f4791d3cda6ce572d80e7f5fc646be33f1db5cbb8dd94eb1", + "0x51b97128075f4e203044f1623661e702cfad19c7cdc48df545dbac7eee500521", + "0xca882a67ab86b0ef4e7ddca27b5df90183d6545fa0466cfeba52e7d10412db29", + "0x7327dd8ef29607aaaef9bd84ab3718158a620b3e164df6976909aaef215117f7", + "0x38d4a740f3f99a827703ce6725923277f058619e98435b28078dc5b994e00a6a", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xbCC44956d70536bed17C146a4D9E66261BB701DD": { + "index": 924, + "amount": "0x01", + "proof": [ + "0x2dc0cdb819b7cf44d2de895e6364622b463d703d0f17c60568dd334c324d365b", + "0xe2426c24b394b169d07d68462d6d6d52a3ee51c08ed5371353a8d28def069712", + "0xd7c1a15b710f86aade261c04d27fec83ac6b798b76f86972e953c8642432c14f", + "0x9e8ae6c0c829ef47f1fdcf07618192e842b30fccb4c38a8af79f05f97c75c097", + "0x4325701890e79e85b41231157c1ced07357ce871ed6fb4f233c2f82c38bcf4bb", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xbCCf9f2B76c7E2460d0aCB9763ae8B779675e568": { + "index": 925, + "amount": "0x01", + "proof": [ + "0xd24935c99426359b8db87b2d9337262db5ee318d371e0377691e245a72047d7a", + "0xb492774252dc0486ab9e7c95ee7f534e1539a4ac6d26bd1f81126ef5de019917", + "0x3cded42477683fe44d3b53da8af7372eebcf3f7b5d0c072544d9d80a0220aa0b", + "0x41e64ddeb2fc55a967472c34897707f35a7b74171d5a7d21351e62fd45ccae94", + "0x7e73f337249898d15604f7c330d90e36da04007407404a4b4276d5fe3083b929", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xbE3fbEBC1Cc29E99E02237DAC84860E268CAbc9b": { + "index": 926, + "amount": "0x01", + "proof": [ + "0x051345b18ea583990a0f3659f37abac89a2003b114b38321bf18c4239b5a8fc9", + "0x24409cd3f82bc55de621ccecaf54842dc6fae2367889f37ad3ad85d6af19900b", + "0x3b9ae731fb4fc0a972a141d2c931c7e4afe1020d11bb774ef3a217e73d2e8b23", + "0x2782f91cb56c53bb349c99893dffa8838299f03f96c6519b56f604653b45586d", + "0xb18758ddf98cdeec3d020c2379717281f5c0fa0133be7d006f7f753c756da43e", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xbE424F1e306c03113563db34033bE714dAb39fCB": { + "index": 927, + "amount": "0x01", + "proof": [ + "0xb010e6d2f6cbc433d1ed1414a9967a46a107d9776db361520c68d2885b00f3e8", + "0xd7061525778fa3fb49d7f0936ea2fe4e8e443e40eb600592763fdbe9ce723c86", + "0x3b785839cd26b611d66f8b353ee5f32ff1026532ac266e55f2864fb32246d378", + "0x577f81e56558cea5cd9d5160218e718fdbd9b124f0dd5499c3e14a238415b645", + "0x72373ecc225af245878bc638c49c8901db1430b7210a3008231acc8f8118d2e0", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xbE9013f7e9f5514ceCac5490b83F63FA0f607a47": { + "index": 928, + "amount": "0x01", + "proof": [ + "0x898920da3332725bd0f3e30ad533e1db0a3d9d61c78afa3d96339633a8780415", + "0x98a08095e1143e4bffc91d0d097598f8840e329876b6d376098cbf92ddfabd49", + "0x955d9858f13d562b2b223301c8206ff82e44d35786e621872e8a0ddcd2c8af96", + "0x16f452fd982f0f4e3fe20a4b2fdefc9226e8d1db4c0b29793acf9535b6c65c66", + "0xe4fc54838dec16cd3ac94713f191dc41ac7f5e070180d4843c9aaaf9c71ce29f", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xba30963F47A2d33476E922Faa55bEc570C433dD0": { + "index": 929, + "amount": "0x01", + "proof": [ + "0x98e61e33b02c8d5b9099885f7c9306ce4fe8b35304c0931375ae5404e5fab505", + "0x7b6add6566648546e7727259f67c2b0b34ed116e3e06da7a83de5761884fb361", + "0x8b0939c5da9a4351dcc809a063b8226bb4eef5b67c44f5015340b9723d256a41", + "0x0209cc90d619e0e5f56081126d2ed4018391f3d9e1dd1238794235d656c68c9b", + "0x62ba7b58fd554e8be295bf9d4baf9eefd0b518ead5cb8bab321717a08160ae0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xbd600A3765EE38966d23030E303DF452CA296f3D": { + "index": 930, + "amount": "0x01", + "proof": [ + "0x342fff7a2bac25f77cd7a926c969440f7abb3fbf9895b091bfca4a813325360b", + "0x89914286a870c5d0b51ccc03413505f08a95629f4f42c1192fa7c18ba61d3fa8", + "0x2ceb10a8fdb6b89453aa45138287aaa29f977b0aca5b8c98dcc42bdaf69fa298", + "0x9c7a414e889956f4c85241ac1c103f8242a6795725b10a2a17d9a1d125767087", + "0x963cc7ad3f8f0ded379d05906b629df8cc616633784013c90731955d0b0736d8", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xbe15D15bb99CaCBd87530F4B40BC706BAF35972E": { + "index": 931, + "amount": "0x01", + "proof": [ + "0x09f1c1cb4d35b81829c2b9278bdbad6725f274b604496a3610593276831458e6", + "0x306a8cb80a4fa105c174f23a915a866242d63632d3e7c3a81d8040f1b2bae200", + "0xb1717c21808d3d48c3df9715b61089ddd54dbf21e63f04ad434821ef229b5e7b", + "0xc50cae5631fa8cafae8224329322dbaebc117b278a8e07f29104d255198d88a8", + "0x4a36dc66177a8394f6b14fc9adbe4ad7e0cc2dead6acb72d80990e336fef8d45", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xbe4cB1Fb159cDdc722c89c18C005cDCdDe0bDe4a": { + "index": 932, + "amount": "0x02", + "proof": [ + "0xb09c1333e95ad827efa022d49738dac1da37260814ba5c3a6dc05f380291e4bb", + "0x09aa1457f64cf20167615ce9721d6ca4816d7022d04b6fec48cfaff3742124be", + "0x861b6a9fa4a9a59b3537e811eda798dcbe95d882461afb4d7e9391162a287d45", + "0x49f4781ffbed71f831627c02425eed106f4714988055f5e0978de46ca35b3ae0", + "0x72373ecc225af245878bc638c49c8901db1430b7210a3008231acc8f8118d2e0", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xbeb910Ae193Dc54411747aC236E67D221fF3F1D7": { + "index": 933, + "amount": "0x01", + "proof": [ + "0xe5c5c3f28ddb75832b82fd54c8f9032a1d98d642f052036df6699cd186def092", + "0xffd2172389a725993abc199482d9cb8f1b9154eebe3f0d9300cd77fe4a94b491", + "0x7d7f94570c5fdd54e865230be00712e816eac4c23f4dbf19c8566a21bd0c5b95", + "0x46903c3e0f26b709802c8a2743505337728e1f805b4f936ec91df4b3f43fcdb9", + "0x7a545b345b30e441bb780a4fca731a87b1e941b75518a9983a312194a9e7bd46", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xbebF76d496a855964845706f12A9f75e9Ae6423d": { + "index": 934, + "amount": "0x01", + "proof": [ + "0xba4803005e648f5b63bdf2af459afac86341d606059ccc821dec7e861524a991", + "0x54bca3cee45869ce5e39ed9e4a737f77f180f84015517ac17ca1b667f9b46a0f", + "0x99c1bfc876cf5982f012ca12995034d51b946a2ba47a506495fe65b361451d8d", + "0x6a8275b9d29aafc6358bf9f174b96a6a2561ace2c21d2edeb2a14975f0d9b0c1", + "0x83e262e483a6f2ff9f4df14637dbbdfeddf0c6b0b4ca462c4375d29a3521e052", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xc05bc25EAa52a23476E113b9A139a66e7473b364": { + "index": 935, + "amount": "0x01", + "proof": [ + "0xab7e489eb888d8d8be590f85cc05162955cb50755878d9992a8d02a9818c8245", + "0x51d6140bdf2266dd9e6099fc4dfb33024b0df3b8f004e20097b66ec1d0ed4a9b", + "0x2d96d77142897c826da134ecca3727222ddacbe2424e5b5b3155c87241c4bbb3", + "0xd7f4836e54488e91267fda42072073873c17b5d47a5a1cb5374c07d89c92ff21", + "0x32636a5315ca425c602832f925f24426ea5aec9939c73d1b2a6fcdace85ecae8", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xc0607575dF410411A06833AFFc54b424a56b385D": { + "index": 936, + "amount": "0x07", + "proof": [ + "0xd3ecdcc142e6e92ef68075ee2da55bf5bc349159f0c7777b950a4121f3692881", + "0x10aea724940dacf1e47257b194de3b628ec4b4087263aae40eda9ca264e6e9a3", + "0xcf4b0a8be134a824cf199271e2b48b713aa95add1e71d8db714ef711f58a2265", + "0x295b1cb76b1ce79cd1280bb1130a4264534288edb4c264d45d4ab36dd72b36ca", + "0x7e73f337249898d15604f7c330d90e36da04007407404a4b4276d5fe3083b929", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xc138aE7bCD1fDe0606a4eD6c8B7413e80c796915": { + "index": 937, + "amount": "0x01", + "proof": [ + "0x00783678c00d67b3e385ddfc2084806da04a98c43d1e0a548386a3862a73b5d5", + "0x30952d388dbe3075410c6e7280fcb7bb0aac6e789051f268dd015bdff379ec3c", + "0xf1525aa7a232fb8c1021a8aebff4bb78ffcfc5a5e00461950f235b958d5c70ec", + "0x694db95f2efeaf59bc0b92d1736ca407eeca00ef7ad545f2c27ec99a059b74f0", + "0x9be1155992502d2b75a54fc5b2a41d663a86f7d329faea1befa0e24965b01a56", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xc140AAD62f73C19764205815E6B564CF6e9504Bf": { + "index": 938, + "amount": "0x05", + "proof": [ + "0x044dab23cf8e3c432effdf93ca88ebe62eb3b8622bb355e7e5d2f3f2e9dc18ca", + "0x8e2ce87c274c5cb6a31747ff7f03631923b0082b8b207e466aecb396de468a88", + "0x45a6e4aae97f2117fcad08e0d206885cb995ba10687c9b38df31960a7a1be1c7", + "0xf48849b03cf9b334d4dc7a6911b922272cb1a72dc4223db35fa6c699461d5f16", + "0xb18758ddf98cdeec3d020c2379717281f5c0fa0133be7d006f7f753c756da43e", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xc1f3eBe56FE3a32ADAC585e7379882cf0e5a6D87": { + "index": 939, + "amount": "0x01", + "proof": [ + "0x709e4e3183cdd8be935251dd0d48a91829d0f86d7a22c81932a5bd5ab824d9c4", + "0xa2dc3924d587b21d1726f4d92731dcaa995e9165f4386e4af38be93bbffba08e", + "0x8be860722f0612e38d1e8acd51cfab2cbcb140685965dff7de6f05ef66a544e5", + "0xfe79a6356c4cd9282dab3a598f859bdcecd04fcb915a9edd66380a81697af3bf", + "0x7abccb934a7f719fa80b9a5d3157e99d45ee17a391abf85d4f60839dbf3769cd", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xc315155D817140250D238F140142a10b69Fa1c4e": { + "index": 940, + "amount": "0x02", + "proof": [ + "0xdbe2ade5644dd5da3f9253f7ee4cd48a5424019bc8335fe62d91da970871fc81", + "0x030497abca81e76b8f6fac09dbb62f9c6dccc0fbb9d8c36885fb6b494eab57c6", + "0x0e3f11231eabc58db4785530d98a166f67094f59b7d8140612cd5b4356e4db3d", + "0xc84beec6531767197744c2106caed4823936b1ceed7475952444acf832b57446", + "0xd8ba0ec6899e7ab5afd6774d7465b2ebc52e677b805f74deb131b1b243bae70a", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xc3AE219995a5a38cbc44b5580fD7162489E22D3d": { + "index": 941, + "amount": "0x01", + "proof": [ + "0x7a239503e0fc7e923cbe6850db6a65a6729eeae2f6a5610277dede27573dc8f5", + "0x5abb765f1d646311ac232b61b47e72693e2e694ee181babe375589be9993b712", + "0x4c323856e3ed5872317143e057e5eb0b9c02e5efcad37c36801f077d7c535fbf", + "0x81cb79cde32d282b43e0e438fe2b6758f17fd2d569d10c780c800d4c492134d6", + "0xe2050f6c95c616c1cfdb04f4b6d0afb5afa0fb464f767c38aba0f07df915a97f", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xc50188aba81aF79E3082f3C7BF5845B06C7fDD20": { + "index": 942, + "amount": "0x01", + "proof": [ + "0x130dc454c3351eb6712d102c62d51c3f0b070f087fa9b556c4e2f5d69dbb2728", + "0xb167b442e8f4c911410d3f591415b4988292e84c7d91cc08a1768a68a7772773", + "0x845cc84318cf86b31a866d4991f68f70ae915279f96750b537b675397281505c", + "0xdcab737bf32fe2edc99f37725a5c46b3f4c2b142298388f08a1bc983981697d3", + "0x6431c24d3d46ea6b0d1959c0de03265dc474d3e67139f2bedca26b5aab0c0c5b", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xc5463fC1AE9edc3827029B7D8272890cA8e67D24": { + "index": 943, + "amount": "0x01", + "proof": [ + "0x5a59e7f87d9a745c0a28dc9ec912372f5bdc4083370ad864acedbf8971827f09", + "0x8feb836e6c91b900a2062e734ffe8864facfd489dd9a0d44c74a253b694a33a2", + "0x44e62419e6617508f01090bc15bf772f46d113e070bd339089cafb8752c6c104", + "0x31f1720e10e01b0c3f193ea7a34f44234d915ebd6c8260e1b72970bca0201b09", + "0x140105e3fa17ce783a651f2281967c53a37a748c29442efd53ee24d8a1cff6f5", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xc5AeB6d28Ea775CE6e65505Be9eCB5cF752c5BF0": { + "index": 944, + "amount": "0x02", + "proof": [ + "0x87e9be03676bb0679a872a30b638694cf5ac02657c46f9be278edffb44e66f1f", + "0x9db80f247660d61beb3a018a785598c1536be2f221ee38a71dbd4c64f2ff6344", + "0xf2b143b8e4bb24b0f6133a57083058573afbf3f2d5a88213d4aef21a33017990", + "0xdb5507911490bc1574fb624fe6bd570cc6afcd947118f0c9c38fe90a00ee8b29", + "0x9dda7d74fd49fdacbeb3afcd37c878516159fe4b594e491ff7ecbc80fd8d6808", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xc64844d9b3dB280A6E46c1431E2229cD62dD2D69": { + "index": 945, + "amount": "0x03", + "proof": [ + "0x2f8659e94bfc768d99c9367a4fdf5702c5f3f14c56054ea8054866fcc4c2eb7a", + "0x4a32f641947cf748eedfb391350ef984318a6e6cf1cea98bc14cc35cdd1adcbc", + "0xf9b0841b7b62c71198361192f1c7feafd2ded284dca91596cffae95a4d3686ae", + "0x7fb8279a3bf6834ff5de6f30e4ebf74889d64cf70547e9c78a27d7fd86516478", + "0x4325701890e79e85b41231157c1ced07357ce871ed6fb4f233c2f82c38bcf4bb", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xc67a5aec18d39D925B803BF06b6D232919E9EF09": { + "index": 946, + "amount": "0x05", + "proof": [ + "0x8404da706357c80a670edaf1b35afb404ac6fc80c3834eb7d5169cb1a7d3f525", + "0xa57293a23108699589e42520ced4add426c35225c4e3863ea2675a5d6895bfdc", + "0xbc2dc753cf42a1935c4d0a0882fed8a90a12f1c0a70573deb71cc2d70b40317b", + "0x02cef8ccb3c7906e41a7ed9d223c95f320f2860a3d5a5dc4598d02362970eeec", + "0x9dda7d74fd49fdacbeb3afcd37c878516159fe4b594e491ff7ecbc80fd8d6808", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xc6b3D5Bc8562D531cF3E963f1083097Ce3ceC4Bc": { + "index": 947, + "amount": "0x01", + "proof": [ + "0x2e5e67cca8c2da14901ec5e7efc2f76f37f556e34ced1dae5bd380ea98972cf1", + "0xcee67e6b369f2863b42982f3bbcacce67b4206c192012a65ced1e1524f58583f", + "0x33ee9937a125c825df46cd7852ad611a4a2bd56aa65171e409297909c605ac3b", + "0x9e8ae6c0c829ef47f1fdcf07618192e842b30fccb4c38a8af79f05f97c75c097", + "0x4325701890e79e85b41231157c1ced07357ce871ed6fb4f233c2f82c38bcf4bb", + "0xca03e8953ef40b66f05ad1cb80c9b99794341f4ce821a38ee50936fca3e14000", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xc739D8AAFc091735C9996dCB940023EB23528FeD": { + "index": 948, + "amount": "0x01", + "proof": [ + "0x0d531543be97b88ad5acd395bc90872d30d54e503cff78f8c7db0f09c151f322", + "0xcf558ed9c43ca44b32b5aef7afbbed2fae05da17321bda78b73d305e495908a5", + "0x32079f379faa5487ad026443f33416fad7496adb5ba59317ada9083a771610a5", + "0x037fa491e4b6fc74b9dccf3175d28aed9f5dacdb75dd0fc8e1154a0704619620", + "0x4bab2069d20a5d1d2f5ebdb61803a57609b7709eca9e925e31a7d14434af1326", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xc7bd798519B38F4d9F424F8764424C54F653C38a": { + "index": 949, + "amount": "0x01", + "proof": [ + "0x5134541a7d830f8c668dc02e6847d1580ab75461ffe1857526e208fd908e0b27", + "0x191e46e84ff679a225a39d89a8aa67c729f341715aec8dc7b3e5edfb35d6b3e9", + "0xe9d1da07919f076017a9e46eb39c786b9ad3246e3af938c5a8bb37fcf62feac3", + "0x60ea05c082bde3732ec3daeb0e2bae0395932096e755b1a42d9def3042bddceb", + "0xcc9986a7987738d81db64db86f583aed4fde214b766f55d0f15a876c8f790fb8", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xc821477E0310001dd4DBD978425002eE890bd975": { + "index": 950, + "amount": "0x01", + "proof": [ + "0x4e60efa9bfc541f7efa9039749c5319539bab6978887631dfdbef908d65bd404", + "0xd35de31a11f2c71104f9bb4d17986cab48f3fb4323f24b6b902a5d5d7f2d42c6", + "0xc9b824e8443131ec044d11642590dda66ca265300328d8dbe4689483b562b29e", + "0xf94cc4240e18301aa3e9325f55d6ec2e2e84a181037fd49b69a29a1aedce082c", + "0x43f59a603c2458850547e5a84d47e61be843b4a3c814303ed1b52e1e4d37a1b5", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xcA24Ee62344900f7BFC39CeBeeCEdFA1920DeBbe": { + "index": 951, + "amount": "0x02", + "proof": [ + "0x1d38a144bcbfa06338ef93953e811fc1052e52e2a59df53c451fc1dca2bd47ec", + "0xfadf55a64f547fac120cb1b0d627dd3e6f58d51b8b3fce98f649e99b354db11a", + "0x702557a325e5dfca211cf992bed4c7d6442ba5a9ca061e69640a79660a822710", + "0xc2b85fb7fbdedfff6c0826f89cbeff5a93f827eeaec8b16d80424b138de956db", + "0x8e0cc5c13324dce3ab0f042d31a9db04afe0918f70e3f4515f43739791621c97", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xcB007Bb46dE077F87792191cbC1923D8fcD20E8F": { + "index": 952, + "amount": "0x01", + "proof": [ + "0x12cd193fb059a390b1511f6d5a8eadd3c55ff3641f00caf5c79eec7035f8eb94", + "0xb167b442e8f4c911410d3f591415b4988292e84c7d91cc08a1768a68a7772773", + "0x845cc84318cf86b31a866d4991f68f70ae915279f96750b537b675397281505c", + "0xdcab737bf32fe2edc99f37725a5c46b3f4c2b142298388f08a1bc983981697d3", + "0x6431c24d3d46ea6b0d1959c0de03265dc474d3e67139f2bedca26b5aab0c0c5b", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xcB8D7e09CFea4685596e2336c0505826F35cDD0b": { + "index": 953, + "amount": "0x01", + "proof": [ + "0xf961c857b2be7f04b22dc5ff0173fcc387ee2cbcf1db698780ef1f66d63225df", + "0x23fe565318d11bbd2742a130623a8c3f9d59dc6c74a82d09a44722ebf99e19f5", + "0x3708d8178885b9269e803b79a4e0463134629db473cf8c80861afeae7084931d", + "0xa151a98046c68dc4de0dd4ca59fe7fff4ba692aa78310b499e772f0cf61a08d0", + "0x938890418edfff03e5d8f0abce65769ab79b16db349d2869a477500717305360", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0xcC202930867769A83B61cf5053b65D1845E76Aea": { + "index": 954, + "amount": "0x02", + "proof": [ + "0x1db76414c006c9a43c452b8e8a446da8a04173510a9326ca7e0fb0728f2d1d03", + "0xc91390643b5fc24c58ff0d2dcfe1a4e0d84bcb8f45f2b213e0861fcde3ba6d9e", + "0x1cdba9e91cea35b2840b706aed8319a24d18d06c2d7b29d63283aa5645e5a6cd", + "0xaaf60b5ecf22563f090c456c87a77833a8ecad31ad25f79ce590acdcb7f64b01", + "0x8e0cc5c13324dce3ab0f042d31a9db04afe0918f70e3f4515f43739791621c97", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xcC987f85C2150670a391E9bf6dDCcB4B875b9826": { + "index": 955, + "amount": "0x01", + "proof": [ + "0xec9d3539b8187b15ae00a7b52f3b0e84e103536c9645c34a4414b790523aca0c", + "0xb2bbc7ec4d0dd075b47f1aa696f7a532fc23f61125da3784096070efe2d026d4", + "0x77487187bcb357b4188cf608ccfa3f6f329c635c083000f639cb79cc9e5b4cb6", + "0x338979409b1c886a92a48a505a3f0b093231b3d66119d999f9bcb41baf89c59d", + "0x6e496426985c92b04963088da4856230c781a975dbb5ce2d8eed77e7d2d4b58e", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xcDB527EDB664b2Ee6B8A3B96212Dc628A35dfdad": { + "index": 956, + "amount": "0x01", + "proof": [ + "0xd5d9fb61594f39bc37f152b2b5a13aa8ea8aeae7ad5b55a1ded3cb5714e9fca5", + "0x5f173f4df62d2d177a611d4c4cb56bb8556378c831d0e83aa38cada3821095f9", + "0x19086762fd1965edfc2c6f8d382a94ec7bd76977d80206b5dfe7ff81c35524af", + "0x295b1cb76b1ce79cd1280bb1130a4264534288edb4c264d45d4ab36dd72b36ca", + "0x7e73f337249898d15604f7c330d90e36da04007407404a4b4276d5fe3083b929", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xcbF7515F481BE2C3D0354a5bA81BA587D48d9380": { + "index": 957, + "amount": "0x01", + "proof": [ + "0x07421aa821e00f64ec23961cbe38ca5ddaf7f0a9bd207c5c4051df6b36067413", + "0xb07bb32ad80d56890b18315cc49e506789f445c92b690b1ebe2546b68dd97b58", + "0xdae2fa58d07da8c33da0b26d0890a4bf9f3cded6c882ce8613c4097fb454fae7", + "0x7123b37c640e8ecb7e1db656a0f1869aecd392fe2f9511dc671c16401bc54aee", + "0x6e752d8572dc933bdf463f24751c7070d8aa74bb8987a5fe56dee3b0c9f53450", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xccf8B610E4a19d4d34378E050ACeE33dC538129D": { + "index": 958, + "amount": "0x03", + "proof": [ + "0xa59c5034445767260bba2250034a7221ef4e5d8a4d8b7e32752dc3196347947c", + "0x0ac9b2299a2ed35f2222a3b68dfc9e41d64bfc7b448389495176837bda0ca684", + "0xa1721ee66f5b33fb1491876c9638c9e321f4e9e99e92b69903d4c3b0954511ab", + "0xc677cbee79568f65b4882bd20044555e2bddfb473bfa6749d1d07caa3dd6fd2b", + "0xdf701aa8bdb3ffefff1b359214087cc585fa0a0d40716a6635a8d2db4380dba1", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xcdc1F76Ef38a912bb05C8aD268fc02CCDAC9d024": { + "index": 959, + "amount": "0x01", + "proof": [ + "0x2189f7f4bb9149965a42057b6e775821d27224da93904214368f504091fa620e", + "0xa640b527974b8ab9419d85004f68d1bc23dbec6fdc16c4db2198d649c05481b7", + "0x65c9c0c546d81a46cba9c8cb702c77ff47deec1dcd6f975abb3e5cfe8dafb0b0", + "0xc59577d42e813ea179264892414f1c8c6f09486aba6c8a1a1cfecbf6d1e7784d", + "0x6665ebe68e892e4e5135c09f9cdc379628aaa60a8ff322ed2ba75fab3b3a9cc0", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xce4B87301aD7c336Ef2f1b822aD8Bd7e86249ebC": { + "index": 960, + "amount": "0x01", + "proof": [ + "0x5d66cd88dd84d02a1f1a107825eb38c974ee63fae262bea36b1540989893ae01", + "0xe659009fa1069f5a03ea9dc2499f39c63bae54235f152c79ab4e4a8415ca5136", + "0xc8194a78aa356d611f6bbcbe346bc7a996ca8addbd55a10d6fe06d7320b2f492", + "0x4bbd36041ce4968e3db3409953e198317c2cb3811d91f8fc5a98ba5c581d59e5", + "0x140105e3fa17ce783a651f2281967c53a37a748c29442efd53ee24d8a1cff6f5", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xced432f2B188CaaD2f545bC524222A9F0DeaBa18": { + "index": 961, + "amount": "0x01", + "proof": [ + "0x5c0ce769072552fc7d644a59ee91d7373e4abdd2225fe811d8e67a6086b681cd", + "0x6406e0c7b04b98936d48bb060745f5d7034b02e4e01c28519641943d242097f6", + "0x1e238294161409acd6c7ffaa2d08bd09d6a95e15ec21b6d1eed1c519054307f7", + "0x31f1720e10e01b0c3f193ea7a34f44234d915ebd6c8260e1b72970bca0201b09", + "0x140105e3fa17ce783a651f2281967c53a37a748c29442efd53ee24d8a1cff6f5", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xcf9Bb70b2f1aCCb846e8B0C665a1Ab5D5D35cA05": { + "index": 962, + "amount": "0x01", + "proof": [ + "0x8bc78dbe0d16f453a3bd1ad0017bc5afe3f1289a73045a0eeb56414062d94e74", + "0x5fb23e09649322695a74e48ae902ee984aae9f179ecac63ad5af24de31dd0c2f", + "0xeab5b9106c246e423a3bad13324b91b16f3f43030108260127abad6f7f52e76e", + "0xe04deda4b0f0ea0bda4320a7f8e55700dc470bdcfba68775214ca25f30ccc348", + "0x8fbc13f50b0f82a781945a74ddd5c5abde0b4a8983852c66ecda77a68df50722", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xcfB464585241eab3Ecb392011648a8e829b951eD": { + "index": 963, + "amount": "0x02", + "proof": [ + "0x317476ec67f75da8b43046f428f21866af73d69ede69e330fc42d5cfc3fdbc88", + "0x49cd9c4bd029d94a4fb131eb1986ac9e5247b3cec88948ffa59e93a48522cee7", + "0x7f001521588dd2e8e4ddfabfc157315a28fb70b9eaa1e5f5cd46420a6a34950f", + "0xb74deb44e6419575dd75ff4fb4c2cc26c6f8bccff72ef47a08f3f27e13f3de40", + "0xd6d09ea62a0a0959d8a1f1cbd849b805597a75fe443bbbc4d5e2555bf8225437", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xcfEEAb521b91bBE20FbE020B8e6bE8397bee6468": { + "index": 964, + "amount": "0x01", + "proof": [ + "0x5350067a8a6a8b910e1df9a0c4eed048162c560eac3f32142611d1c132ca1eba", + "0x4cbbd99b432afca501b2d9c83401affd239d9bf8c7e9ee093e293f0ef7e2cdf4", + "0xa21540ccaf175cc840a18d1224f8d3683c9d069bd5ea2c3bdcc7b37a61191f98", + "0x7a5397945a42b48bf4e4ee9c21f985e9d9ccf82e57fdb87dc2e6046ed345d7ec", + "0x5477c93aa7e191fd8f76e1976387fc82460220dfdcee87f9ba8926f4e0ddf45c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd03F1fC3f80B65BBA30063185614C972697A3294": { + "index": 965, + "amount": "0x01", + "proof": [ + "0x9a08a8e7608ee037ec34c6d869f60f0815d0cb80c1b809175eccf8e05678f879", + "0x980ad86e05c35240bd248bd776953d4ecc33730b9e47830fc99b866ae044f726", + "0x265c302052174e496eaf88164e054aa106d99c29ee696e11b9c7df66fbb1a01c", + "0x0209cc90d619e0e5f56081126d2ed4018391f3d9e1dd1238794235d656c68c9b", + "0x62ba7b58fd554e8be295bf9d4baf9eefd0b518ead5cb8bab321717a08160ae0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd116EC51cEd0a7A49BEA6555f90872752448D8Bc": { + "index": 966, + "amount": "0x01", + "proof": [ + "0xcf9b5c2cb9a2a4461a0757007298a6f4bdb88018952cbd32e729a07111c5af46", + "0xf90ba0f4efc0dd3d7f49552842ca8dd3260f0faf2c3d3c105c1f85630cde0da3", + "0x13ea6405c1facec923a61440b64632ddc4351c954b3e5915100fe378a0664a58", + "0xcea68af505202af90a0679269376e373d9ceca250970bcb6953e0f30f5dcfc7d", + "0x85ada07677b521b0dd2e0d60f51f92f7b1217f46e36379a5afa5a74fd5c87a5a", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd13678BD996bCaCF0f4d0e81F3c1036aF01Cee49": { + "index": 967, + "amount": "0x01", + "proof": [ + "0x9331d340cd012bf388c5ef9a2169e9108971dc848791c8bb202ca44cfad0fdd5", + "0x11da34f4ea9b53698d8ebf0d92cfc6166436e04c4d2c8da6c846fbfebf5873b1", + "0x416fc24a2fc25ba59a366a12617fa61dc7d155780e7b0cf47d4beaec91fb9776", + "0xeb79377abd71cdb891e1379260c8fb1947760c17e28c7168ccd62f5d772f861a", + "0xea7c0076ebef0c429d544548828ff19d5600136801cc28845bdfa9990d97a058", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd158637f7a7bAC0E16e83e532b8d01edc77c4797": { + "index": 968, + "amount": "0x01", + "proof": [ + "0x9b1cd451a755f98780c1647f0d388422b059d675702122238b8eb2057511619e", + "0xb4a6bbf4380a38c62359d66f80a459eaabc2b70e29bdf61790c4877dd9e22ffd", + "0x5f131578ec5ee52b28c08fe064f728891f9d0f557e3b97ae62418e9efc1ab06a", + "0x4e1a6e4b411d6f4beeb3ab0567980aee8895068f33d0f7cf833e4bc4887a1b83", + "0x0b385e4882f89784f506afafe6dd217c6ad9d142ccf58713e27961d25b2c6d0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd1B572F9528B70dF1Ea79456EdC8250125f2d6BB": { + "index": 969, + "amount": "0x01", + "proof": [ + "0x616f62be32f1905613f2ebeb238917f22c1dd2e391b260ba2851d5eb5d2b3fb8", + "0x30623ea638bdfbe5c0f91a8c7ff1b7dc5e497ff57b36806a8c7aa063b45892f1", + "0x0d0aad0eac33ef90a443928440ec8982d70996c767cc18a515c491ce4412a27e", + "0xd1cbda0650121cdf56f6e9fac417e3ddbcea9364da64e4e29c3e50fa61aa56bf", + "0xdfdb156cb5d2b90a5253163570fe08739b17ab3fc383c79eb041c1d1a667fe84", + "0xf07cf1b0d415156d087e2a58f84bac7252fc35c72fcc8ea0edb033b09e3d67d5", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd29fe6DE1bb7A1Cf556Eec5Da5E4D708C0a806C2": { + "index": 970, + "amount": "0x01", + "proof": [ + "0xe93b97e105532e3349ac25c7792d3b4072dfd7c38558126cf94c839145e6198e", + "0x3b5932a693ae66b55ed2f426c0ad034cf08ceaa9a288d9cb0d4cdc3a64f73561", + "0x63334732b85124845e0586f19e798fe9b282285142d8b7ff24128a88ae98de7b", + "0xa26acb471e2d600bf69b92e87438242435f7a1ed8e490016e5305ddbcea64c2c", + "0x3ac4ae4a4697e2400113df3bd55f84456aff86925f45224af80fd8af20592214", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd30391E21741C54c32987bCfcA3D880E6D261Cb0": { + "index": 971, + "amount": "0x02", + "proof": [ + "0xbf2b180252cb1cf0a224e543d59b4a1456222201f1940b18d078a555a4dbe377", + "0xe37f7ef1706d6313d311cf1a70d91279eebcf121dd8d8a73dda9577ed484e35f", + "0xb8ba31195c91c8c313866172aa3210fabaf1ae5dc11c67181101d637d0e73050", + "0xde546e8389f64cf158f6546ecf18f3c473b0c5660810c1eba849db699f2c4883", + "0xbd7abdce9ec414fe47ea73146a2131622bdacb914ea6353abee1b0a149275092", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd35E119782059A27FEAd4EddA8B555f393650BC8": { + "index": 972, + "amount": "0x01", + "proof": [ + "0x3f8be914d7313e97cdf1d4ea635546c13a53e6ce8257147e8c3e83cc54b6e67e", + "0x7363075fbf25a3fd6c7617804466902fe5d3bdd5e9e32bf273be4f74fbdaa9ab", + "0x8f2a101ee77b78dee9cb982af71dce833445b338ef84d162c17a123bd6df03bd", + "0x2b5ad2a01fbc178584e521e2b2e5c612407bac24dd9bf0c452060b71384720b6", + "0x98ba92b6a1d3418a3c44b684c9f0dc2177f48d3a6b666334d112dacbb6f5acae", + "0x9034967b64aef98b5f62de29b9d8cde9231e75a0d2026d7927f2999bc27c2daa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd3F01D352aA3185F45929C20Ca98DD5074be626A": { + "index": 973, + "amount": "0x01", + "proof": [ + "0x095082856b6f0137e6e14dbe0892252b9ddd500e939b094072a20a075843e318", + "0x93e8f1b4da2ff8813f1b7c4b7dc1db73658754aa215c41ad9aab5d982079c1e3", + "0x4c45a6beb436ef04cc6902dca8ec98a6004150388bd0a3f1f3e1e8d205a1e2a1", + "0xc50cae5631fa8cafae8224329322dbaebc117b278a8e07f29104d255198d88a8", + "0x4a36dc66177a8394f6b14fc9adbe4ad7e0cc2dead6acb72d80990e336fef8d45", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd47016d69Cf5FbF3eE49A8cC1F061de2c276E343": { + "index": 974, + "amount": "0x01", + "proof": [ + "0xc845e1848b917bec4ac9699a71cf3ef1ae70c6389ba65ff3c9cadc3d58751e97", + "0x9425350b8131cfa1673b6fe8d04f90ffdcff25e015e4c94fa7ceafbadcbd6626", + "0x040429b9a444021a6ff7e6c6ecf5b7ad469b7bc2acfbfd2738ff037f2995c0d2", + "0x036edc84651a6e437d2aeddbd5e5d10d4911716f37c92c584d637f9f9ebb0dec", + "0x97fbe90108c9d6db20d511e4419e4ed044f589ef1f2a9f6539187bad21502f90", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd4f8a1BbEe54C1533CF0ef8C6f877ADa4dADcA1B": { + "index": 975, + "amount": "0x01", + "proof": [ + "0x38b26326d37c789a2c8a21129d0ed3e21ffcc76b09feea6be7bb383b23d2faff", + "0xb2a3a5ee3811ac9759dc207c4777dbd3f7d718388fc64b9d918b37b593468eef", + "0x96659af2623f9d5820946e88ce636546f77239bf7c47b826a73c1355654c5cdc", + "0x26d5243ad79c6ff0365171b12c8ef795d8c977a57cace1265e53f8b7326c312f", + "0xdc998377cfbadb1c2d77196acc69c259bcfcc6de58df7f5aeea2780a288f2509", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd507D4Af71088BAfbf2eA0CdB6962694F850DE01": { + "index": 976, + "amount": "0x01", + "proof": [ + "0xac5b12c7fd4873b19bb356be86c77647b2469e77e58a04edef233e36e109a05c", + "0x520475fa32c633832b3a9928245d557e745e205fec21d1f9021b7a82455ecc9e", + "0x547310dbf01783252ecf8dcb1f11da8552ff7f0911e701b5e17e3f8ce6679a4b", + "0xf685abad756fc52292f02befc3f5465de8d8f16cce61117b3f5de4fc38a60819", + "0xa952d1dc401036dd357d470bb699a7e9cfc64f0caf6dc51a638cd2487f5e73fb", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd56EE5Ba5A52e15f309108BDd6247C69B4F624C2": { + "index": 977, + "amount": "0x01", + "proof": [ + "0xe9dbe3261643bc6c68d2a21b25e693114d85c8d48b3d3a0013c47b5c41a0103f", + "0x3b5932a693ae66b55ed2f426c0ad034cf08ceaa9a288d9cb0d4cdc3a64f73561", + "0x63334732b85124845e0586f19e798fe9b282285142d8b7ff24128a88ae98de7b", + "0xa26acb471e2d600bf69b92e87438242435f7a1ed8e490016e5305ddbcea64c2c", + "0x3ac4ae4a4697e2400113df3bd55f84456aff86925f45224af80fd8af20592214", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd58919830Be1833052B8321021218F10d80d088d": { + "index": 978, + "amount": "0x01", + "proof": [ + "0x3c87334cc3dd2572b3c9fd8671475e12a6fe82324181d94e145e6d0b1837a61d", + "0x5982477f9dabd22fa394e30cfd71211bbabf93aae7cdc3bc365fa560eb10f929", + "0x7cad92e269fd399bb88a0e39909864292b3fbcd2d596ee1b941883a15cbe467e", + "0xaf86f597317f3202fff25068896658613bc0cbf9d7a66fd51e55c97f2358b8ee", + "0xb5bb98883f5ea232108866e1400cd4067f34fc2d70605fd2c67051a6095af7f8", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd59e99927018b995ee9Ad6b9003677f1e7393F8A": { + "index": 979, + "amount": "0x0a", + "proof": [ + "0xad659ba3cc1d0d7ca84e6fd191256fff4e5592d970acbd64334c8fad734dcf25", + "0x9607e1060d07f16010086b043ab302ad2f3781b1a171a1ed56fcf57f2e9aa2a1", + "0xd7ee782e7b8b92e8ee009d7874df94ca08040bfb250a415f26b44bde9008b154", + "0xf685abad756fc52292f02befc3f5465de8d8f16cce61117b3f5de4fc38a60819", + "0xa952d1dc401036dd357d470bb699a7e9cfc64f0caf6dc51a638cd2487f5e73fb", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd7342B4Aaf0Ef300334CabA5412692FD4e1e6165": { + "index": 980, + "amount": "0x01", + "proof": [ + "0xec6a8941346289f5da623e61f5c936b160af7f7e18cf7ae41752bca62c8e5efb", + "0x7c973e726223f392281bf4c449c5fe10d1bdde4121524c34b5caf331ee3ad0b9", + "0xc7a5709349e5e5daa302cf7bffba9d9d810a658db5159793c0ed38096beebc0e", + "0x338979409b1c886a92a48a505a3f0b093231b3d66119d999f9bcb41baf89c59d", + "0x6e496426985c92b04963088da4856230c781a975dbb5ce2d8eed77e7d2d4b58e", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd7855bA8A53951b064DA7DE0d07DaE0eed248547": { + "index": 981, + "amount": "0x01", + "proof": [ + "0x95060202d2d4c3f36febf0af67001ffc00db67b11c11b1cb959fe324fe7ea38e", + "0xf189869ed4cc615f4b5c374a77c9dec40714e9965dfbb0caa2919e5e69fb8389", + "0x1e8f6edc1f9dfa901b23584d944d29352277c21bd90680f8bd4cc7247d86dd9b", + "0xb27289c273000ad0db5ed9acba0b01be05f672a2f40d51317a96231114834c95", + "0x62ba7b58fd554e8be295bf9d4baf9eefd0b518ead5cb8bab321717a08160ae0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd7A44b55A9Ed0Aeed90fC66e22152356bF422230": { + "index": 982, + "amount": "0x01", + "proof": [ + "0xa92db69a598df9768fb3de31b526859e9a94a1a8e2ff5ebc9cca2ac018e1229a", + "0xe7aed7aa44b9186eebdfdc871e3813cd3472e8698837fe68211825dbc917efaf", + "0x94d660904dde29f38b66932719fbb6b3f61f23334c6bed78753e9db544ffe1da", + "0x68141ce9c9d3196b1db61f6e6c902aa8569304d1613ec750ac0ffed8af2bb113", + "0x32636a5315ca425c602832f925f24426ea5aec9939c73d1b2a6fcdace85ecae8", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd7Ddf70125342f44E65ccbafAe5135F2bB6526bB": { + "index": 983, + "amount": "0x03", + "proof": [ + "0xa6e782c2d3cf6a7d8f3e7c1f5df63105215f8128a48cfd512b6efbd95341c335", + "0x701a70dc7a9d2ffcefdbb1ba00a9f529929c3ce9593a76e5fa4328b4f73e6012", + "0x745fb65ee3248ac54928f37f35bcfa2f7104894c9f61401a249bd637620389c4", + "0xff4bbb2da92e4f9e24f8d79cfebe3e93428702c14b9f4cc9993761fab9d19c9a", + "0x59d5a4275936eb4dfca0d17bab02b4a25bd4dc43ef3aa0e3515a07f7c0f68a93", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd836da33a6629548271eb9ef4f62D083376eB4A6": { + "index": 984, + "amount": "0x01", + "proof": [ + "0x0a47eb58ec3654a36888a91329807706343724cdeafe18f3f3caef48e387eeb3", + "0xb401b90c19bb8b2496a8fd979f240a923c20b7f409845d553fd2ad67fe7ed89d", + "0xa0af5121b49fc7ea34ad1f4c8308fd6e51803abadb614d1f15f8c87bf9fe29bd", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0xd87D47b3c1beFF62343bEC54A740157f4e13A618": { + "index": 985, + "amount": "0x01", + "proof": [ + "0xabc84fbe237e889d231bd09a65020b240c8a4f595d952a2e01ce27d09c7a3066", + "0xf7eaf0a13cafa52265f4c34aa29e1918289d49a85bcbcc5eeacf9e8df51452a2", + "0x2d96d77142897c826da134ecca3727222ddacbe2424e5b5b3155c87241c4bbb3", + "0xd7f4836e54488e91267fda42072073873c17b5d47a5a1cb5374c07d89c92ff21", + "0x32636a5315ca425c602832f925f24426ea5aec9939c73d1b2a6fcdace85ecae8", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd8d10abF300356C7915C8d5Db33F0FBdcfD603C7": { + "index": 986, + "amount": "0x01", + "proof": [ + "0x8092f54178c1b9d8edb0fe57c94816971e409e88c61160ac4f6e71b9d53d426d", + "0xda7a08361527692b975ddf8c69bdb8901089049f8d8ec813655ab8f38559ed82", + "0x5ada5cfebfc9093074af257daae2c61d27b871598065cd29bb9a6790903c5c37", + "0x138bee476bd8ce498e2985571c0fd10b392ab6afd8c1bc3ddfe5859f552044ff", + "0x891a74fec62a569bdbcb44171dedc1926c5cbe5d803c0c17ff419a861e9ee5b3", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd912c21CA7C215594ce55de8080a8cd6b7A0216c": { + "index": 987, + "amount": "0x02", + "proof": [ + "0xc64f781bdbb354703bbc71ca203be9c706fb229f4ce69c4be93e08e8ef15a1f6", + "0x2b64ddb2d6ce7f4130fc138c55720e30e85d39ac94dd192b0bc1b5efe236ea3f", + "0x28953c726ef8579e21b5a30c7fb4f81f31e6a2af517a1f8948b50dc1a62e1f25", + "0x99930015299a0435807ebbffcd0957a02cf6631c31c05ff8ed9a165cfa4bf8e6", + "0xcf22c1d43a94c7c6471efe1209a3b103ec0a9836b6c11fe8d2e98d18b2e9cb36", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd965Cd540d2B80e7ef2840Ff097016B3A0e930fC": { + "index": 988, + "amount": "0x01", + "proof": [ + "0xd13a225bb3228fef5f8ab520d6db449d0e3546b1356fc0dfbe7894e8c44131df", + "0x284138aafb11de2200940127ef6bc34207a21e77ade6707bebc808d0da57ab45", + "0x290beee419f0613b459c711e5b28028d47a7d1917c0eb36c686bdc2bb4991683", + "0xd549250cf81d453ab878cb87d004bd56f5975ca86398b00d651f71d522925a30", + "0x85ada07677b521b0dd2e0d60f51f92f7b1217f46e36379a5afa5a74fd5c87a5a", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd99C4D61F385327eC94beB52244166003287C1Ad": { + "index": 989, + "amount": "0x01", + "proof": [ + "0x32049f14110fcddd9d0853733adc723bdab48a034ec65e8ed7496cd23f453e24", + "0x472ffeca31479b90a1c5b0604db2e3f956e42116fde5b789cc9af1f2d63a1a43", + "0x7f001521588dd2e8e4ddfabfc157315a28fb70b9eaa1e5f5cd46420a6a34950f", + "0xb74deb44e6419575dd75ff4fb4c2cc26c6f8bccff72ef47a08f3f27e13f3de40", + "0xd6d09ea62a0a0959d8a1f1cbd849b805597a75fe443bbbc4d5e2555bf8225437", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xd9fbb755D859c8026abA1b64F71ce97Ab594644d": { + "index": 990, + "amount": "0x01", + "proof": [ + "0x6c6b1cf236bd690007cb28a116cc2b3d94c6e2fd0f85234c062d278d0e92b77f", + "0x00438b89eb39a97864b6673425e53c07a0b0482e54cad2fdad1574c1dd029444", + "0x9d1bc2241ac02056b61650ad7cae67788655e09d14f6f80d511bc28bd1f815ee", + "0x283f6032b7beb32fcc6ac4b21c9941360bce453787f78b6251c38e3890b83a8f", + "0x1be60ce906d0d73954b2e1f2747ea1c9a23db0ad9345fa6801c551f1a39fa5ab", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xdA65E2Cf7D9625c6BF95B0216404eE1279870c52": { + "index": 991, + "amount": "0x04", + "proof": [ + "0x9e3036ee0ec70e4923849e9988fad96d1d82da2baa51b57daf3395c4540f9381", + "0xbd5066563b0f07b0bcd1391846fcf78c20b799e36a594302f59213eb6de38384", + "0xd32dd306d1f42a39806611081f48b9b83cb4608e909a84d098d91b13868c6029", + "0x35b38a743320b292e89d9164e2c2e5018fa2478f9a132ef65671c9bacfe611e9", + "0xc36c52715656389b2693c145860adf3b1f3d4d24a139850b1fa5f2236456376e", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xdB37F10620B9FBEAd9246af04a3a3d729006210e": { + "index": 992, + "amount": "0x01", + "proof": [ + "0xf83e2e7e6a655eed24b50202db20885461cc8a31e32d4c29ce00921cb831bbcc", + "0x4a623cfbcfcbe221e8a159248d990832cafdc103aeba88ea631fb97edce82695", + "0x9bc46200f73af0c38de14df3f6eddf911056a5df16ad70b6582fcd96bb7e45d3", + "0x3aebe8d88cbaf4043e28b3d6aad9a1f79bda4dbadcd2f685785a58d155fbcc50", + "0x8e7f75ccc4d864471b1a7ec71efa29a4e8cc4761c26a6987c8043d9ca642a2a0", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0xdE33e58F056FF0f23be3EF83Ab6E1e0bEC95506f": { + "index": 993, + "amount": "0x01", + "proof": [ + "0xfcad15087b647faaa0e235894634aa5a1a3a694e8bb2ca10d3a7fc012527bcb7", + "0x7be7868b8dc3c4702434fb982f4d3c5fde1d840d056ba6f423e837874ed4383f", + "0xa7b1364c89574d145647fe0631d469a646bcc060519ae25e959ecafa4f17d9bd", + "0xf7b15c813ccb2cfda0fad7314544180ed758b3ac0213d482dfeb48697c2a487a", + "0x938890418edfff03e5d8f0abce65769ab79b16db349d2869a477500717305360", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0xdE5Ba71a0D6C2bD74E52819A44689E40A883a954": { + "index": 994, + "amount": "0x01", + "proof": [ + "0x04a317a16df74d3ee0301b0c37004d693e6eb16e95aa938fc68a620c614a8790", + "0xde1c042ea62a5e234f17de53658b441c698087f124f858cb9ecda7be560f347b", + "0x3b9ae731fb4fc0a972a141d2c931c7e4afe1020d11bb774ef3a217e73d2e8b23", + "0x2782f91cb56c53bb349c99893dffa8838299f03f96c6519b56f604653b45586d", + "0xb18758ddf98cdeec3d020c2379717281f5c0fa0133be7d006f7f753c756da43e", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xdF24B20bf86Abd426Ec33A913da6f65429d80389": { + "index": 995, + "amount": "0x01", + "proof": [ + "0x0d5c969c533070c353b2d0be59036e7cab8fe8db24471853afe46f18f75240c0", + "0x58a8c0d78de7d1c7ce1e55ad130b6552b29126a42f67d9d0c724c2c0062f2b7b", + "0x32079f379faa5487ad026443f33416fad7496adb5ba59317ada9083a771610a5", + "0x037fa491e4b6fc74b9dccf3175d28aed9f5dacdb75dd0fc8e1154a0704619620", + "0x4bab2069d20a5d1d2f5ebdb61803a57609b7709eca9e925e31a7d14434af1326", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xdF4DD7f972926d7D82b8a3Bb3feb5254c368045c": { + "index": 996, + "amount": "0x01", + "proof": [ + "0xe1fd613050078e01423a35f496f152fc0e62cf539274f1147630e853be8873cd", + "0x62593cd2ee85631b3a0807d19161937223de09b068548e5ca4134cdfee82928d", + "0x48e789a37f032c18f647b0c6b852a88e29403e31c0f6bf94215b72507b16fbbf", + "0x60dd57debe01b07f2150f54d637bd8f574df12ac003a445ad012509f5b619671", + "0x966715df220dfbe5e11392b257b61b64c18178d1825b654f95f67d7c9558a2a2", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xdaa59B1316f37cB925611E3C95b739F815194f1F": { + "index": 997, + "amount": "0x03", + "proof": [ + "0x8314ad0e14d45f461a1fbc5e71188ce8dcf6688cf0ebbad2eb0612748f623e0b", + "0xc795aa78d3489fef0249708334eca5f50ae6b1836de13fd7dd09eb6599a9bbb4", + "0x4e10e7f195c67618f3d3a7993df508e04ac06383b5ec9580c6c0aa53b1917d0d", + "0x13c4723f9c83e02f8e5d7f08a17afc4776844c18a0189a9fcccd2702d623254a", + "0x891a74fec62a569bdbcb44171dedc1926c5cbe5d803c0c17ff419a861e9ee5b3", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xdca628CE9699500191c37D6A4d029bac9ae76447": { + "index": 998, + "amount": "0x01", + "proof": [ + "0x68022b0fbff3573d90022fe5f7c187db65a45578f8ef928c58247bb3fe8085be", + "0x97c4a13ef90643fc14b83e447b6db03e2c2dbb64f17fdb9b0d3f7a47b8de3e36", + "0x12739444750a786d216e7862d022a412d833ffcaf4cf4f6b1414e14f4ff27db5", + "0x5fee000564bb97bedb499d3b5c01f147f4e4ad76f5f6443565804721f95dcda3", + "0x245190f95f5e09d43d1da7e9757fa066be1942b52f7e4962cbbe6a5f2e0981bc", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xde208627B38b9795284efCc14D8B8C313462876A": { + "index": 999, + "amount": "0x01", + "proof": [ + "0x832bc98bafe787e4cfdd65a273ead5eddc5629732172fc6c3b865b76dc2412f4", + "0xdfc024e199a4fdbe2f7c0991bb79aa5ad167912a6fd038507cac42419b402b95", + "0xc1327fd5c0d304512764186ee58b613917e50f9a632100c058142561a8ca2611", + "0x02cef8ccb3c7906e41a7ed9d223c95f320f2860a3d5a5dc4598d02362970eeec", + "0x9dda7d74fd49fdacbeb3afcd37c878516159fe4b594e491ff7ecbc80fd8d6808", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xde655D29A0098Cbc2C80945F0f1338d43A4779A1": { + "index": 1000, + "amount": "0x01", + "proof": [ + "0xd1411c6c905f4b4b12ea5e65ea3ad717c19a7f16ee5b12173289267ab1fdc6fd", + "0xd89cb7f045b5b24e579216c7ec90a43a96a6ebdafeb26b08f47769dd973a8e5a", + "0x290beee419f0613b459c711e5b28028d47a7d1917c0eb36c686bdc2bb4991683", + "0xd549250cf81d453ab878cb87d004bd56f5975ca86398b00d651f71d522925a30", + "0x85ada07677b521b0dd2e0d60f51f92f7b1217f46e36379a5afa5a74fd5c87a5a", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xe085327c5AD2F77147F10973Fed45Fb19d734F7e": { + "index": 1001, + "amount": "0x01", + "proof": [ + "0xeec6dca0548fb98eefcd29ad7e1fc49c1f2a3eced957813fb0b754e65753d238", + "0xe4c720a1a55551d11e715aa0329811976b18a8448e42ca24e51c05d4e75c1fad", + "0xc71ffc537d3b73c4d65d5ec902214853d0ca3a6ef44a38e578c0f12fbc4929f0", + "0xfbd5cea7e1eb5806f6f82efdb0e881576ab386159b1b3ff7402e4bf56a947d8c", + "0x58340ed8edb441d787ada6b1aaf2b1e42912724e1f0f7887cde9253262aa0534", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xe14475023852b17530813376E9E9D1Ee04C494fb": { + "index": 1002, + "amount": "0x01", + "proof": [ + "0x959443ccc340731f237dfd5debec6e42b0b20ee8e7239de73017dc21eb1c10b7", + "0xde1bc7c03fdb02b201652e08a3a21cd6746b818430c282326f24634230597653", + "0x1e8f6edc1f9dfa901b23584d944d29352277c21bd90680f8bd4cc7247d86dd9b", + "0xb27289c273000ad0db5ed9acba0b01be05f672a2f40d51317a96231114834c95", + "0x62ba7b58fd554e8be295bf9d4baf9eefd0b518ead5cb8bab321717a08160ae0d", + "0x064f5835b1342b0cd5092b852eeacd74b4aec20fc84ce2a9d5c6ff8383d199ad", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xe1D9298FBeC55da67e97F344DfAF9a30F5eb4331": { + "index": 1003, + "amount": "0x01", + "proof": [ + "0x0b5d083a75e4da4dd65c5c4d08a7fd82abbe14b5bbea8a8291e76b8f73995578", + "0x4f58d6143f73fb3a2d5821d44aca4ce7cbf936068923669d604272d59f5f005f", + "0xbfc26260b7e6983f90908bd7c4dce14d82539f1d2bdee73c0034e9382a6e10f8", + "0x979cc6c181e08190bb233f0cf5b0f7b487d9aadc675c9326a9af9732d3369d45", + "0x4a36dc66177a8394f6b14fc9adbe4ad7e0cc2dead6acb72d80990e336fef8d45", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xe1eF9A086C359162B6ff7B58B42Dd8d0989875af": { + "index": 1004, + "amount": "0x01", + "proof": [ + "0xe64f697f9e16689455570e6d4969eafbaf5272b0e818363535058099af72fb1a", + "0x8e104a6c7a1de0e900eaeea9af8d3552c61b75ba1bf6abaac237cb9be72c64dc", + "0x46620257535f86b53d54bacefde5f7e5ba7d4ccaf37a80ee488adfb5afabf427", + "0x46903c3e0f26b709802c8a2743505337728e1f805b4f936ec91df4b3f43fcdb9", + "0x7a545b345b30e441bb780a4fca731a87b1e941b75518a9983a312194a9e7bd46", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xe2Bb94210B41Ce4c01B9B97f3Ac62E728E472f9C": { + "index": 1005, + "amount": "0x01", + "proof": [ + "0xcde77826624f91b0861434e0add3b365d29c0238f4c994e58a214d6f7854beb8", + "0x1f342de2928cc7674f737763ca390af80258c8a948b47cc6218acc2dabf34851", + "0xe8a6478d83d6e44010f2e45c5e73a005e8a6798d300da5af9760a1a7319a59f2", + "0xef33e9da5226ecbab5796a616b47d5f4223c729722fba46a5cf043b7bdc381ce", + "0x2e78635a0ed4a14dadd872d564c5dd2afc4f21b0307932d27d4471c48082b7f3", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xe32EC808E1A3FA31384952476070678fF0787e69": { + "index": 1006, + "amount": "0x01", + "proof": [ + "0xc7f9e8e0e11b288493126f69f2b538ef335fceb795ee098b8e0b93884a649be0", + "0xce20e2ce6e6d69622450f3ed50b2230b0d0af94185588c000469352bb152a017", + "0xe4ac80d26c77ba89058dfefdaff6c557a8b7b9a413abd87f4e1ed3224c0d25a2", + "0x036edc84651a6e437d2aeddbd5e5d10d4911716f37c92c584d637f9f9ebb0dec", + "0x97fbe90108c9d6db20d511e4419e4ed044f589ef1f2a9f6539187bad21502f90", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xe33931Ff58cFC8c828988e881F27a4b034eadd84": { + "index": 1007, + "amount": "0x01", + "proof": [ + "0x19236ac273b02ce691219ad4fccd86edae6ebc255b77928602fd18d40f29adc3", + "0xb25cd9c460d1c120af4f52034d5cb37afaa7dffda7bd5617dc929e90eb37e713", + "0xf9aa43102404b84f14eba6125f677ccda1d14a7d5704168958698912672e9e8b", + "0x9259974d28cfc23eade84b4a12eba89f4b5d3b0064ca7ad3dcf3a6a6a2555c91", + "0x93994074bdd819d668a79fc2c79be23cb074a679cd3fe03940945d4c6f9fa9b3", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xe38F6399508296B485cb05560c7a504f8C5725eb": { + "index": 1008, + "amount": "0x01", + "proof": [ + "0x0236a3112d104890cda31df442846e4d4c501d84d5dc382ca690b87038e8b8d0", + "0xef8ed33b0380fa88ed37d439e93900b61eae6b8144c8ba1df2804352ef4dc1b8", + "0xa4fdfb9e13a8933dacaef17334dedd3721c4ff7bf3930be481e987c2b288d052", + "0x694db95f2efeaf59bc0b92d1736ca407eeca00ef7ad545f2c27ec99a059b74f0", + "0x9be1155992502d2b75a54fc5b2a41d663a86f7d329faea1befa0e24965b01a56", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xe4C70c070Ed7bB39dFf82DD259a9E8AEcF7461cD": { + "index": 1009, + "amount": "0x01", + "proof": [ + "0xd6259ce2f3c5f1bbc5b429416eb5b4a497e89564a6ac0ad5a7decb921f939c94", + "0x5f173f4df62d2d177a611d4c4cb56bb8556378c831d0e83aa38cada3821095f9", + "0x19086762fd1965edfc2c6f8d382a94ec7bd76977d80206b5dfe7ff81c35524af", + "0x295b1cb76b1ce79cd1280bb1130a4264534288edb4c264d45d4ab36dd72b36ca", + "0x7e73f337249898d15604f7c330d90e36da04007407404a4b4276d5fe3083b929", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xe52431D5dB91a0e50B6b071BBf4b816e7D1735D8": { + "index": 1010, + "amount": "0x01", + "proof": [ + "0x934224a87dbf0497e69f882be0c5903fb1e73b2a1f297dd2ea46ce9020b96090", + "0xd0d777fcf3eae923dde55021bdf0c753b10acc64f994c9f743802c9d40d7f0d8", + "0x416fc24a2fc25ba59a366a12617fa61dc7d155780e7b0cf47d4beaec91fb9776", + "0xeb79377abd71cdb891e1379260c8fb1947760c17e28c7168ccd62f5d772f861a", + "0xea7c0076ebef0c429d544548828ff19d5600136801cc28845bdfa9990d97a058", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xe54f740C9fad814dcE458610c2B465af0DD5D11f": { + "index": 1011, + "amount": "0x01", + "proof": [ + "0xd626cc5480230495fe8df7d831671b30087aa5a396609869126a501ffdb9f184", + "0x9a8c170967f2ec100127e9fa78d82a6e68ff7867357e255b43c9e2b64c9aba89", + "0xf1ba16133c06bfb62c0f34a7f2c60b2d060a7b428988c8f8b9683824c0eff3f0", + "0xd382b6f12ac3804a083f91e50c5b4faff460036b8bbe9e3c74b4468370b346f2", + "0x57a1600e1002b648fc38956dc1d2f34be5ee3f6cf170c73bd27c43b2a01e45db", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xe5A3F1e72D1dFa5C361516AC2779E9602106fEa6": { + "index": 1012, + "amount": "0x01", + "proof": [ + "0xae7675947807792ac3c9bfe322267e656e252af83c602add14c5c17395937cfb", + "0x93b3607fa7be6339374e07e6fc6d62267063a0070e298250f7e97dd354ff9796", + "0xcf221106eb3204d78b5ef9028e613c93c6b7a5954f19a30ac14d1d5567f3051c", + "0x298bc701f239e72f83c6fbd5aa5172caa103b1453ebcf9fd1dfe23628f4dad14", + "0xa952d1dc401036dd357d470bb699a7e9cfc64f0caf6dc51a638cd2487f5e73fb", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xe5E8aB16c1EFFCe2947d8Ed1Be0adeFEd38e99c1": { + "index": 1013, + "amount": "0x01", + "proof": [ + "0xe66aa97e948d690a524f7256f6309a2760b7f05a15f6c56ff18bcfe593b220a9", + "0x68cd967fb4360752099fe5506c783a0ff76903e24668586a2159c2f2952cbd51", + "0x1a4492318b217e4bf203e535736df5d575d869a4d6eed45535f3a69b1bc59f98", + "0x6029ed468a13d48547faf514f4c29ae1fc65bcefd1ecd17c26aeef29ec044356", + "0x7a545b345b30e441bb780a4fca731a87b1e941b75518a9983a312194a9e7bd46", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xe64E80a1BF85e479F22301ed9893a038310D6D76": { + "index": 1014, + "amount": "0x02", + "proof": [ + "0x30fae5cb212038d528887e20b76a591b4039450ef7c57174750e4b4898cc945f", + "0xe3c03f472eefb48125de49e678cb3cbfe265531d0aa112ba2cddf16904716926", + "0x84397224dcf960c935f9f1d840b696834d2c96bc90fb990bf0e58178e4151092", + "0xb74deb44e6419575dd75ff4fb4c2cc26c6f8bccff72ef47a08f3f27e13f3de40", + "0xd6d09ea62a0a0959d8a1f1cbd849b805597a75fe443bbbc4d5e2555bf8225437", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xe69f5958C990b642ff7F28Ddc35fB085032d9aB2": { + "index": 1015, + "amount": "0x01", + "proof": [ + "0xa2a19aa6b83fbe33f6869ef48161b07ce7ad311da712e06e6cebc131b082f249", + "0x79ec05ec13a307e7f5601eb6bde69b5ffc24db29a4e4b2481393ee472082e482", + "0x91479039fdbcfe3f9e57c85a35424ab551f951e96197067348c757ea7407d64d", + "0x9d1cf6e9f51d85a77dd4eec2524ba22941ec238f140f4f63c1712d78c1e4c21f", + "0xdf701aa8bdb3ffefff1b359214087cc585fa0a0d40716a6635a8d2db4380dba1", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xe6f3fd8ABB61ca6417D386e67e9596c3492D49A4": { + "index": 1016, + "amount": "0x01", + "proof": [ + "0x72b5fcb8f100c8ed0a669820589980a5a1438d2a73ed9e39aefbea2d9fc89ac6", + "0x2182370a1e13111884e9e0d103fe6916c45bc8b8871e94e2764e1243cd3dd58f", + "0x8e6c137a880fc95bd5ee7752b07878a345c6c782dd2c5f54cd1429db575fc484", + "0x0dcce906ec5827bcb3dee3fc162b46bcd945486f9b95e6d9175120ea721c3e19", + "0x7abccb934a7f719fa80b9a5d3157e99d45ee17a391abf85d4f60839dbf3769cd", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xe85D541ae83d312F74355D628F91D7fc28C46dfb": { + "index": 1017, + "amount": "0x01", + "proof": [ + "0x3226a14937276259c87d498f8437d6f937aa6c18ff66e976aad28faffff4ddcc", + "0x472ffeca31479b90a1c5b0604db2e3f956e42116fde5b789cc9af1f2d63a1a43", + "0x7f001521588dd2e8e4ddfabfc157315a28fb70b9eaa1e5f5cd46420a6a34950f", + "0xb74deb44e6419575dd75ff4fb4c2cc26c6f8bccff72ef47a08f3f27e13f3de40", + "0xd6d09ea62a0a0959d8a1f1cbd849b805597a75fe443bbbc4d5e2555bf8225437", + "0xdeb7eb022fe9dfdb64919bc3ed4bb07dca6fe13313fe088696f1bf34f45e5413", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xe88663F5878Dd0967C905EC8c7Cc65d6d8e091E6": { + "index": 1018, + "amount": "0x01", + "proof": [ + "0x03343ea97eb362576d488275e40b022989b81222301b90f3671128fac4285a94", + "0xd6702010f79e4804cc549aee31f21eae323920b7067d9d2161c8c5e240bf76e0", + "0x473c279a80efdd22e0652061508704656dccd4cfb6e1c6c4e5d7b17c2a8e4eaf", + "0x2be850b7e0b2b6c90dd3488b90e348653e541a9cd2983b235559153dffffe1d2", + "0x9be1155992502d2b75a54fc5b2a41d663a86f7d329faea1befa0e24965b01a56", + "0x984bdec8da223da4f4e12e62e6e7daacfec4f7904030a672ade79793e2709355", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xe8c7CF37b998935815e15A534d21B45e2dE5d015": { + "index": 1019, + "amount": "0x01", + "proof": [ + "0x798f975a391853a7d419be422db020283b5d9f66c4558d5fc3e1cba5e815c101", + "0xe309338b5391e2b4fab0fe3a446c3224074ab0f17060e12ca3326c1a737aa1ae", + "0x3cf840f671484c5a4854a9e7a16c73913cc5e1ae358e160566aa35e0ef06bd1a", + "0x9b12cab9303ffdb5818321d84969747034ab90e273c8fb6d0031d1f6e3e1f83c", + "0x80cf615f05f15e9ed665dd7df5d086fcb70ed5a5086e02db7c08752fcaab6507", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xe8dd23472f9CB963fdaeE7c1fc3b6900c47c73F7": { + "index": 1020, + "amount": "0x01", + "proof": [ + "0x1dee6e0fb189af055f8f1876f2d6b3a818ed85187b0cec55a8f286dedf049e6c", + "0xc91390643b5fc24c58ff0d2dcfe1a4e0d84bcb8f45f2b213e0861fcde3ba6d9e", + "0x1cdba9e91cea35b2840b706aed8319a24d18d06c2d7b29d63283aa5645e5a6cd", + "0xaaf60b5ecf22563f090c456c87a77833a8ecad31ad25f79ce590acdcb7f64b01", + "0x8e0cc5c13324dce3ab0f042d31a9db04afe0918f70e3f4515f43739791621c97", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xe9017c8De5040968D9752A18d805cD2A983E558c": { + "index": 1021, + "amount": "0x01", + "proof": [ + "0xb1462b9128efc15adc83c045fc43396589383894471ff5ce7896d4e28191ba92", + "0x3d20bf045759d6113388821ea6575275e0487132b6c2b86adf8966ceb779820f", + "0x29019a0cb0bda0ba23b44ca59094eb26fe840748f490419f63051f2087caee0d", + "0x49f4781ffbed71f831627c02425eed106f4714988055f5e0978de46ca35b3ae0", + "0x72373ecc225af245878bc638c49c8901db1430b7210a3008231acc8f8118d2e0", + "0x1a31957cab0ee192f023bba3088309b20adaa87c65388b4487fd805f6ad261ba", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xe9B0ADdBA12f4cA92589668956b1089d1fDc766E": { + "index": 1022, + "amount": "0x01", + "proof": [ + "0xf2f28d9faf023914fbe577a719b0a7ec227362cc7dfbc7c1219cb932608034c1", + "0xd9e05ba09015e9481504b532a6a889bed7b6b1bb2c80ab50514e9d57015413ba", + "0x4fde23ae7d8b91b73ed7665e54d03801fd1fde8acd49d16d146cc40a2ff9295a", + "0x7caec6cdfba66dc7947ce7a10af67bf36737d573f70c5bcf73b71057ac86d1f9", + "0xed5c942adbfa1d9538c55e89e4a7ff4276f908ac558913b5f43dce424bab8e0a", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xeC0B8e807e581d59aBb1062C61482361A87Cc392": { + "index": 1023, + "amount": "0x02", + "proof": [ + "0x5a1617f553acdca6b56add3cce483e2110edac391b845611b618b2b9f28163d6", + "0x6bf71dd96dc520ea1d4363e86e4f952fb827872011e1c93a08d9852877a38a6a", + "0x97f948eaa1e0aeac34d319d612cd62bd5eb49ea9df89012417a7fa4f0b73a5e6", + "0xd34d09ef2d0160dc3204b5dba612749c3a92de5f38fe30c9dfc3d0d199e36074", + "0xf9f105f90db6fe2970fb4e03b35654f9b69375879c783d3f1700e04b2e2f925b", + "0x95548415aa9a16b2182f2595112f2c39e9757596c6948fbe1e263fb05160c5b2", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xeCdE04E088828c93a1003b9388727a25C064e5e3": { + "index": 1024, + "amount": "0x02", + "proof": [ + "0x78b5b59683d92f0393e6ae4f6ce3b7b4ad4a3e66931421ba76bc03c36ea68bdf", + "0x4d916e54bf39855ec598f38830389e269e7f442b31a226fc8702ffd15d59d0ca", + "0x430e9eec036c03066fc0319049daaa271c11c2e68b105a49cf5a3f241fa703d0", + "0x9b12cab9303ffdb5818321d84969747034ab90e273c8fb6d0031d1f6e3e1f83c", + "0x80cf615f05f15e9ed665dd7df5d086fcb70ed5a5086e02db7c08752fcaab6507", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xeD2C2CdEc695be3A4Dc421c1A8a6756dc5A927b6": { + "index": 1025, + "amount": "0x01", + "proof": [ + "0x3c827d522ea91f5562e532c570dafcf1e7f85ec6876b70a7494eaf74a8145f61", + "0xa06cde13b1bbf2bedb4ba3c34cc18c4cd81a80642d76795a73f7b6889b1de1b9", + "0xbeb2c810887b1f03a89248c556855316973dd3f9f824dd7608a2162c3b2e6c6c", + "0x0f96aeb97a653e888416c064689ed19e2c4f980fba2ae619d0c47550168b385d", + "0xb5bb98883f5ea232108866e1400cd4067f34fc2d70605fd2c67051a6095af7f8", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xeE45068a80ed0c086517BEf6B2d323699c0f746B": { + "index": 1026, + "amount": "0x01", + "proof": [ + "0x551eafc3dc55838824efc88d94b101b85cdba4a6ba7f939ac5d7fbf37f2f8c58", + "0x8c940500dfb9a5194bc0ab633ef9966c4fc296a8fce41bde7ffe0b3f67f7fad3", + "0xb38048ecbdb0d7a97188f59825c94f13ca314f4be11d86febd1cdf302e0326ad", + "0x9104efb4441e61a09b4e458e6b45f6759c37c20733b5823cc04f759cc53d5575", + "0x6ae25cafc683eaf0756d86c89deb0abecfbfd01e812ffbed4e7a26f11cb91f8c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xeE98342F66765d2170dBE6Dfa9bc4Ce36fF3162b": { + "index": 1027, + "amount": "0x01", + "proof": [ + "0xcc8e4ffe14c3649336e77b15c177b591c547987051eb82d34608094e1d2bb3eb", + "0x31f76a6505bf96c91720a067f25fa54ed53ee8f7085494c0546bbc204fe10c46", + "0x283f3fb0109ecec757290961e9c3e0c9092dd7697857daa95c6c89647800e706", + "0x9bd1c3205e48cecbaefedf96e5d998ea4bb84adb658c966bfa31e3599a4a0ea7", + "0x2e78635a0ed4a14dadd872d564c5dd2afc4f21b0307932d27d4471c48082b7f3", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xed46a40c088D11546Eb4811e565E88A03ae8a07c": { + "index": 1028, + "amount": "0x01", + "proof": [ + "0x3b5f39f0a70c89fb55d1ed15770d1ee8a3fac8710c7d9679866c37a6de92f3f4", + "0x542c5f90b54a284b6731f393940acaf25d1a3f38f27d8ffea681fa179d93fccb", + "0xc2aa8ca221a28e31ed71a4539c43e41e94c128f08a109bd6a1b093e635ca88f6", + "0x0f96aeb97a653e888416c064689ed19e2c4f980fba2ae619d0c47550168b385d", + "0xb5bb98883f5ea232108866e1400cd4067f34fc2d70605fd2c67051a6095af7f8", + "0x96603d3d5ad7d01c80fec4a1a42863156fd7258bfb69bd3428e30dc28ab03609", + "0x453903488f5b1b1e5bebf753a59e32b40323d5e029c237fdf7f1fb325f6e8d94", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xedf562E5349807704875Fc52355209568f86CfC6": { + "index": 1029, + "amount": "0x01", + "proof": [ + "0xab6a4ee0e0e91ad3488f7819dbdd25db447a28f4b5c7961acaa39d146f4d2fd0", + "0x372462dbeb6f261d343ec5bb98bf18b9a0823c925379516bd354cc27fe1c8a5b", + "0x8d09decc88251c44f7a49a4b85d4449eb023b2742a6cd38b9c5de1b9936589c6", + "0xd7f4836e54488e91267fda42072073873c17b5d47a5a1cb5374c07d89c92ff21", + "0x32636a5315ca425c602832f925f24426ea5aec9939c73d1b2a6fcdace85ecae8", + "0x120ee079303f5afbd492c1f7d47a08d24f237d46f33cc9fcf20df2dc0aa5a944", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xee944Ab7E1b78F5BB89C745114D52719D2792558": { + "index": 1030, + "amount": "0x01", + "proof": [ + "0xdf6b2c156ad6803a948c4ca72e208e6ab562488dde07d20c35cf3a03e0f66499", + "0xc41dfe428693dcd917be2116df24c4e4eb6b01e19c2087e0949b91fcd731e59a", + "0x1b6e78ed9f82ec1c3081d1383366405b44866f8b35969ff88549384d481f717c", + "0x285f0861eec4fffdb569c07f6f01125414c98685171578e7317ed5b8c16ba373", + "0x966715df220dfbe5e11392b257b61b64c18178d1825b654f95f67d7c9558a2a2", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xef8104c1F471C1995cb6F7276716E8B38dc1B9A7": { + "index": 1031, + "amount": "0x03", + "proof": [ + "0xcbc484764a872f365285dd299d24715f4691d9622961869915071b700c74d4cc", + "0x6c22ebb02fa693c6f07e126e470d434a0ad3501cd78e6792ef766a226adcb4fd", + "0x44e28972482d62299900dbde770b7f615c2062b558ca8938a3d427799471882a", + "0x9bd1c3205e48cecbaefedf96e5d998ea4bb84adb658c966bfa31e3599a4a0ea7", + "0x2e78635a0ed4a14dadd872d564c5dd2afc4f21b0307932d27d4471c48082b7f3", + "0x152086d53590fcb64889e7684a10fa64d15f4c231e9c81da0957446802c605a8", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf14C5c02758dC98ac86b36060F2124F3BeB72ad3": { + "index": 1032, + "amount": "0x01", + "proof": [ + "0xefc862860d301d765e3485a050675f14833854aa48235282c0f7ab44a77df88b", + "0xf032ed1c19fedbbcb01ce00083aadbc9058bb1872bed143077449d597d0a17eb", + "0xd8a35ae28db7c81be0f42512143e3c242b1425823caa2703947a88061459e211", + "0x27cae8e1fac7b32e83e85494312638757cf1e0afea8f4e6fe77387c412b4efd6", + "0x58340ed8edb441d787ada6b1aaf2b1e42912724e1f0f7887cde9253262aa0534", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf17441352d36a537c36dB7782B7f08651fbBD86F": { + "index": 1033, + "amount": "0x01", + "proof": [ + "0xe38d9ad873da315107a3406cf65bfae66cbc46bbbee632113376fba6bf130e1b", + "0x7d9d2db086a88d5f428032898c3ad694fd7372e8ad39f5b65684a786e6465301", + "0x567f8f869bafb76cdb1e5c86291783cf3bb6dc604902df31bd0f815d38e36ed9", + "0x1bd24f0c1d9a337a197e1feb80905be5821f1e64457aba030d18aca78646a08c", + "0x7968b2383e3b914ab3a36580b205f1449b51563630c77871f712e94743e3bf39", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf1c219204810edea94406c69a06Bfc91d695D1DD": { + "index": 1034, + "amount": "0x01", + "proof": [ + "0x691aae2d450c0adbe495061be2f0058bda4b08d611d9c5a67a65b4a77e68d712", + "0x575ec01ee64e98b94f27e1fd440fca1882e62cb73e7a79621e65156ce71fdb78", + "0x7745a5c31086c993a46c6a7ae6582a5b091fbe9bb854ab5d75a56c332e82c2d0", + "0x2b5637be96c5474a58c9ffbe0539171817312be59bc8b7c71e23242dd20afa66", + "0x245190f95f5e09d43d1da7e9757fa066be1942b52f7e4962cbbe6a5f2e0981bc", + "0xa5a49f02d9bbe320f1f83ae3cfc1c7f3426abbf053be609399d335f91e0cb5bd", + "0xc09d4afca001abc13d145c710e2da10d19e8fd3bc1905c86ef1da29e6c27db89", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf1f12A06Ca57BFb6f8d2b075577a6d138f1d70e8": { + "index": 1035, + "amount": "0x01", + "proof": [ + "0xfe3ab03c768f1c5f472a6ff31b2233cd50e2f9f40a7129265f4392a70ea3a59a", + "0xe91922f6213a6bcd8eddfb6fbfd654d2ee1800b8f245d033f39493581f6deae9", + "0x228366240da7e1e50c9fbbf0d83ef3aee5be6b101fa2d9de2745bc568f3857bb", + "0xd234d050330272d515ab9d9de470961bb799874daa015afb8d313d5141c5e8eb", + "0xa0af5121b49fc7ea34ad1f4c8308fd6e51803abadb614d1f15f8c87bf9fe29bd", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0xf2065Db56Fde1B56e60F66a0dcB2743cc5b179BF": { + "index": 1036, + "amount": "0x01", + "proof": [ + "0x89b3b063cbc8f3ac4e5ae3e610d231dc206d5ecb5d282a4d032b2b147bb5b653", + "0x98a08095e1143e4bffc91d0d097598f8840e329876b6d376098cbf92ddfabd49", + "0x955d9858f13d562b2b223301c8206ff82e44d35786e621872e8a0ddcd2c8af96", + "0x16f452fd982f0f4e3fe20a4b2fdefc9226e8d1db4c0b29793acf9535b6c65c66", + "0xe4fc54838dec16cd3ac94713f191dc41ac7f5e070180d4843c9aaaf9c71ce29f", + "0xc23ea50d002ca7d5877f5caa2d1c2d56a28969df1d396dbcc98231f65fb937ac", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf22cfDD13bf9ab3d7D0e3d3b859FEDd3cE08Aa09": { + "index": 1037, + "amount": "0x01", + "proof": [ + "0xa3b49350de90c1d1753f83ddb63f31949c85b6670bbd42ccc29d49162a3cef51", + "0xb1ecb70d62cac7b856505e9d704ee9608347da8130e989925f729fe25fadf52f", + "0x2951c6889bb57f842bbebd143d63e6a3223010b180cb5d4a43421a7db1a043b3", + "0x9d1cf6e9f51d85a77dd4eec2524ba22941ec238f140f4f63c1712d78c1e4c21f", + "0xdf701aa8bdb3ffefff1b359214087cc585fa0a0d40716a6635a8d2db4380dba1", + "0xd114a44c21225abce250cab2ef78e5883421371e926e8af2d6242269ee529ade", + "0xdf6b39309da3ac217004887f4d2980b29b37f0956a0cd77e3b97878af0d4b5b5", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf3171c681Df4a916bCa547C00F1AB3815BF29F56": { + "index": 1038, + "amount": "0x02", + "proof": [ + "0x1d2ac964bc40a5f328834f2eb09552aac4ad6f045617925d9e6a10708772419e", + "0xfadf55a64f547fac120cb1b0d627dd3e6f58d51b8b3fce98f649e99b354db11a", + "0x702557a325e5dfca211cf992bed4c7d6442ba5a9ca061e69640a79660a822710", + "0xc2b85fb7fbdedfff6c0826f89cbeff5a93f827eeaec8b16d80424b138de956db", + "0x8e0cc5c13324dce3ab0f042d31a9db04afe0918f70e3f4515f43739791621c97", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf350243F5586C44BE42246e2D41c43A53FAA8fDD": { + "index": 1039, + "amount": "0x01", + "proof": [ + "0x08431002bbbebf7f8037e39222d3eaa3cb9739ea1469461315d65b562e31cda6", + "0xd7eba5ca62209179dbd0b40711ac815dc26a99dad294cf14d27fb4003bf8bd2a", + "0x159ab1cba9bf6ec481ada7ab7f7a06201f1346aa831336b8b398fcd6da2de059", + "0x7123b37c640e8ecb7e1db656a0f1869aecd392fe2f9511dc671c16401bc54aee", + "0x6e752d8572dc933bdf463f24751c7070d8aa74bb8987a5fe56dee3b0c9f53450", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf38A506cD35Da2b6C1Cb30975D9Bc22c531Dc5A0": { + "index": 1040, + "amount": "0x04", + "proof": [ + "0x92d39829f46be7fa9f43b0c9b277f2440d603dbd15d9d29e6a253be67b4acb3e", + "0x5942421f32a242b9590366d4604591e357d73486a5442dee6f47c406b8c3f74c", + "0xf7812c617fd43b12d11ba57fd1f9b80022f8cbcc05f057d95b7bb516ebef605c", + "0xeb79377abd71cdb891e1379260c8fb1947760c17e28c7168ccd62f5d772f861a", + "0xea7c0076ebef0c429d544548828ff19d5600136801cc28845bdfa9990d97a058", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf393fb8C4BbF7e37f583D0593AD1d1b2443E205c": { + "index": 1041, + "amount": "0x01", + "proof": [ + "0x85328ff19a520dbc116ae9236229d9fca1e98a683b83599f61a70ad18eb2899c", + "0x11e2c610b943d7d1768b63b84c5b383784c1a921990c4060813fc08cc72621f4", + "0xbc2dc753cf42a1935c4d0a0882fed8a90a12f1c0a70573deb71cc2d70b40317b", + "0x02cef8ccb3c7906e41a7ed9d223c95f320f2860a3d5a5dc4598d02362970eeec", + "0x9dda7d74fd49fdacbeb3afcd37c878516159fe4b594e491ff7ecbc80fd8d6808", + "0x64208dc94140ed01f08ad40b88c983779224a7d0b2aa71ba337d82a0bb5d5b44", + "0x54b1942b7dcb3f6c4137bd8561f5185145c5780ef76039a533bc5eebb04ac6bd", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf3F39A5d1f439d0a1a5bDc520177345FA0F331da": { + "index": 1042, + "amount": "0x01", + "proof": [ + "0xe153b66d4120e73b3df6b7f2cf73d8dbdec30d30517369135e29a485e4a4858b", + "0x47fe59bafd3357a18bf3ca4978f0cbabaf927bca771ed8620571a4205920deb5", + "0x48e789a37f032c18f647b0c6b852a88e29403e31c0f6bf94215b72507b16fbbf", + "0x60dd57debe01b07f2150f54d637bd8f574df12ac003a445ad012509f5b619671", + "0x966715df220dfbe5e11392b257b61b64c18178d1825b654f95f67d7c9558a2a2", + "0x9ab798e7e432691ae5120aefc1fa128937b80e94ff9ddedf890d6f75a5635a1e", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf45f34330bd4DeDAc13824e15624D97FBb430183": { + "index": 1043, + "amount": "0x01", + "proof": [ + "0x223d693869aab3633b5c5561544d5be856850ca6d3d8ab7d2986ef932b863f18", + "0xcba47d3e3066624ac5fe167f8941130f54ee55629bb1146e0c3a02dd3dc0d37b", + "0xaace454f3f03cf0e0a3025941926638c00df7354ff9ef7c7ea1df6506661ad57", + "0x7076b49e1dda289a132a67f2f0be7b87522da84294f2302ec4d61300a0630b79", + "0x6665ebe68e892e4e5135c09f9cdc379628aaa60a8ff322ed2ba75fab3b3a9cc0", + "0xf70b9a7e8bf16caac9514318836698a51db06587c577c22db581325c130e7a39", + "0xb728ce8bf4f84da6389c7704c7d368e8ae8f6af30f77374b5054dbb99184d9c9", + "0x313243d4233cedec58aa8c28a2af52bcaba1173bb5f05d9af07cce77d3f81984", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf486d56ccE70c481b3455aF901fCC4F03FeE8107": { + "index": 1044, + "amount": "0x01", + "proof": [ + "0x74a52d30fcfb3b11a40c2e29bacef9bfd1d4f0b0f7283c24fd45ea62e9987c18", + "0x533638642dfa72435d172bbf5ab67254649fc8a0c9aa6cbc90bbbab4ad46ac30", + "0x1b96dde5d525085e1803041fc699ac898e6dfc685d023f0edffb1520d8a514bf", + "0x396e47c3a850c873832c034b62c0031de9378efa99594428607ab8c6bc01e27f", + "0xb78cb1aa869958030ce4a14b5fff6309166225c83e0cdd2b91deb7b1639f67c4", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf53cAB0C6F25f48F985d1e2c40E03FC7C1963364": { + "index": 1045, + "amount": "0x01", + "proof": [ + "0xd394d92af6231b38deca78d5b4c6ad55fb66d38c61fc0cb596bb41ebcf505ef2", + "0xf205429173ff3206db22866262af56bce196a1f03f8462a2af5e24401468cbbc", + "0x3ec622c30c179a8f226f3181e0bf4aa4636a1725cf1861d7cef1a8edcb079b0c", + "0x41e64ddeb2fc55a967472c34897707f35a7b74171d5a7d21351e62fd45ccae94", + "0x7e73f337249898d15604f7c330d90e36da04007407404a4b4276d5fe3083b929", + "0xbf5b40f808623e9fc708bce3166e8bd16b4f9df0b06c0eaba8926a8d58f211f0", + "0x3349d55c854b87839c86c22b833a36da3cdf2891c0de36b02ec8654be7597119", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf645B44FF5e857d374bEdc0B67857b25e38CF4c5": { + "index": 1046, + "amount": "0x01", + "proof": [ + "0x1ebd7c97ca99aa018b918e02644bac713ff05005d6d4c4293c36982f3fae21ec", + "0x066beb648ebcc20fe8d63bd05cdfa8df8d8ebd93cd52c658d5318197ec394383", + "0x02c2372e8c71ba8e5b843247d27450214c544f74b4dd4d34e7ba17d64e09a617", + "0xaaf60b5ecf22563f090c456c87a77833a8ecad31ad25f79ce590acdcb7f64b01", + "0x8e0cc5c13324dce3ab0f042d31a9db04afe0918f70e3f4515f43739791621c97", + "0xfb070e39273109ecce7d3e30430fba8300badc2723ba21b0701a10757ee90523", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf69EA6646cf682262E84cd7c67133eac59cef07b": { + "index": 1047, + "amount": "0x01", + "proof": [ + "0xc1fdc9b8af57cb88b4d7f5be98fb7ab125caf8d7bd9813303a759bf36e808cd8", + "0xeb89f66c33f972131f05457d09c65012a4a07b743f98b336bcd8031dc6161b3f", + "0x71e3366d76c55a2318750b2a51d86a41babf197eaec484325789436df87b8918", + "0x56b8291821908612de8ad02adfee632a6221773b416cedb3db9fd4f3ba5d30ff", + "0xbd7abdce9ec414fe47ea73146a2131622bdacb914ea6353abee1b0a149275092", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf6B5FD8e2CAC43987DE603ce7942E09e2DC8A2C9": { + "index": 1048, + "amount": "0x01", + "proof": [ + "0xbd24b867c7f538cc25254a2668435a9bc985a19e4abe859bc63877e6b902def8", + "0xd1c4e02a846378a98e14a96757b4ddbb29039ba3dd27df01d9dfa5f342c0f252", + "0x8afb93098421e3e4b6478f7ea0a2cf7b3f942d556afab74785ace4a5071dee41", + "0x3886e44b7873439ef0a83b4119fca7dc640ee0f9551983449d038a076169bb1d", + "0xcf36a9c08620752945fec2c3138a9b0eaede19862d6c5cb3c0489e6ab3a443d3", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf7191034Ca0A4dFdFDA3dB160C92d06D361A5366": { + "index": 1049, + "amount": "0x02", + "proof": [ + "0x4d838b1f14f398331fe9b0c05c8dc6c690e0dd873ba679d9dbb98a5b4a50d29f", + "0x4c3af5cb9ce3e2a2b30cee148ab664e24bf31dbc4a45bf1573d7f262dc48617e", + "0xc9b824e8443131ec044d11642590dda66ca265300328d8dbe4689483b562b29e", + "0xf94cc4240e18301aa3e9325f55d6ec2e2e84a181037fd49b69a29a1aedce082c", + "0x43f59a603c2458850547e5a84d47e61be843b4a3c814303ed1b52e1e4d37a1b5", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf7401f57a705b71A9463d8b5a2a59eA0161c93f0": { + "index": 1050, + "amount": "0x01", + "proof": [ + "0xea173a8702aea627f1a37b6c58ba79909124b81e684d8fde396b047d533635f5", + "0xeaf8e0fcb535b52d11d83081a07860de2138906e55058295490b5bc3dffa9738", + "0x63334732b85124845e0586f19e798fe9b282285142d8b7ff24128a88ae98de7b", + "0xa26acb471e2d600bf69b92e87438242435f7a1ed8e490016e5305ddbcea64c2c", + "0x3ac4ae4a4697e2400113df3bd55f84456aff86925f45224af80fd8af20592214", + "0x2e17d4da5568744782264668f51e375e9e253e1447e3757fe588da6a57c767df", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf7814b5CECf31907745420d67D52D1c8b1671541": { + "index": 1051, + "amount": "0x01", + "proof": [ + "0xf8d8f6cbdfb3cbd0ae6e162e4034c46d5f36d7235399d78427d1d08d1a2b6b0a", + "0xf844c56b74173490eb513b4a77ac6240738ddcc89e2096443dcf07aa60bb1691", + "0x4bf5a604b9a09c347e1aa7d41b0a7679a3e791ff15d6e96a280af113935ff733", + "0x3aebe8d88cbaf4043e28b3d6aad9a1f79bda4dbadcd2f685785a58d155fbcc50", + "0x8e7f75ccc4d864471b1a7ec71efa29a4e8cc4761c26a6987c8043d9ca642a2a0", + "0x658c60deabd56636809877970a011b1b8182923517f545a8c8a36d344551dcdf", + "0x357d2640203dbb4cdf43675929428e6b353c408b74c6eb7d93f5871909997936" + ] + }, + "0xf7Eab72Ee14daD3DFEf597420F669c25B39f938C": { + "index": 1052, + "amount": "0x01", + "proof": [ + "0x5389d10ea78a94bfe3e18bcdaacfdc1f45c4f1b884ec0d58894b9e036e3833ef", + "0x4cbbd99b432afca501b2d9c83401affd239d9bf8c7e9ee093e293f0ef7e2cdf4", + "0xa21540ccaf175cc840a18d1224f8d3683c9d069bd5ea2c3bdcc7b37a61191f98", + "0x7a5397945a42b48bf4e4ee9c21f985e9d9ccf82e57fdb87dc2e6046ed345d7ec", + "0x5477c93aa7e191fd8f76e1976387fc82460220dfdcee87f9ba8926f4e0ddf45c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf8Ee872652e2B8AE594E6a3F83048F5704114658": { + "index": 1053, + "amount": "0x03", + "proof": [ + "0x749683d8ed7af32788e0cbb87dbe1edd963220ff1db7de12f7805882e1a4cc59", + "0x2798fba9a260f6fb124666e8af7abfce9309b5dfdd278c348026c5673976ad32", + "0x1b96dde5d525085e1803041fc699ac898e6dfc685d023f0edffb1520d8a514bf", + "0x396e47c3a850c873832c034b62c0031de9378efa99594428607ab8c6bc01e27f", + "0xb78cb1aa869958030ce4a14b5fff6309166225c83e0cdd2b91deb7b1639f67c4", + "0x53dc32da737bc8ca857f21b3954e878c6ba61710ea165932d35aa1ab5832ed5a", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf8c6A92D8adD8090c66Af86e973479edD1DcfA85": { + "index": 1054, + "amount": "0x01", + "proof": [ + "0xbd97c98070dad6ae6d309cd795788873d00463b79fc13968b58aeecde8397845", + "0xdd5a5a03336ff3fcd03b8c065a4e184b77cb95a5fd5e4d4fa95ce164f2e7e261", + "0xb47c664b127e95ef186434a19e51e8c91952a09c8b6513f4afcf82c63bcec3b2", + "0x3886e44b7873439ef0a83b4119fca7dc640ee0f9551983449d038a076169bb1d", + "0xcf36a9c08620752945fec2c3138a9b0eaede19862d6c5cb3c0489e6ab3a443d3", + "0x9874f803b09a6422fd654a30b8bffa0951b4cd5429f9f2bcc689c8c0ba01d9f3", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf96D09c553db50EF8198eED965dF9E660133C23A": { + "index": 1055, + "amount": "0x01", + "proof": [ + "0x78f06d49f7db6d0493b2d8366c2da6adfc2a3cc55caab7f7ed776012ae627281", + "0x7d0117083b95e78fd1027c446d855489ff4ce1efc8dd32492e266cad463603a5", + "0x3cf840f671484c5a4854a9e7a16c73913cc5e1ae358e160566aa35e0ef06bd1a", + "0x9b12cab9303ffdb5818321d84969747034ab90e273c8fb6d0031d1f6e3e1f83c", + "0x80cf615f05f15e9ed665dd7df5d086fcb70ed5a5086e02db7c08752fcaab6507", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xf96acd900deC0BAFA463948ea125FEde2B52FB43": { + "index": 1056, + "amount": "0x01", + "proof": [ + "0x0d6848594c2800ce78ba6599b92ed111634df94b425024d3aaca208665d66c59", + "0x58a8c0d78de7d1c7ce1e55ad130b6552b29126a42f67d9d0c724c2c0062f2b7b", + "0x32079f379faa5487ad026443f33416fad7496adb5ba59317ada9083a771610a5", + "0x037fa491e4b6fc74b9dccf3175d28aed9f5dacdb75dd0fc8e1154a0704619620", + "0x4bab2069d20a5d1d2f5ebdb61803a57609b7709eca9e925e31a7d14434af1326", + "0xde1d5937f72a645e19a5226267db102a2fee82dadf90edc08b50eec5e88bc4ff", + "0xd7f8fc63d3792cbf81f63f43ab2b13d028d8f43fab1390f170900dfe0af3ae9b", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xfAaf6324666971CAB93023654405188258EA898C": { + "index": 1057, + "amount": "0x01", + "proof": [ + "0xc581441dcbbe0b2d2d1e553f37c3d26226b3ccaa631915e277646b56f57da2bb", + "0x2b64ddb2d6ce7f4130fc138c55720e30e85d39ac94dd192b0bc1b5efe236ea3f", + "0x28953c726ef8579e21b5a30c7fb4f81f31e6a2af517a1f8948b50dc1a62e1f25", + "0x99930015299a0435807ebbffcd0957a02cf6631c31c05ff8ed9a165cfa4bf8e6", + "0xcf22c1d43a94c7c6471efe1209a3b103ec0a9836b6c11fe8d2e98d18b2e9cb36", + "0x2f33b161332d78905aaae57f6d66e7dea201249675e56794ffeeb64067023d48", + "0x624dd650a4e417a5e0041b2f4803239f9bb644dab5445b20b5a68d28fa043c83", + "0x6678b772fce45919576cba31fba47394f7ebc2cd80670ba17dd439af4c90ff2a", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xfBcADF5514b1d0538A7EbD443fa76f04D526c079": { + "index": 1058, + "amount": "0x01", + "proof": [ + "0xf20bb9e9d1608aad8008280456a3b3a73c99488e9b57adb921b21eb3e1db368d", + "0xd9895ca238040a842ca0038140e67b405a6f7cba6a467efbb3c6951596d1fa20", + "0x7ec9bc99b06cb88cc17f324af3ce04347d9712a8cde058a864a99e2270fa22c9", + "0x27cae8e1fac7b32e83e85494312638757cf1e0afea8f4e6fe77387c412b4efd6", + "0x58340ed8edb441d787ada6b1aaf2b1e42912724e1f0f7887cde9253262aa0534", + "0x88ead25622b86a5d318b6f140ce704920889f891ff7ece5458a9d77f6341f4f9", + "0xb244cb9668959416c4fbdba551218409d3b61d5b6a7b94bd145ef966dfb4dae4", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xfD6231A29661100e9F7E68d37730b040E24caD28": { + "index": 1059, + "amount": "0x01", + "proof": [ + "0x796a07abc3ded0753bcdd8ce453d11800b0b9be68110d7fb784e25655b5cde2e", + "0xe309338b5391e2b4fab0fe3a446c3224074ab0f17060e12ca3326c1a737aa1ae", + "0x3cf840f671484c5a4854a9e7a16c73913cc5e1ae358e160566aa35e0ef06bd1a", + "0x9b12cab9303ffdb5818321d84969747034ab90e273c8fb6d0031d1f6e3e1f83c", + "0x80cf615f05f15e9ed665dd7df5d086fcb70ed5a5086e02db7c08752fcaab6507", + "0xe37dad2cc2d365c75c662c37581f7bab845e2f7bbfa99d1c2fcd1d7a3db70f39", + "0xd8bfe48b3965f436f0213994e0e6f751caa2360420c3556f633446b8c051598c", + "0xb6306268a1c019cab379200e650d8a1fe9d184460de02bebc1c5e3a790905230", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xfF058c99568e0F753B960f1D0ac7830bdFF1A51A": { + "index": 1060, + "amount": "0x01", + "proof": [ + "0x51fd2f34b72b9db0881731ded3b72770f7b7592dc675f017aa3061a3e1e6dede", + "0xfa9a75aea105dc3280bb3b46fb6ac2c13645b903db9fe2c57c304bd184ed2b77", + "0x6e4e3be8c84bdf4ca5531cb1f98b5a0f91f960b234deca1bc85cd01c39319968", + "0xc7b00ce40d9d1f9a2921254e2bca646cf3992fb2c667a15215723d1f5a1b5352", + "0x5477c93aa7e191fd8f76e1976387fc82460220dfdcee87f9ba8926f4e0ddf45c", + "0x8860c6f8909f514108ba0fe001817d735f31c2e950e7cfd3a3d451c6fab91a05", + "0x5b2588db3f48b4b57097a8c6422a3e83b561b95e30488f3a5c0ee2106857b621", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xfb325eE61cef82a6e360755aa2fc105d545B07fd": { + "index": 1061, + "amount": "0x01", + "proof": [ + "0xb50d73c98d90f370c2e4aff2198b4d4bbab07471980708e15613760368d030ce", + "0xbbc0c9648e4d5c5f44bb2553cf70092c725cfd49de8cbaabb0740cfbd4aa9455", + "0xb2ed6280151caa17489d6fb4598efd9034b403611c60ec584929ae6e4dd1f3af", + "0x575d2e3f9c311244d801f96a2b4f9fc9666f8793f898d400d71e121add7f872f", + "0x529f1b48ab616d4dd60f663753a7779d8ec25952bc8c34df4aa96347bdb0d542", + "0xc3266e417414eb00246a29644b45d537e40fe4a5ae4f7a9488027a47563327e3", + "0xc48dfc72bd6c5e992871f4bf150b37b94c436aa890540c491e08d828f6c5be9a", + "0x3609c68cb0f91e4b72c4578b9fe83e3b86e80b8321a5041e66a243a47a359233", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xfb578D95837a7c8c00BacC369A79d6b962305E70": { + "index": 1062, + "amount": "0x01", + "proof": [ + "0xe32717ba75a1b5d70e341aaa155fb0c50ab2e178cc0976e22dca025dfa6aa8fb", + "0x7d9d2db086a88d5f428032898c3ad694fd7372e8ad39f5b65684a786e6465301", + "0x567f8f869bafb76cdb1e5c86291783cf3bb6dc604902df31bd0f815d38e36ed9", + "0x1bd24f0c1d9a337a197e1feb80905be5821f1e64457aba030d18aca78646a08c", + "0x7968b2383e3b914ab3a36580b205f1449b51563630c77871f712e94743e3bf39", + "0x2eeaf1f0b14094efdf153455cc61fb600838768a1495072acd7adcb287a54d97", + "0x0395c01dd75294a1d0921f4cf12d259dfc960beb83fa0e254edb13ef9f76bf12", + "0x10e2427bda264f42002f613033a262ae6cdbd882700d5bf9fd53bdb3901b8eba", + "0xd0a648ff127a4fefd3283c0827b5652b2e53e6bdfc3dbaf6934315d97a269fae", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xfc1F931AB692F366b65ef42a6cD0d8d65E40F841": { + "index": 1063, + "amount": "0x01", + "proof": [ + "0x9169dbeb1fca399af864ac0e58d6ae8b89af65966bb69ba071c5f967de754c44", + "0xaeea21490325a3ccdb24ff2530c090bf62fec7ed45dca1c13565c4aff6891a40", + "0xad5c895abbeb22965da16b0fe557d3867fbef2fd9736aeb313fd9e3058d4bdba", + "0x0a650a18b5dc7e14051f590d1612c3614c677cc931a3bd72443efdbdec9b6fb6", + "0xa4e0ebcaa65c6595e7c7f0ffb89992e2b9cb58ac405c81aff220fc4b16ea3b6b", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xfc436651F2fD4885AD645035a63A7Cd22E6A868c": { + "index": 1064, + "amount": "0x02", + "proof": [ + "0x494ea781237e5ec33093e4aa570dc9c039ed63d0595981430d110bdd3fd78a60", + "0x0c15044f5711bd573ed2adb27d2bb70d44e0b2cc3aace5e1c5ef7031a4ba8710", + "0xa1607b1dced9e8d9d1aaa755c5c6bc84b483e3063f866818b53e0747d67d0d1d", + "0xa5e8bb53f83c3715772cbf32d53d2e1c1c9b5abd0d51618f0e2ec2960d9a33b8", + "0x43f59a603c2458850547e5a84d47e61be843b4a3c814303ed1b52e1e4d37a1b5", + "0xf827a37bc09431affbf06b5b3495ce856b0233f527c772da1b66eb4e89c6eefa", + "0x719940ab08f7abbbeb506dceac0c71d3b27d46d43dfa89b17c8b2f3f8204feaf", + "0x43e5b7a570af1a994fe61b9146a04222bc57070033456a78d0f324943e175f32", + "0x08070a88dcc821e9b2243b2b85e0109010112c4ad3a34c1378fe2edc2b459476", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xfc64Aa8B9DE7e6bBcdC414E9ad39B6a63E498E18": { + "index": 1065, + "amount": "0x01", + "proof": [ + "0x0aff6cce235423812edd057508f957bd84bd254e28466d5030b308375805a009", + "0x7b286a39d827ec0a6301858dae95ddc36ec440065ea92f65731980cfa57bb970", + "0xb1717c21808d3d48c3df9715b61089ddd54dbf21e63f04ad434821ef229b5e7b", + "0xc50cae5631fa8cafae8224329322dbaebc117b278a8e07f29104d255198d88a8", + "0x4a36dc66177a8394f6b14fc9adbe4ad7e0cc2dead6acb72d80990e336fef8d45", + "0xfddcb143fd05f6cff10b56b8285ac821cb9b5177e2af2d3c0e8a7bb51ddc3231", + "0x1ac664d1d137555775cd45c09ff65f64b5401e26d6c57bfb7b7257c9bf38daf2", + "0x079feeea514b3e5eb1cc6866a3c81a921064a4299e6d10d2694de68da5e0f0b9", + "0x884c490af1f8387e41f956c46a14f4487f775c2695bf6fcad04ebe8e10b7376d", + "0x948162f96890a9ef98c0336cb98a6fa5504094c521b4ed9f46379c1a74e63ee3", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + }, + "0xfe880cB755C640c1183567483072025657F908ED": { + "index": 1066, + "amount": "0x01", + "proof": [ + "0x906b62edda59b2e8906f5096e97221e29e1de6a31fca154200c0ad1222eed7fb", + "0xdd35a8364b39efe0ff47f199e8600ed4ea2861d0645092a22de6be4736d0fcb7", + "0xef1d4406d91ca16cad3c2ae3fcec81605fde6f08b915d8de8717673e99c1746a", + "0x1a6147d096056583b570a6da72277e79d6ef31519ab9cdbd2d1115f5eeb94a46", + "0xa4e0ebcaa65c6595e7c7f0ffb89992e2b9cb58ac405c81aff220fc4b16ea3b6b", + "0x74b676f822a8d631372d59bfa99b47539d07eef043dd71ea042c674f4632cd55", + "0xd9b92443a2df2b6d41bf840fb425e2c77d64773f8d1ce174e7878fb8f844626d", + "0xa8379b3d6eee596f8f4734d3e045121ff5a2b1d4c32f86f1b9d901aa052ea61c", + "0x75393ca285668e74a196bfa5bad4be0669003f58ddbe328bcec1dbdeda111d48", + "0x8d6f5d34fbd8acd8bbc55f6c03c694a30628b27af657b986186f0563ba69e0ac", + "0x9bb5df65c76ce4422072b10b432f6838074492be6aa66681365a028a43dda809" + ] + } + } + }, + { + "merkleRoot": "0x2deeff15225851ed30002f74ec451946eca34ee756740bc4ce673f6c6419631d", + "tierIndex": 1, + "tokenTotal": "0xf2", + "claims": { + "0x009154b39CA41372Df54564fb8fF2C437a83c411": { + "index": 0, + "amount": "0x01", + "proof": [ + "0x6098e96cd4f761d9351c744724d9ef6d0184799c5933bd5302752e5d85156bf1", + "0x6074436da9fcec4cfe79a40ef542bc4899208ab1d8f0001adf90f92ee1fefcdc", + "0xf92aa902ffa739c5a1075086d0bbb171c03745ac9446538e400f447857437193", + "0x2ef2c623cd26819e676f6295abaad8ef34c204b71b3ae644be0cefa86e3150b6", + "0x8a2a892a2a632adf2f1f7df50cfe964e48bf81690e7a3c82aa6be34a79635896", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x0226068cE182ad66482ac08219d41e00Eae74aa7": { + "index": 1, + "amount": "0x01", + "proof": [ + "0xd7712de1c44107ac131f728cc256241e8b7451d0455d40e564acac3cc2ee3647", + "0x99a06f41cc94481935318c4265776e3b916e651fab846abced5c618d873b915b", + "0x99f0091db6a51b03d8a461655ef7e68150a2349be1edcb0dab9de795bdd645d9", + "0x5d0c037ff149aa61e68483d2aa89514545be2eba507b61f72e04da089b5134d1", + "0xce3c2cae572bf1ea81613ef7fc064010151dbd5264896982059a3d31ab366fcd", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x038Db6c62d0F072616e2B8dB7D3D7cFC829f7f65": { + "index": 2, + "amount": "0x01", + "proof": [ + "0xd7beebd4e8b467272159e1914bf15c8701bef831e70306d2c01cd6d02e768dea", + "0x3d4acc8a549c34be118beb6cc07ef1f16f1c76233c9cf81cdab19540c7edb240", + "0x99f0091db6a51b03d8a461655ef7e68150a2349be1edcb0dab9de795bdd645d9", + "0x5d0c037ff149aa61e68483d2aa89514545be2eba507b61f72e04da089b5134d1", + "0xce3c2cae572bf1ea81613ef7fc064010151dbd5264896982059a3d31ab366fcd", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x06940cfBc097ed8A3F535715E500Ffbe1E685fDc": { + "index": 3, + "amount": "0x0a", + "proof": [ + "0x33b17559129f1425324816c313bfa8ce4601904cf4c5a8ec6019c7815cb0e200", + "0x9f661db63c76dae77be353208cf6dab430914ebfe232e1b405deb08ec73f402a", + "0xc37ca5973cbc7282c5a31def4e2c8dea04369ac2e59b9bc0fe3b8fd28c9e5872", + "0x9f2ec78bac177b82e65626eb3f7b76e2644d8a7282cc3be0840fb0ecd772d993", + "0x3784903b025be81b83e9bb4752292191cf517ec429d6662e8b71177a2d5d4ce4", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x07B802f6954602787A51d09DB4A3544412fCddC6": { + "index": 4, + "amount": "0x01", + "proof": [ + "0x4ac5774d220ffb37f56e8ae13523135d933095d9cbd0aa92e7a343054029ef6e", + "0xebb27e77cb9bc98f82c42074368f6a251478e2684d0f0b5b08bbaca6b7d03c48", + "0xee0321a702d99edfdf36d62367c275274518018d5f5d106fce98072476620f9c", + "0x62ca54c10d0d2e8f11b95ce1e622c1071c735ba393fa4d8574607daf6a853ebe", + "0x86373cbc149bf07a85d55b4c3cb8102ed404b3acd5444c368631ed78c89511e5", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x0998160bdF3Ff6D86A4E9D5c31e0eFC3Ca7e7D01": { + "index": 5, + "amount": "0x01", + "proof": [ + "0xca46f48e8a0c9f1ad9a61e7fdb1dd4311f875f829545e56cfc7664d50b1c30cb", + "0xcad84d256c4f73644a31128d98720f66c3adea2829d78cfb4a09c9fa1daa0b34", + "0xf5abed670baf0190a0a91df408d65698c3209dcf17a843f9e5fcda9bd8959a17", + "0xd9184a25eeb4f87cd2425cac26ac77cf668feab72ea6bbd3b110892fbe584508", + "0xce3c2cae572bf1ea81613ef7fc064010151dbd5264896982059a3d31ab366fcd", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x09CF915e195aF33FA7B932C253352Ae9FBdB0106": { + "index": 6, + "amount": "0x01", + "proof": [ + "0x629658bc5fe99e352d0abb7515ccb85e9973896c3a84971a7b29de39f3ebf959", + "0xc18c21692f3c869fcc64847b2fd873721527da6c40789f78d16f7f6046a7cc06", + "0xf3e7b2856b67ca0006e0458e20a848e0ac893cc6c1b59039b13d9aaaf09cc4f5", + "0xb46aef78df30b13738edb3464ba4c37561bf949ea83771c3a8ffec47c242fca4", + "0x8a2a892a2a632adf2f1f7df50cfe964e48bf81690e7a3c82aa6be34a79635896", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x0Aa350FB487F75d4f5d6ED920A5ae0923ded06E1": { + "index": 7, + "amount": "0x01", + "proof": [ + "0x8eb363728058aa8def6ddbb7e0ed9f93c79968056b0b8208593fc5eb60834165", + "0x1d24b623a851d2d8288fe18d4841049213f0f31118ff4882feaefa828eebc3ff", + "0xc644c2e247edac46242eaedb98649150e3e4ed6e2a71819c401c47cdb8b7cd51", + "0xa9c14b7bde5f6bd300bce856d17e01e920e75da313902e045b4b3e048962526c", + "0xb654a1a566453851ec2f35198e6992bb9af61b4c4bbb9383d0605d3898fe90ee", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x0Eb96D5ec478B68fF0d48628Ab4DF6A63c21ddAa": { + "index": 8, + "amount": "0x02", + "proof": [ + "0x0c3c02c9268e841b93fa39a4d108820e8f8100db850c036639fca5cc4edd98e5", + "0xd5986a533de5ea3bd8a01eefe2d1112059c5c4b8195e7483e99b57836ae6bdb3", + "0x3a5db6056b8109ccd710bcec9b1f94d65fda06943c72c7a79ad08305276b8e63", + "0xb64575b2e5c17b269a7b54aad00cb5ae485e6d3cd97f9b696f2c348980c80376", + "0xcbc27f89cff792994dade0a33179d3255f98b752d247709d3ac3afbb50e6678b", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x0F0eAE91990140C560D4156DB4f00c854Dc8F09E": { + "index": 9, + "amount": "0x01", + "proof": [ + "0x0ada5195e76ece25914658f19918276c8db87942e3f86e86f140891ce6646d6d", + "0xd5986a533de5ea3bd8a01eefe2d1112059c5c4b8195e7483e99b57836ae6bdb3", + "0x3a5db6056b8109ccd710bcec9b1f94d65fda06943c72c7a79ad08305276b8e63", + "0xb64575b2e5c17b269a7b54aad00cb5ae485e6d3cd97f9b696f2c348980c80376", + "0xcbc27f89cff792994dade0a33179d3255f98b752d247709d3ac3afbb50e6678b", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x0c46db6711824A8627090c4835E121C3A86C4600": { + "index": 10, + "amount": "0x01", + "proof": [ + "0xf989c8496689c9d6457cdf75f933ade99fbf6f15f0a39aaf89b77c324fbdf1a9", + "0xa3f7b2b01e24dea7f5a238004be9f05b65628ace72790a7f77fac6e6090aa2d1", + "0x7f7d059a484fc78b87c1b6419a9f6ada2b19a94a6be65024ee86971d55c384bd", + "0xb867795c31665082bd4b62531e021fd6824408948736b0ddb1c8b57e1c294a11", + "0xa28387a156c9f4954d9607a9ac4f19c1c5d457a48cda78448a477aeb395467b2", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x0ef6E547DD86de09F0E8eCE1E5A9f5cCB335aDE1": { + "index": 11, + "amount": "0x01", + "proof": [ + "0xa50b0a3bda75c923b957c13ebad05ac27a835ab42d6a519d27685d92c5d965cf", + "0xd5c80b252f62333501c948d1eacc5d0d183eb99eb6cc099f2beb609de0317752", + "0x7d90615908c5080e692d6d0dd760c920eaf9db7fa051a3e8b1135ce96cc6229c", + "0x930fec2c2d175134b5a08f2432bf7e01104646b61dee15c531d62ad698c4b460", + "0x28acf9aeee9dbbfe59ed9a35b834f1bb8f030da25f10829a720689183c091e8e", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x11b67a503B3B702104EeeF69a4eA1365D0F2c658": { + "index": 12, + "amount": "0x01", + "proof": [ + "0x3a4e43aa07083424542058affcb645930ed842cfe2597745dcd773c959d3fcba", + "0x24927ba509ef8c181f0bad9f16ea987631090499e83b0901f5574acbb040e4aa", + "0xa9e692419cb4f94f85f7a3cc302df5c748e87c56568a4cb3a6f25ed770c307ee", + "0x9f2ec78bac177b82e65626eb3f7b76e2644d8a7282cc3be0840fb0ecd772d993", + "0x3784903b025be81b83e9bb4752292191cf517ec429d6662e8b71177a2d5d4ce4", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x127168570D34E3D19aC3eAa75Fe9B841DE0F78f9": { + "index": 13, + "amount": "0x01", + "proof": [ + "0x411c65bb85bdd540ea13a32fef8f499d2016321a549895b9012108269b5927fb", + "0x36b6c8fb03ca39598517ca8a40f1cbad83a628ede60b7042cd8078040d06f016", + "0x8d04ed65a88640cfc16aeb35d55de80ad6bddbf3f2166a56343c6dd7d9444410", + "0xda7f239c88a5b772a2ff14bce5086ce21c104bb4ede8fb05b792ecd4ca562d5b", + "0x86373cbc149bf07a85d55b4c3cb8102ed404b3acd5444c368631ed78c89511e5", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x12A1E8f498501c2CCE0967F8b9717b28492fC668": { + "index": 14, + "amount": "0x02", + "proof": [ + "0x12cfb325ebebe449dcd200ad892a176159c5dad9ea1889cf2cc344251d3dd2dc", + "0x86fe57bceb22bff47dbe347de7e52aedc5a8a29805e6f0a77586999983518ee0", + "0x465e6bafbf8b6f363352a3e3a36f9e265db0c2b866ce9068dcc12adf9107ad37", + "0xb21ede7787a0a8b0437145982a83b864f2e47c687aded37139d31a4560feeaef", + "0x08516e24629ac2a05afad7d0082e47b87252429c85dba8347bb8d99ebd15917c", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x1331a3b18d4B56fB23F2692f3A452938990E94E2": { + "index": 15, + "amount": "0x01", + "proof": [ + "0x0e78b3189ddc384566e800fc8ca004f8147fa9ae9352f8746c615d4a2dc53387", + "0x8abc8ed00099d2108683f675559c7aa321002f0d2053b3ccb2c586e11ee804ea", + "0x2758e8a25cc5d66b30b697aa228db9ea85e95e74c78ae8d4bb807812ab88f7a2", + "0xb64575b2e5c17b269a7b54aad00cb5ae485e6d3cd97f9b696f2c348980c80376", + "0xcbc27f89cff792994dade0a33179d3255f98b752d247709d3ac3afbb50e6678b", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x13C03641c376Bbd2113e7fDD02e92D0BBef72511": { + "index": 16, + "amount": "0x01", + "proof": [ + "0x1ba336bdc4c9a0f4332cb30295a261b5189737b1f42492653870a2ce3de6ce11", + "0x0398918de9c23674d120e1c3ed3f872d7ab6e509a8ee8604649ff472802e58a0", + "0x23c008de9012b3127a46540f787a48c449965235c9f502b0bbb1719973199e73", + "0x3e7f8382a906db03cc3d1a09d794b375222411632d321f6070b091c1a5d92686", + "0x08516e24629ac2a05afad7d0082e47b87252429c85dba8347bb8d99ebd15917c", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x14cA9Ec64239831c6d34426ED9339c35b9f5E2D8": { + "index": 17, + "amount": "0x01", + "proof": [ + "0xce5da555c95d88a9ef37edfc7588785f961d0e7dfff57a16062377c762fac67d", + "0xe5267359a68ce5a917a20b834e11fde6bb06625695e259a6ce29c59c072bb5c6", + "0x458ab07c152871be5712096c4d82f8b3d3ac751c1a69e1efc1461cee12f752c9", + "0xd9184a25eeb4f87cd2425cac26ac77cf668feab72ea6bbd3b110892fbe584508", + "0xce3c2cae572bf1ea81613ef7fc064010151dbd5264896982059a3d31ab366fcd", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x1808ee295Fb2C356A7e00994282c1670810764cA": { + "index": 18, + "amount": "0x01", + "proof": [ + "0x40d301c5ac5303b8f22d58eb7191a8f98d2c7dce850062be62600080ba2a93b6", + "0xce179b69ad031a12e56d0b72c206a09cb33f737ecbc71cc9a69c250982b1212a", + "0x70c1e14739c966ef5e24983ec018e0476325243ef26be486620edc26445e05fb", + "0xda7f239c88a5b772a2ff14bce5086ce21c104bb4ede8fb05b792ecd4ca562d5b", + "0x86373cbc149bf07a85d55b4c3cb8102ed404b3acd5444c368631ed78c89511e5", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x183B6267cb9F985A8AA7Fc912672A21d644a4102": { + "index": 19, + "amount": "0x01", + "proof": [ + "0xc6550ff279693a17b7e17abba842bb222c3d1d6cbb0e1176df992ff7c81cdcb2", + "0xd6783ce232e3dc7b5bce837e77c83e11da7430d43336f663ea9fecc00290fa6e", + "0xe09f40c84b8e41eeaa1090ec7ac0b8eb2b2c5243c7e81e00d5910e03289e229c", + "0x7be11c45c5666355fb967ece1269c0e78498643ab2b2435f7cddf99ab8b39422", + "0x1ae23534fd2ec3b68f5762f60ee913ca81f956ea9ddeee68a6f8f4427a5a56d5", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x1867aa355db059D649Ab84CeDd7F0403d11d6A37": { + "index": 20, + "amount": "0x01", + "proof": [ + "0x5ca92b5c84f9cf75056856b7df6e252061bf7e22b17254ea3250a02e31faa00d", + "0x172ffed6e628d62c1effe22a12ea2a732fed0639aa6ff9e166f219a55acfe012", + "0x4166276af4821b7e02ad4e901ba1c008614f51459cd39c81ccbf08a195fadac1", + "0x2ef2c623cd26819e676f6295abaad8ef34c204b71b3ae644be0cefa86e3150b6", + "0x8a2a892a2a632adf2f1f7df50cfe964e48bf81690e7a3c82aa6be34a79635896", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x1E8eE48D0621289297693fC98914DA2EfDcE1477": { + "index": 21, + "amount": "0x01", + "proof": [ + "0xd112e43651fa82b3675ab59b3ac772b20b2c68d98ee1192d56fa66991ed13947", + "0xd1e0f88633251f7ae2df245025c0b5fa5121b2a83ce560dcd97e9f9064836ee4", + "0x9ff6d0995e7919e1977592bf9d9394aaba2c03cdfdc48dd0aee32d4431d791c8", + "0x5d0c037ff149aa61e68483d2aa89514545be2eba507b61f72e04da089b5134d1", + "0xce3c2cae572bf1ea81613ef7fc064010151dbd5264896982059a3d31ab366fcd", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x1c2CdDC58EAE7A9d6CFd2aA7b8ed7dDaD9900179": { + "index": 22, + "amount": "0x01", + "proof": [ + "0x841c9e16ead05660bdf2164f2decbc0db9804c1ccf56c4d9162c00590a1c8964", + "0x9862f4bfdc51e24c3d90e72cb0e4a71823def15b9950a6defd3ef680ee028bfd", + "0x5c107555f7f57cb8c8f52941d77a7ee7824e0ce08328394ebd3660ecb496a75b", + "0x0d0da98bee418d7d5447b0b9f149280d02d3119d074c67428254b1b6e48d4725", + "0xb654a1a566453851ec2f35198e6992bb9af61b4c4bbb9383d0605d3898fe90ee", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x1cC972Ff969689873f8010bDD0Cf3dC30618397E": { + "index": 23, + "amount": "0x01", + "proof": [ + "0x868f9a7b581c26c5fbf163e329a643e3c7d2b2aab5a14e9321f500e2080b6a00", + "0x5fe4716e92c56f5942e159b46246eaffd3b40df78196d03fcb4f184ca45bdd36", + "0x00c785fb523e770b855f5a8f4bcff502dc4ae56e5dcb87030ea7135262441e9a", + "0x0d0da98bee418d7d5447b0b9f149280d02d3119d074c67428254b1b6e48d4725", + "0xb654a1a566453851ec2f35198e6992bb9af61b4c4bbb9383d0605d3898fe90ee", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x2028579c7DddA2Af393904A9dedc5a42cac438Bc": { + "index": 24, + "amount": "0x01", + "proof": [ + "0x2ca441a62c32815ed5abd69e5977b5602349ff303417bd6bcad323754187996e", + "0x9f661db63c76dae77be353208cf6dab430914ebfe232e1b405deb08ec73f402a", + "0xc37ca5973cbc7282c5a31def4e2c8dea04369ac2e59b9bc0fe3b8fd28c9e5872", + "0x9f2ec78bac177b82e65626eb3f7b76e2644d8a7282cc3be0840fb0ecd772d993", + "0x3784903b025be81b83e9bb4752292191cf517ec429d6662e8b71177a2d5d4ce4", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x23ED0374d7e66884cD42A2B5AD96f5d9C6c49d32": { + "index": 25, + "amount": "0x01", + "proof": [ + "0x9bcdd9340e1fdcb4f10de50e137e3287d4366f72a741ace7912743f505d20040", + "0x11c8fd41523bd50072f2b4c078fcf414d0bab2796bd421c41346025eeafea12f", + "0x0dac557adc392ee670c09ce5feb56a9eb0694456c9b8679f870d2c6fcd1cd495", + "0xe1fb9cfbf2109f088b0cc3e464d6a88d8ce475c0df0baeaa065f9bf5438fcf28", + "0x28acf9aeee9dbbfe59ed9a35b834f1bb8f030da25f10829a720689183c091e8e", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x264571c538137922c6e8aF4927C3D3F681399E50": { + "index": 26, + "amount": "0x02", + "proof": [ + "0x2531ae8e1c2d5c4f99945f86155241b67285e7f6aca56afc9f94ec52f2768ecd", + "0x4c8014af774aaceb6c6a6050eb01fd6e03baaa3bd661d49893d945605d39387a", + "0xe11251280abfd46378ca9ca336e9954dad085a38edcbca705ec534447a68e2e4", + "0xda4b6bc089b72bc047b6c6fed7fe7fcd52dd68b9d13d6be60c86383ca2ace879", + "0x3784903b025be81b83e9bb4752292191cf517ec429d6662e8b71177a2d5d4ce4", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x26Dd71418840d2d8505251D2c6445D9A5834d3BC": { + "index": 27, + "amount": "0x01", + "proof": [ + "0x6b028bb20aa704d798ae8f2c0fb05a76df3fc2e0c12ef314de08faaa66b46547", + "0xe12ee3b3863caa35f4bb0a76cf89e6f32891897d303dc3f6ad03d2acc9c89310", + "0x8fa28fe1927369e107a95848594ef796b7bef6240d6b34a6cfff9259c5f1f55e", + "0x472ad2456c55e2e0144a5164c7ba8b34a827db0c91aedbce9484da200426d438", + "0x6bb1e68faf6241a81d5f80cdce73750e9979840cd454e701f5027975e0839c13", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x289922fBBfBd38472D7e2A1652B33b834f7c0E49": { + "index": 28, + "amount": "0x01", + "proof": [ + "0xa28b0de0f6e2c8c304ad92fe49b9e354c423e8f631d5d8add8d1b674657cf8d2", + "0x721a6e333d44569a347959958185be645b3d4299144728604cb10639520fb169", + "0x086ebe30a2720a483fda3431b8859546cf2996b8f18a02045112e469db21cd79", + "0x930fec2c2d175134b5a08f2432bf7e01104646b61dee15c531d62ad698c4b460", + "0x28acf9aeee9dbbfe59ed9a35b834f1bb8f030da25f10829a720689183c091e8e", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x28AeE851E7b65A46b71DE302CFfEeB2c557847C6": { + "index": 29, + "amount": "0x01", + "proof": [ + "0xfc5786b536c6e0651e59b5d113dc1a2aa94795e50134beb2aac8aaee33a976e5", + "0xf9540918c21cbf33d4ebfb4b010be4be3516ab4741f3f352adaa6b5e36d1ab05", + "0xfe622aef6c55ecad704e4012913430d112a6749301f3bcfcc64dedfdadbcb658", + "0xb867795c31665082bd4b62531e021fd6824408948736b0ddb1c8b57e1c294a11", + "0xa28387a156c9f4954d9607a9ac4f19c1c5d457a48cda78448a477aeb395467b2", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x28C01B64F2492D82fd58FEECF8c71603c769BB4A": { + "index": 30, + "amount": "0x01", + "proof": [ + "0x86462d18e3101704e9c268fd3ea6cebde18ad42a791e4b2a7099cd63e30c1084", + "0x5018e747d85c5ea88baa6da77e8044b33263864e5f30b5efeb5e97f5ef55ba07", + "0x00c785fb523e770b855f5a8f4bcff502dc4ae56e5dcb87030ea7135262441e9a", + "0x0d0da98bee418d7d5447b0b9f149280d02d3119d074c67428254b1b6e48d4725", + "0xb654a1a566453851ec2f35198e6992bb9af61b4c4bbb9383d0605d3898fe90ee", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x297946c26171008BA8c0e5642814b5Fe6b842Ab7": { + "index": 31, + "amount": "0x01", + "proof": [ + "0x7a8d49e3c3e8393ef3685f74ab20de7b891ab96d1fd624ce041a81ccfbd28a22", + "0xd99ecdee3eb555438db6d25ef37392bead4a46bf9f267c67c4d6f2e9526e06cc", + "0x0a5c96ccce526b37acbd9cbea1f54a3b0d7d9355bc5b2e73685641ddd1691dbe", + "0x7bd2d29f4e05262244eb00af397a27132489abd476657497c2091a5e09fd028d", + "0x6bb1e68faf6241a81d5f80cdce73750e9979840cd454e701f5027975e0839c13", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x2Ea631BDa7f9Bb50b441C7d627f0a89D1fEe0Ebc": { + "index": 32, + "amount": "0x01", + "proof": [ + "0x92359e659e48a734d320a1758314026ab379da7d0487af6105461c67c30a1aa8", + "0x4c2617bcda69bc0d1946d7c70b97df2337a6deeeb15143a892cf1482ab04b23f", + "0xb4fec3235be97a74c6d3a1ddbb5e2ca83b6851ee0a5698d087e4d674ef1523eb", + "0xe1fb9cfbf2109f088b0cc3e464d6a88d8ce475c0df0baeaa065f9bf5438fcf28", + "0x28acf9aeee9dbbfe59ed9a35b834f1bb8f030da25f10829a720689183c091e8e", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x2FD9AbB389214cD5fe9493355641229428cC5Fec": { + "index": 33, + "amount": "0x01", + "proof": [ + "0x19d110c871f66facf78040b5f18c8d353b5a0452cc3e05dfad4d881adb617c2f", + "0x21bbecb7a6521951b0e7ddf2b677d5dbe39fefdeafc51a62b6322293c05834a3", + "0xa77edf59a8449f5f298e1693a0f6fe156e33c8defa73bf9af52d31f9956ce8a5", + "0xb21ede7787a0a8b0437145982a83b864f2e47c687aded37139d31a4560feeaef", + "0x08516e24629ac2a05afad7d0082e47b87252429c85dba8347bb8d99ebd15917c", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x2a8600bBDAab254A2F8A8E00912799295C3DD601": { + "index": 34, + "amount": "0x01", + "proof": [ + "0xc86e95cbc857254c09bd937edc0542aa1f23f435fdf84f43fde587ef9cfc4cda", + "0x4435fde9cc1355b864440247f9cf1b28d75f5ed906cc256901a2fe4c1474b4ca", + "0xf5abed670baf0190a0a91df408d65698c3209dcf17a843f9e5fcda9bd8959a17", + "0xd9184a25eeb4f87cd2425cac26ac77cf668feab72ea6bbd3b110892fbe584508", + "0xce3c2cae572bf1ea81613ef7fc064010151dbd5264896982059a3d31ab366fcd", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x2b6336412636616e9158252999432e1D6938F89F": { + "index": 35, + "amount": "0x01", + "proof": [ + "0x8258af328e4fb63c18cba2922a17fb83d032528c4580e761d599eff99b6ef92d", + "0x849635b046d19849d500ef851c2e33651a284eba2e781123b574291db1f00593", + "0x3702841d6d320aaba6b727029ead617540aad4832009b222b2a880f54f501d67", + "0x7bd2d29f4e05262244eb00af397a27132489abd476657497c2091a5e09fd028d", + "0x6bb1e68faf6241a81d5f80cdce73750e9979840cd454e701f5027975e0839c13", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x2cADf1261E6E1eEbbDf1a4B50a8d610400289520": { + "index": 36, + "amount": "0x03", + "proof": [ + "0x1ab8d1272ba55f54686042ec354e9c4ce9d9f8857bb862421298b1e06f994b9c", + "0x21bbecb7a6521951b0e7ddf2b677d5dbe39fefdeafc51a62b6322293c05834a3", + "0xa77edf59a8449f5f298e1693a0f6fe156e33c8defa73bf9af52d31f9956ce8a5", + "0xb21ede7787a0a8b0437145982a83b864f2e47c687aded37139d31a4560feeaef", + "0x08516e24629ac2a05afad7d0082e47b87252429c85dba8347bb8d99ebd15917c", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x33eBB62DC9ddBf6B8F3C0efdF5BccC2e7AC60211": { + "index": 37, + "amount": "0x01", + "proof": [ + "0x484d93c8083c6665ca86aa42b34af14a40c47d381cad976456864fcfd835127f", + "0x6836792f6523f1ce63021a8e8f1f0b6df52704a223f9198088a5164651dd450d", + "0xee0321a702d99edfdf36d62367c275274518018d5f5d106fce98072476620f9c", + "0x62ca54c10d0d2e8f11b95ce1e622c1071c735ba393fa4d8574607daf6a853ebe", + "0x86373cbc149bf07a85d55b4c3cb8102ed404b3acd5444c368631ed78c89511e5", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x3477823dc687e24147494b910b367CC85298DF8C": { + "index": 38, + "amount": "0x01", + "proof": [ + "0x9d8fc64bea1d1462da916653defd811c5772886be35382d8497aa6d873481b6a", + "0x721a6e333d44569a347959958185be645b3d4299144728604cb10639520fb169", + "0x086ebe30a2720a483fda3431b8859546cf2996b8f18a02045112e469db21cd79", + "0x930fec2c2d175134b5a08f2432bf7e01104646b61dee15c531d62ad698c4b460", + "0x28acf9aeee9dbbfe59ed9a35b834f1bb8f030da25f10829a720689183c091e8e", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x35E14B0722Dc1a81893FF8F7f99F931aca5B2d25": { + "index": 39, + "amount": "0x01", + "proof": [ + "0x0d9bd2f4c69eec5a068ec18033d678ace66ad1cb14238f201785c5f94e7eb3ab", + "0x50ec89f4fb48e8f6c5bddad6acfb77324cad483cee274590dd8b76ced5491634", + "0x3a5db6056b8109ccd710bcec9b1f94d65fda06943c72c7a79ad08305276b8e63", + "0xb64575b2e5c17b269a7b54aad00cb5ae485e6d3cd97f9b696f2c348980c80376", + "0xcbc27f89cff792994dade0a33179d3255f98b752d247709d3ac3afbb50e6678b", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x38148eCC2078dA7f65E6233DDA28eFaf4C51E96F": { + "index": 40, + "amount": "0x01", + "proof": [ + "0xb63ff43dc05daa88867809f6f4eccc7819dce462ce855485dd394921374b0109", + "0xd32a12aa4f2759034ce7b5445123946fd33ab0c7076a5b573c1f1a3f40abd135", + "0xdc4e7219a44becb0ffe5cf27abd1dd6df2675bc95eefe6c0595876d9ed1a63d7", + "0x7be11c45c5666355fb967ece1269c0e78498643ab2b2435f7cddf99ab8b39422", + "0x1ae23534fd2ec3b68f5762f60ee913ca81f956ea9ddeee68a6f8f4427a5a56d5", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x391891Af67E29D97E61E30C3036a0874F5Da411e": { + "index": 41, + "amount": "0x02", + "proof": [ + "0x694788cca2374874e7d855e8a36467e2f2a0c54dcf4c10d1457a693579e57f41", + "0x59a8c420db51cb57a961c3bc018e5df7c035f192981b8c3f38da17f1fc3c8f96", + "0x656d4eb2cf8aeda1c313a6e5cf200c987172917d24ebde8f8cef67b1854f43ba", + "0xb46aef78df30b13738edb3464ba4c37561bf949ea83771c3a8ffec47c242fca4", + "0x8a2a892a2a632adf2f1f7df50cfe964e48bf81690e7a3c82aa6be34a79635896", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x3A409EfF50A47aEeF294E3f0BB3874490dD99abc": { + "index": 42, + "amount": "0x01", + "proof": [ + "0x08bc8b341fa17c5a868550f7764a4840de40a8f933739d886a53c2559b07445d", + "0x057ce8fac654ea1d9faee1b816e5dbae926b084690c3fee298f2c9ddfa250756", + "0x4a54ff6bd65fd2eb3e648c37e076c1749a0d5447a8652ffc13ceb567def05fa2", + "0xc9483a8ee2897792a07d445fd7e441987e2e09db3bd94d45a4f7b5a4164ac998", + "0xcbc27f89cff792994dade0a33179d3255f98b752d247709d3ac3afbb50e6678b", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x3Fd1DdF28f604CFe5FEFA3adc38e38BE2F7208d6": { + "index": 43, + "amount": "0x01", + "proof": [ + "0xf8c3250f05818dfb0cb7fb76a63d3d9d351f8fd7f15225e88359f1c48df5e9f4", + "0x0365311bfb3e1de8620157c44a3233b46601c6f740d0f9cbd157df707509325b", + "0xb5e32c61e30be19fa7f3bfd310e5b8b415935a0884b889f3193bb3f4045e29e8", + "0xed856c374c426cdff99c626612739a1e89c2035df4f6a7667e3ad58492f8df83", + "0x71d69f595b35fee0a6d4187afc71b6bbff74c91927c4d72dae6c9dc0fb7e878a", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x3a44808bd1BD0225c7f17Ec0597C2bbB83513C89": { + "index": 44, + "amount": "0x01", + "proof": [ + "0xbc84f34bacca86ffe4a8a012aa445368ac767488eb9631c5d4b70ba04c475842", + "0xc95d835c748b5e7954cb0dd70b1a1bdfb56c1a4371423d44af65f6501868acdc", + "0xa28387a156c9f4954d9607a9ac4f19c1c5d457a48cda78448a477aeb395467b2", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x41F6e96FA35b6DD35044E171E0f6d163A3A77F53": { + "index": 45, + "amount": "0x01", + "proof": [ + "0x6c0220c8c80b764f47269692c0da242e23f545886f9cfc28d3f05248718ca024", + "0xe12ee3b3863caa35f4bb0a76cf89e6f32891897d303dc3f6ad03d2acc9c89310", + "0x8fa28fe1927369e107a95848594ef796b7bef6240d6b34a6cfff9259c5f1f55e", + "0x472ad2456c55e2e0144a5164c7ba8b34a827db0c91aedbce9484da200426d438", + "0x6bb1e68faf6241a81d5f80cdce73750e9979840cd454e701f5027975e0839c13", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x433663f1258376f0C7aec8fbC5CC81292e921527": { + "index": 46, + "amount": "0x01", + "proof": [ + "0x901bfd67bdc1bbfc28eee28b8d8d6772eaad06047566d0283fb191c137e7440a", + "0xe5d0d4de7efa65716c21f804bba4439f3c7f5afcd866b647c59f15bac2c8b574", + "0xf8c29056ebcfe5fae8fd66c73dc80d748471d6e92447b781ee16e15ed7060308", + "0xa9c14b7bde5f6bd300bce856d17e01e920e75da313902e045b4b3e048962526c", + "0xb654a1a566453851ec2f35198e6992bb9af61b4c4bbb9383d0605d3898fe90ee", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x441557092fCD8e979a64Dc8b44216F8CF6d07880": { + "index": 47, + "amount": "0x01", + "proof": [ + "0x06f304ff2d05e299ff7435f467bf1466c8e6f629e44debb69c37f4540ace04fa", + "0x46fcb09374e0cd462e5e1f3b4e7ccdb7e6a3783ffb54b9ff10eb7931da9ae58f", + "0x4a54ff6bd65fd2eb3e648c37e076c1749a0d5447a8652ffc13ceb567def05fa2", + "0xc9483a8ee2897792a07d445fd7e441987e2e09db3bd94d45a4f7b5a4164ac998", + "0xcbc27f89cff792994dade0a33179d3255f98b752d247709d3ac3afbb50e6678b", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x45C2700a0b0e84FffFfC74dbe4Ca415BC940F93d": { + "index": 48, + "amount": "0x01", + "proof": [ + "0x8150030f7b4d08ff40eea36e54f900aedd5d24b922338ad21f89c250df985278", + "0xe3c6f374609d85e5933e77e92557dc37b52462c8dd7b4f1b5dc74d4ce5d4e26f", + "0x3702841d6d320aaba6b727029ead617540aad4832009b222b2a880f54f501d67", + "0x7bd2d29f4e05262244eb00af397a27132489abd476657497c2091a5e09fd028d", + "0x6bb1e68faf6241a81d5f80cdce73750e9979840cd454e701f5027975e0839c13", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x46847c1bE6CCf8CB2510A88896559152AE11e83f": { + "index": 49, + "amount": "0x01", + "proof": [ + "0x261d63fe311e4132175ee5a99659dd86ab546feca09d7a52bc0a498b995dcb09", + "0x4c8014af774aaceb6c6a6050eb01fd6e03baaa3bd661d49893d945605d39387a", + "0xe11251280abfd46378ca9ca336e9954dad085a38edcbca705ec534447a68e2e4", + "0xda4b6bc089b72bc047b6c6fed7fe7fcd52dd68b9d13d6be60c86383ca2ace879", + "0x3784903b025be81b83e9bb4752292191cf517ec429d6662e8b71177a2d5d4ce4", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x4B78e19f34bDB0B2AE16Ad9888Ae1E3cA5998D2c": { + "index": 50, + "amount": "0x01", + "proof": [ + "0xc27e858f4e4686ba988c972024cf0d13482f55389eee280e27e522c25822db8e", + "0xc1633d06fc80c73d6816fa099ad6321fc2b3d603fba870e07df72e722812f541", + "0xe09f40c84b8e41eeaa1090ec7ac0b8eb2b2c5243c7e81e00d5910e03289e229c", + "0x7be11c45c5666355fb967ece1269c0e78498643ab2b2435f7cddf99ab8b39422", + "0x1ae23534fd2ec3b68f5762f60ee913ca81f956ea9ddeee68a6f8f4427a5a56d5", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x4c1bcC8F570e9F98Fab0eAE6b14F4df6E90CB8F7": { + "index": 51, + "amount": "0x01", + "proof": [ + "0x83695e5fafb44c7b66c16942c314aef818d5ab7409189397dc077fb97cc00342", + "0x9862f4bfdc51e24c3d90e72cb0e4a71823def15b9950a6defd3ef680ee028bfd", + "0x5c107555f7f57cb8c8f52941d77a7ee7824e0ce08328394ebd3660ecb496a75b", + "0x0d0da98bee418d7d5447b0b9f149280d02d3119d074c67428254b1b6e48d4725", + "0xb654a1a566453851ec2f35198e6992bb9af61b4c4bbb9383d0605d3898fe90ee", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x4eBf55228579DF2EB6Ba59DED18c13f3891f39fE": { + "index": 52, + "amount": "0x01", + "proof": [ + "0xc1a4ff1d01d1005511761951eb9cb6b07971719fba8b594aea2c0693786d0175", + "0xc1633d06fc80c73d6816fa099ad6321fc2b3d603fba870e07df72e722812f541", + "0xe09f40c84b8e41eeaa1090ec7ac0b8eb2b2c5243c7e81e00d5910e03289e229c", + "0x7be11c45c5666355fb967ece1269c0e78498643ab2b2435f7cddf99ab8b39422", + "0x1ae23534fd2ec3b68f5762f60ee913ca81f956ea9ddeee68a6f8f4427a5a56d5", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x50664edE715e131F584D3E7EaAbd7818Bb20A068": { + "index": 53, + "amount": "0x01", + "proof": [ + "0x5aa131e6ccc09f5178a86666d8cd8e032b99739b9212df2afdf12d9d18ffffcc", + "0x6a13476836cb8af3e238a715f2ba2f1617d7e45af54ae4541f4e02d8ed2c1677", + "0x4166276af4821b7e02ad4e901ba1c008614f51459cd39c81ccbf08a195fadac1", + "0x2ef2c623cd26819e676f6295abaad8ef34c204b71b3ae644be0cefa86e3150b6", + "0x8a2a892a2a632adf2f1f7df50cfe964e48bf81690e7a3c82aa6be34a79635896", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x512a49C299F5F60EDc1EE147abF1d68B41de4737": { + "index": 54, + "amount": "0x01", + "proof": [ + "0x2b0c4e41c0a6543b3d690f8180cb2a4b9e050887812158ba10e57b059ea6aa7a", + "0x955756148e703ef9a8c9c71ca5418819127cae616dfd3d383d78feb109a662a8", + "0x5208575fb8340b178b6659fb29b2fbfb299ef7a72affc3bc356f4a9364de55e8", + "0xda4b6bc089b72bc047b6c6fed7fe7fcd52dd68b9d13d6be60c86383ca2ace879", + "0x3784903b025be81b83e9bb4752292191cf517ec429d6662e8b71177a2d5d4ce4", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x5136cDFC4D2b1A74774F5137095F82f88Af5ec99": { + "index": 55, + "amount": "0x01", + "proof": [ + "0x5cb0a5cb09aa56a03301172fda1fcf1865155b2b71b3fd24c86a6252ad5a78f8", + "0x246772b7d1010891a99b75e6d019e70cb5cc286162551f2292546369c6c99616", + "0xf92aa902ffa739c5a1075086d0bbb171c03745ac9446538e400f447857437193", + "0x2ef2c623cd26819e676f6295abaad8ef34c204b71b3ae644be0cefa86e3150b6", + "0x8a2a892a2a632adf2f1f7df50cfe964e48bf81690e7a3c82aa6be34a79635896", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x51c60c3cd234430A238f33559D8d4aA646741820": { + "index": 56, + "amount": "0x01", + "proof": [ + "0xdbdfdb952108ffcce446f6898aaa944fc6c4f3e35cf369f03bbb9318b525cb3f", + "0xfc1e64cb878a2ca012d818370c3cc15a0d7d6be19796a55a23298d08a91cb7c1", + "0x7a9470d7c062a7c326d834ae050d2362978da7e4f2562b3c749901732949866b", + "0x6bc340367ac6009abe512f43268c0c5efb547c716b06709e20656240cee5d67a", + "0x71d69f595b35fee0a6d4187afc71b6bbff74c91927c4d72dae6c9dc0fb7e878a", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x5356b6e62112C8D527Ca3658FEEba765e590aAbB": { + "index": 57, + "amount": "0x01", + "proof": [ + "0xfee4d23aecee0da263a22238b1fbc81a5fbd3ec0dfebad7950cb28604de36e02", + "0xff52f9472ecedb1cc3a1bb8ecff44721cd61f43fe5513fe5f81ec20d234a0b94", + "0xc95d835c748b5e7954cb0dd70b1a1bdfb56c1a4371423d44af65f6501868acdc", + "0xa28387a156c9f4954d9607a9ac4f19c1c5d457a48cda78448a477aeb395467b2", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x5389477e84b4B7e693940a135BF0C1928d232840": { + "index": 58, + "amount": "0x01", + "proof": [ + "0x6a4cae28f4021f8c24885c2f7ac1417863868d5d50d6985f90ec70bc85311cfe", + "0x62c2f8cd12c3d4bb3ea13169462ac39c59c887692229e5635fe490347ca9cc5f", + "0x656d4eb2cf8aeda1c313a6e5cf200c987172917d24ebde8f8cef67b1854f43ba", + "0xb46aef78df30b13738edb3464ba4c37561bf949ea83771c3a8ffec47c242fca4", + "0x8a2a892a2a632adf2f1f7df50cfe964e48bf81690e7a3c82aa6be34a79635896", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x5477729b43A0A9beA8c41367C62e7864123B57d8": { + "index": 59, + "amount": "0x01", + "proof": [ + "0xa850221126979683cdca4bf3eaaf553406e3f040ff754e640ac58a67aa01f06f", + "0x23115e32a9a585e9685aef68cf905061ba7785000006cde35f7408a92d17a805", + "0xb6757d5e45ae60417249acc37e28f4a986e39deb356ba67a14b501fce218e39a", + "0x027dd52a5591276c58d2b79d691dd8cbbc85f5645392a665f5955e389f86c024", + "0x1ae23534fd2ec3b68f5762f60ee913ca81f956ea9ddeee68a6f8f4427a5a56d5", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x560feFC8f45b8d43f86F79F718dd0364d42037BD": { + "index": 60, + "amount": "0x01", + "proof": [ + "0x400ef08ea0e19537b5298cfd2e2eb7b967569e4125601beb6b8c2c7a4ffadf22", + "0xce179b69ad031a12e56d0b72c206a09cb33f737ecbc71cc9a69c250982b1212a", + "0x70c1e14739c966ef5e24983ec018e0476325243ef26be486620edc26445e05fb", + "0xda7f239c88a5b772a2ff14bce5086ce21c104bb4ede8fb05b792ecd4ca562d5b", + "0x86373cbc149bf07a85d55b4c3cb8102ed404b3acd5444c368631ed78c89511e5", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x56341B69586dCEb4e2a2A1432D944B9C0828fD84": { + "index": 61, + "amount": "0x01", + "proof": [ + "0x18d4418bdb29a032fa90cfa84bc95bef7e2718541656d8982adec64df36de4bf", + "0x9f77264ea839cce7398b32bd2ad8d702ce2c76abe600a910037806983bbc7c50", + "0xa77edf59a8449f5f298e1693a0f6fe156e33c8defa73bf9af52d31f9956ce8a5", + "0xb21ede7787a0a8b0437145982a83b864f2e47c687aded37139d31a4560feeaef", + "0x08516e24629ac2a05afad7d0082e47b87252429c85dba8347bb8d99ebd15917c", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x568106712b41EacbF2A8643Ed2095b5327B61a5D": { + "index": 62, + "amount": "0x01", + "proof": [ + "0x5bdfcd69abfe35f5d9be893704de61fd45cbcd9a2dee5513ec383326952821d8", + "0x172ffed6e628d62c1effe22a12ea2a732fed0639aa6ff9e166f219a55acfe012", + "0x4166276af4821b7e02ad4e901ba1c008614f51459cd39c81ccbf08a195fadac1", + "0x2ef2c623cd26819e676f6295abaad8ef34c204b71b3ae644be0cefa86e3150b6", + "0x8a2a892a2a632adf2f1f7df50cfe964e48bf81690e7a3c82aa6be34a79635896", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x5784fF641C2AeEE1339c4c32dA28d2E2E975BD3f": { + "index": 63, + "amount": "0x01", + "proof": [ + "0x1799fd0a921d37b27141b3c62292ff9cec5ddf234f0c589c06d5c60128c0e39b", + "0x9f77264ea839cce7398b32bd2ad8d702ce2c76abe600a910037806983bbc7c50", + "0xa77edf59a8449f5f298e1693a0f6fe156e33c8defa73bf9af52d31f9956ce8a5", + "0xb21ede7787a0a8b0437145982a83b864f2e47c687aded37139d31a4560feeaef", + "0x08516e24629ac2a05afad7d0082e47b87252429c85dba8347bb8d99ebd15917c", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x584313319d0bFeAd2a9d98a7154f5dCb5a62887F": { + "index": 64, + "amount": "0x01", + "proof": [ + "0x36f652dccdb5398dba4da6ee818a05da786b6c2bff663341c16608b88f25d346", + "0x35a6c4832ddbc9480d1b26a3ec4e2fd43b7b240f965a9f3c52e055abef1d97e8", + "0xa9e692419cb4f94f85f7a3cc302df5c748e87c56568a4cb3a6f25ed770c307ee", + "0x9f2ec78bac177b82e65626eb3f7b76e2644d8a7282cc3be0840fb0ecd772d993", + "0x3784903b025be81b83e9bb4752292191cf517ec429d6662e8b71177a2d5d4ce4", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x592142078AB4c94d3382f997456D92e3d9F3accB": { + "index": 65, + "amount": "0x01", + "proof": [ + "0x9c6cead2fee1492cee79a613df4917af4061a627c6bc2763aaf5ae15b183c175", + "0x89344024be30fece69aa991bfe664f8db5a5bfeba1946d9202eae9cecfc026ab", + "0x086ebe30a2720a483fda3431b8859546cf2996b8f18a02045112e469db21cd79", + "0x930fec2c2d175134b5a08f2432bf7e01104646b61dee15c531d62ad698c4b460", + "0x28acf9aeee9dbbfe59ed9a35b834f1bb8f030da25f10829a720689183c091e8e", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x5B81ac639448Ea477C6147eF7EA9b7c04C6F89a6": { + "index": 66, + "amount": "0x01", + "proof": [ + "0x45558a9dd5b6364c06b642cd97438152c527b66155cda07ca9d156b87c2851f4", + "0x6836792f6523f1ce63021a8e8f1f0b6df52704a223f9198088a5164651dd450d", + "0xee0321a702d99edfdf36d62367c275274518018d5f5d106fce98072476620f9c", + "0x62ca54c10d0d2e8f11b95ce1e622c1071c735ba393fa4d8574607daf6a853ebe", + "0x86373cbc149bf07a85d55b4c3cb8102ed404b3acd5444c368631ed78c89511e5", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x5bbB65fe6E990f2DCDF95FE7E71f07264c5993ac": { + "index": 67, + "amount": "0x01", + "proof": [ + "0x4246c949ffad00e4e778fbc4acc335149f81e071a855894f905325c5527a1e2d", + "0x7f64feca5e6002e41d339823fec8dddd95980c69a7c87f3a9964cae54755c2a9", + "0x8d04ed65a88640cfc16aeb35d55de80ad6bddbf3f2166a56343c6dd7d9444410", + "0xda7f239c88a5b772a2ff14bce5086ce21c104bb4ede8fb05b792ecd4ca562d5b", + "0x86373cbc149bf07a85d55b4c3cb8102ed404b3acd5444c368631ed78c89511e5", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x61d84d65d0cD1B0D22EeA94A80f15554e3304E49": { + "index": 68, + "amount": "0x01", + "proof": [ + "0x3dd8de54cdfe414a712646c1ce2e05106cb5d94e2779d09a47f75df1c6fcab6b", + "0xfc543c4698375a26135e828192ea0bee900dba8bf3a05e5be1006f20cca48884", + "0x70c1e14739c966ef5e24983ec018e0476325243ef26be486620edc26445e05fb", + "0xda7f239c88a5b772a2ff14bce5086ce21c104bb4ede8fb05b792ecd4ca562d5b", + "0x86373cbc149bf07a85d55b4c3cb8102ed404b3acd5444c368631ed78c89511e5", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x6368CE2750325f5002587C70C8Bc298B4df61EBA": { + "index": 69, + "amount": "0x01", + "proof": [ + "0xe5ae69cbf4be96fb2317d4538e83677bb69b42ecab1d4a9ff708281bf146f614", + "0x513cf550b0565a71891b008d28be44efbb7db973f422ee977ee84f722a2bda14", + "0x771cb4e120fb08a7b89c5df1e50c7a6545a0ec794149afd5b45339f31bdaead3", + "0x6bc340367ac6009abe512f43268c0c5efb547c716b06709e20656240cee5d67a", + "0x71d69f595b35fee0a6d4187afc71b6bbff74c91927c4d72dae6c9dc0fb7e878a", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x64dF7AF696e0977771a0E1e1B1a8dD22DED3Cf4b": { + "index": 70, + "amount": "0x01", + "proof": [ + "0x4139316c7d801f01f42b504d0d8b290fa905f772edfccbbe7c1ef13a869c67e3", + "0x7f64feca5e6002e41d339823fec8dddd95980c69a7c87f3a9964cae54755c2a9", + "0x8d04ed65a88640cfc16aeb35d55de80ad6bddbf3f2166a56343c6dd7d9444410", + "0xda7f239c88a5b772a2ff14bce5086ce21c104bb4ede8fb05b792ecd4ca562d5b", + "0x86373cbc149bf07a85d55b4c3cb8102ed404b3acd5444c368631ed78c89511e5", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x65CAc1fc7489f7B08156e2e95db4cb35C7C29b4f": { + "index": 71, + "amount": "0x01", + "proof": [ + "0xde047987de37e57b051d05408b8175957809d4a98d4daf34f3ff556721b306a2", + "0xfc1e64cb878a2ca012d818370c3cc15a0d7d6be19796a55a23298d08a91cb7c1", + "0x7a9470d7c062a7c326d834ae050d2362978da7e4f2562b3c749901732949866b", + "0x6bc340367ac6009abe512f43268c0c5efb547c716b06709e20656240cee5d67a", + "0x71d69f595b35fee0a6d4187afc71b6bbff74c91927c4d72dae6c9dc0fb7e878a", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x66E210090aD8f00Cb3915b48ff4E67EaA0282053": { + "index": 72, + "amount": "0x01", + "proof": [ + "0x752ec61d1015a4d3fa228c692315d3bd10d024f2334b438748da9a0c42134612", + "0x9dc55551e92c200f6bbccb7b03c4364349523ee3f0236313a52fd1b2f1b4237c", + "0x22f1713f0f81d5e118ec7f5262909f3724ffc3ef647f9a34eaf8382a5b416f7f", + "0x472ad2456c55e2e0144a5164c7ba8b34a827db0c91aedbce9484da200426d438", + "0x6bb1e68faf6241a81d5f80cdce73750e9979840cd454e701f5027975e0839c13", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x67D33CF1C7c699078f86D517A5a1cd1444A1E85C": { + "index": 73, + "amount": "0x01", + "proof": [ + "0xfb16aa27068430b2238a36bd326383c4f53d2ba94ae39babc3cfa2bc1dcd8914", + "0x2dd24c027a3bdbd05532fd92f36f74c32e6e27a8ca5abb3f7e731a37f0eba4dd", + "0x7f7d059a484fc78b87c1b6419a9f6ada2b19a94a6be65024ee86971d55c384bd", + "0xb867795c31665082bd4b62531e021fd6824408948736b0ddb1c8b57e1c294a11", + "0xa28387a156c9f4954d9607a9ac4f19c1c5d457a48cda78448a477aeb395467b2", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x6A9ee69B6781C18164ee9F7C58f1763BcFfC7c51": { + "index": 74, + "amount": "0x01", + "proof": [ + "0xdabb1771582956a7375f27b80f9c9b21066b0c33b7bcc75d6cb710b512204a81", + "0x8ca8b6cb702054f622c5b0c6455cac153f54ec5bb278889cff32775e57182188", + "0x7a9470d7c062a7c326d834ae050d2362978da7e4f2562b3c749901732949866b", + "0x6bc340367ac6009abe512f43268c0c5efb547c716b06709e20656240cee5d67a", + "0x71d69f595b35fee0a6d4187afc71b6bbff74c91927c4d72dae6c9dc0fb7e878a", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x6Ec4DEFaAA028bbEe11494baaCb9067F083C359f": { + "index": 75, + "amount": "0x01", + "proof": [ + "0x820208412871c52531a342038388b9d2ae5f1b0facae04641b9afabab40c0a8d", + "0x849635b046d19849d500ef851c2e33651a284eba2e781123b574291db1f00593", + "0x3702841d6d320aaba6b727029ead617540aad4832009b222b2a880f54f501d67", + "0x7bd2d29f4e05262244eb00af397a27132489abd476657497c2091a5e09fd028d", + "0x6bb1e68faf6241a81d5f80cdce73750e9979840cd454e701f5027975e0839c13", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x6b0bf3dd3F83c1776769a87cb080eF370288f355": { + "index": 76, + "amount": "0x01", + "proof": [ + "0xed1b00f7cae138c1fbbc98f326165e4ba47a4453042f1759a2ff6c67fabf5192", + "0xe47cce1ecc3d20cae763512c936eeb1ed70b9cbd3cc814af99fd950860463567", + "0x58bf589fe305ed7bb05181f5e2bdaa02f4e5bf894ede44f1b05c8404228bb127", + "0xed856c374c426cdff99c626612739a1e89c2035df4f6a7667e3ad58492f8df83", + "0x71d69f595b35fee0a6d4187afc71b6bbff74c91927c4d72dae6c9dc0fb7e878a", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x706Ca95D326420e4270CD4e83be82B023dA208dE": { + "index": 77, + "amount": "0x01", + "proof": [ + "0x91e290fe42b1973693f616003c89c53d971d1bf2aa2f6336a4b1d1d0aa140c2c", + "0x4c2617bcda69bc0d1946d7c70b97df2337a6deeeb15143a892cf1482ab04b23f", + "0xb4fec3235be97a74c6d3a1ddbb5e2ca83b6851ee0a5698d087e4d674ef1523eb", + "0xe1fb9cfbf2109f088b0cc3e464d6a88d8ce475c0df0baeaa065f9bf5438fcf28", + "0x28acf9aeee9dbbfe59ed9a35b834f1bb8f030da25f10829a720689183c091e8e", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x723cdab3E2263bF7E7aA278C94186922D49FAA91": { + "index": 78, + "amount": "0x01", + "proof": [ + "0x771ef3d576f29052bed323049ac17fb231583af4d0bd94903de3ccaa55dacd3f", + "0xb06d99a5451a1b99d26d737f7623e88fa28b99bf9fe38704e553c08ad7107916", + "0x22f1713f0f81d5e118ec7f5262909f3724ffc3ef647f9a34eaf8382a5b416f7f", + "0x472ad2456c55e2e0144a5164c7ba8b34a827db0c91aedbce9484da200426d438", + "0x6bb1e68faf6241a81d5f80cdce73750e9979840cd454e701f5027975e0839c13", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x74036E47A7E978ad1e29be4F23398b66795AF786": { + "index": 79, + "amount": "0x01", + "proof": [ + "0xf9c4611aee8c8cdaff0ebf0f683459391bdc6fe7e717864579834c91cae4ed64", + "0x2dd24c027a3bdbd05532fd92f36f74c32e6e27a8ca5abb3f7e731a37f0eba4dd", + "0x7f7d059a484fc78b87c1b6419a9f6ada2b19a94a6be65024ee86971d55c384bd", + "0xb867795c31665082bd4b62531e021fd6824408948736b0ddb1c8b57e1c294a11", + "0xa28387a156c9f4954d9607a9ac4f19c1c5d457a48cda78448a477aeb395467b2", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x741bD2e9cd525D1b88972b32b0Dba5e257ce8978": { + "index": 80, + "amount": "0x01", + "proof": [ + "0x50591cd868c957c4e8617cecf5c061848471f9f9e05426958d3489898ac03f54", + "0x99ae07a4d1f66812d6c39a4910260b6bd138ec3b6204393825a3e5f947bb4fad", + "0x89161607a370d2cf202a6b57a566ff2e4ff40dd0763aade2c7537263295ceaf7", + "0x62ca54c10d0d2e8f11b95ce1e622c1071c735ba393fa4d8574607daf6a853ebe", + "0x86373cbc149bf07a85d55b4c3cb8102ed404b3acd5444c368631ed78c89511e5", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x762d0629c46a1D6EC9D83F0f146F177922333039": { + "index": 81, + "amount": "0x02", + "proof": [ + "0xfccabd7b6ef8355bdd5dbefeced51e55be6b239fa3be200507587973e774ae4a", + "0x0a249872a1f7ab42ea1b908b0200991e32df99685f3ed168a4c3ee35126992a9", + "0xfe622aef6c55ecad704e4012913430d112a6749301f3bcfcc64dedfdadbcb658", + "0xb867795c31665082bd4b62531e021fd6824408948736b0ddb1c8b57e1c294a11", + "0xa28387a156c9f4954d9607a9ac4f19c1c5d457a48cda78448a477aeb395467b2", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x77c4a515d6779f358d9C70b78c18715EE352CadC": { + "index": 82, + "amount": "0x01", + "proof": [ + "0xaab298d9524d360eb547f218c19ee1064a56dc048a5c2780709ce68ca979f868", + "0xbc89bcb2d25063236537c931fd5443acf73349866e003e97bf024509f41a94b2", + "0x3012485b6b7f5ab71c4b1ca94bd1af248e606331cde37d005ff3bf07f6430c78", + "0x027dd52a5591276c58d2b79d691dd8cbbc85f5645392a665f5955e389f86c024", + "0x1ae23534fd2ec3b68f5762f60ee913ca81f956ea9ddeee68a6f8f4427a5a56d5", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x786a567eb7928fA25ed4b32a19982313FE89C743": { + "index": 83, + "amount": "0x01", + "proof": [ + "0xd7b1dbae5b9fb1fb2aac9dad29337211b882573c1b1c421ba7244df930974233", + "0x99a06f41cc94481935318c4265776e3b916e651fab846abced5c618d873b915b", + "0x99f0091db6a51b03d8a461655ef7e68150a2349be1edcb0dab9de795bdd645d9", + "0x5d0c037ff149aa61e68483d2aa89514545be2eba507b61f72e04da089b5134d1", + "0xce3c2cae572bf1ea81613ef7fc064010151dbd5264896982059a3d31ab366fcd", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x789146F9BCf06008D18b785912410F93b26c2340": { + "index": 84, + "amount": "0x01", + "proof": [ + "0x10e72485c6767a37dfc359ff84faee8a151b1d34806f2e55a372b9d07652a77e", + "0x125d5466ddb31e89648b093b699c84214dc4223cddc857faa92263b778608355", + "0x2758e8a25cc5d66b30b697aa228db9ea85e95e74c78ae8d4bb807812ab88f7a2", + "0xb64575b2e5c17b269a7b54aad00cb5ae485e6d3cd97f9b696f2c348980c80376", + "0xcbc27f89cff792994dade0a33179d3255f98b752d247709d3ac3afbb50e6678b", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x792703DEd46533458B92e9aaDF3610158f22B30f": { + "index": 85, + "amount": "0x01", + "proof": [ + "0xc803452f0348a8e0dc43fc1cef8d33c0eb7bdb2d185b01ef49a315cea51bc92f", + "0x4435fde9cc1355b864440247f9cf1b28d75f5ed906cc256901a2fe4c1474b4ca", + "0xf5abed670baf0190a0a91df408d65698c3209dcf17a843f9e5fcda9bd8959a17", + "0xd9184a25eeb4f87cd2425cac26ac77cf668feab72ea6bbd3b110892fbe584508", + "0xce3c2cae572bf1ea81613ef7fc064010151dbd5264896982059a3d31ab366fcd", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x7AA8B99093368A791e2fddbf3d34290A9091D21C": { + "index": 86, + "amount": "0x01", + "proof": [ + "0x7fa7789e08d6163b7cdc686d173eb0a2d95dac7f70fa832e21b186f2db850d53", + "0xe3c6f374609d85e5933e77e92557dc37b52462c8dd7b4f1b5dc74d4ce5d4e26f", + "0x3702841d6d320aaba6b727029ead617540aad4832009b222b2a880f54f501d67", + "0x7bd2d29f4e05262244eb00af397a27132489abd476657497c2091a5e09fd028d", + "0x6bb1e68faf6241a81d5f80cdce73750e9979840cd454e701f5027975e0839c13", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x7Bb9791eB21BCD77bDf700E81ba7529720AFF152": { + "index": 87, + "amount": "0x01", + "proof": [ + "0xf1c69398a570b531c3c65da7fefb1b8eb6f13af7de26fbb13f1316c5447a72ae", + "0x82419df43050157ccd6e78dab17d6d749c5d9e1af305c7a37f3b94c61372538d", + "0x58bf589fe305ed7bb05181f5e2bdaa02f4e5bf894ede44f1b05c8404228bb127", + "0xed856c374c426cdff99c626612739a1e89c2035df4f6a7667e3ad58492f8df83", + "0x71d69f595b35fee0a6d4187afc71b6bbff74c91927c4d72dae6c9dc0fb7e878a", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x7EE93e58F1784f23956De508ED0EC33ec8bE9701": { + "index": 88, + "amount": "0x01", + "proof": [ + "0x3a2f22a8806a6c667e72d0a81c378d5e1695ae7a5257dae08b420b4fec007cd3", + "0x35a6c4832ddbc9480d1b26a3ec4e2fd43b7b240f965a9f3c52e055abef1d97e8", + "0xa9e692419cb4f94f85f7a3cc302df5c748e87c56568a4cb3a6f25ed770c307ee", + "0x9f2ec78bac177b82e65626eb3f7b76e2644d8a7282cc3be0840fb0ecd772d993", + "0x3784903b025be81b83e9bb4752292191cf517ec429d6662e8b71177a2d5d4ce4", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x7b2c77e13a88081004D0474A29F03338b20F6259": { + "index": 89, + "amount": "0x01", + "proof": [ + "0xf718aaddb740004d16761f7a16e011916911858bc489374e9af4981da79c75a1", + "0x0365311bfb3e1de8620157c44a3233b46601c6f740d0f9cbd157df707509325b", + "0xb5e32c61e30be19fa7f3bfd310e5b8b415935a0884b889f3193bb3f4045e29e8", + "0xed856c374c426cdff99c626612739a1e89c2035df4f6a7667e3ad58492f8df83", + "0x71d69f595b35fee0a6d4187afc71b6bbff74c91927c4d72dae6c9dc0fb7e878a", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x7d4c4d5380Ca2F9C7A091bb622B80613da7Eae8C": { + "index": 90, + "amount": "0x01", + "proof": [ + "0x1f30d56d2cdedec3a0b1ba8611cbe376563269c8593e25ef0615b97f318543bd", + "0x0398918de9c23674d120e1c3ed3f872d7ab6e509a8ee8604649ff472802e58a0", + "0x23c008de9012b3127a46540f787a48c449965235c9f502b0bbb1719973199e73", + "0x3e7f8382a906db03cc3d1a09d794b375222411632d321f6070b091c1a5d92686", + "0x08516e24629ac2a05afad7d0082e47b87252429c85dba8347bb8d99ebd15917c", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x7f9C8843926De4b2eA6cBf9381F9f2FA81C58ed6": { + "index": 91, + "amount": "0x01", + "proof": [ + "0x8f64cecb8b077f9ff999d358878c074cbb1cec60d08d801d4e32d1978b8d0ce0", + "0x099a0575a47fc7c90d37ad222b796f591c4f3c8cc5430b475751e7ab4cb76e9a", + "0xf8c29056ebcfe5fae8fd66c73dc80d748471d6e92447b781ee16e15ed7060308", + "0xa9c14b7bde5f6bd300bce856d17e01e920e75da313902e045b4b3e048962526c", + "0xb654a1a566453851ec2f35198e6992bb9af61b4c4bbb9383d0605d3898fe90ee", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x81168C14e5A89f60b30e9a7f82A229406A64369d": { + "index": 92, + "amount": "0x01", + "proof": [ + "0x238b30523d36ca7b18159b1a70ed96285458ee6341e3ef9019ce81f6173c15c3", + "0x0526765e3e5369d7de5bb7ef6d825685af0116b2262ea4d31a26e72a914102a2", + "0xc30db538fdb7f80bae447b2d5300490287ab684bcf7e321bd1d145820c04a981", + "0x3e7f8382a906db03cc3d1a09d794b375222411632d321f6070b091c1a5d92686", + "0x08516e24629ac2a05afad7d0082e47b87252429c85dba8347bb8d99ebd15917c", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x81aA6141923Ea42fCAa763d9857418224d9b025a": { + "index": 93, + "amount": "0x01", + "proof": [ + "0xd61141fbc9e737a88508574d716735371ce49fb2806fa4d4ba0353a5f8e4ba29", + "0x73fb28028e5b620bdd6f7a00d9313680dab685f59b6b054f685857f2b17adcf2", + "0x9ff6d0995e7919e1977592bf9d9394aaba2c03cdfdc48dd0aee32d4431d791c8", + "0x5d0c037ff149aa61e68483d2aa89514545be2eba507b61f72e04da089b5134d1", + "0xce3c2cae572bf1ea81613ef7fc064010151dbd5264896982059a3d31ab366fcd", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x8402FC773764d6b4DF62b404381E3706aa4Bc62f": { + "index": 94, + "amount": "0x01", + "proof": [ + "0x01b7a1ad1911e958d0db9da347401d4073ebaef787b5ad119e61319881de4079", + "0x20f8ad8498f87f2ac7f8542060734ca575e9925b3794a66b35e6d71ccb861766", + "0x6044382fce0c9807f54e963af1749be8460153aa0c5865106eb4ee747208d0b9", + "0xc9483a8ee2897792a07d445fd7e441987e2e09db3bd94d45a4f7b5a4164ac998", + "0xcbc27f89cff792994dade0a33179d3255f98b752d247709d3ac3afbb50e6678b", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x84803775437A51BCD484Cf4Aa6beea1E50426eaB": { + "index": 95, + "amount": "0x01", + "proof": [ + "0xde6e49e0ba9ca0c0180740143c91a325494960dd1db66a064c7b8e66ffa3f339", + "0x1600a376b42bb946d99a1686831dc15b6dec6cb5fd5d17310e8f1b6ce6c35d07", + "0x771cb4e120fb08a7b89c5df1e50c7a6545a0ec794149afd5b45339f31bdaead3", + "0x6bc340367ac6009abe512f43268c0c5efb547c716b06709e20656240cee5d67a", + "0x71d69f595b35fee0a6d4187afc71b6bbff74c91927c4d72dae6c9dc0fb7e878a", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x87616fA850c87a78f307878f32D808dad8f4d401": { + "index": 96, + "amount": "0x01", + "proof": [ + "0x117063038866fa4ba6e07c0e40eba2838408809471792a410f451941360db552", + "0x125d5466ddb31e89648b093b699c84214dc4223cddc857faa92263b778608355", + "0x2758e8a25cc5d66b30b697aa228db9ea85e95e74c78ae8d4bb807812ab88f7a2", + "0xb64575b2e5c17b269a7b54aad00cb5ae485e6d3cd97f9b696f2c348980c80376", + "0xcbc27f89cff792994dade0a33179d3255f98b752d247709d3ac3afbb50e6678b", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x896b94f4f27f12369698C302e2049cAe86936BbB": { + "index": 97, + "amount": "0x01", + "proof": [ + "0x1fff94d8899083f4091f0675a5f0a6a24617ac5d54ffd34d04ae16a0cef21673", + "0x92843fd8056cd69aad0d008d7a0c1eb18fbd3c97121fd2a3a596575677f4e452", + "0xc30db538fdb7f80bae447b2d5300490287ab684bcf7e321bd1d145820c04a981", + "0x3e7f8382a906db03cc3d1a09d794b375222411632d321f6070b091c1a5d92686", + "0x08516e24629ac2a05afad7d0082e47b87252429c85dba8347bb8d99ebd15917c", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x8C2d93175B16a934aC806551aBe1442603d68206": { + "index": 98, + "amount": "0x01", + "proof": [ + "0x7171e5325e4378d170ece442e468ba6e3cb4172dadde7426e549c556e8534595", + "0x3017ae48b002c11b242f172900812c00b2aa04df40efea5afefc20691c88f227", + "0x8fa28fe1927369e107a95848594ef796b7bef6240d6b34a6cfff9259c5f1f55e", + "0x472ad2456c55e2e0144a5164c7ba8b34a827db0c91aedbce9484da200426d438", + "0x6bb1e68faf6241a81d5f80cdce73750e9979840cd454e701f5027975e0839c13", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x8C31FF1F7822838711DFeF8c4a88731072d6965A": { + "index": 99, + "amount": "0x01", + "proof": [ + "0x5f1c723f87756e2ea8f0aaca83778a199bcf0206cd42125356ab8c65812c783c", + "0x6074436da9fcec4cfe79a40ef542bc4899208ab1d8f0001adf90f92ee1fefcdc", + "0xf92aa902ffa739c5a1075086d0bbb171c03745ac9446538e400f447857437193", + "0x2ef2c623cd26819e676f6295abaad8ef34c204b71b3ae644be0cefa86e3150b6", + "0x8a2a892a2a632adf2f1f7df50cfe964e48bf81690e7a3c82aa6be34a79635896", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x8a9D46d28003673Cd4FE7a56EcFCFA2BE6372e64": { + "index": 100, + "amount": "0x01", + "proof": [ + "0x158da89241ca41ea1831d11ac60595b305e7a034d40d9c7c3117e3729e91270b", + "0xb74c9a792fcab35438fe260004d5090df457a5a35801482db3e471de88eb42ab", + "0x465e6bafbf8b6f363352a3e3a36f9e265db0c2b866ce9068dcc12adf9107ad37", + "0xb21ede7787a0a8b0437145982a83b864f2e47c687aded37139d31a4560feeaef", + "0x08516e24629ac2a05afad7d0082e47b87252429c85dba8347bb8d99ebd15917c", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x8eCD8F7aA146542E4FD3504b6b6C87cef6a31456": { + "index": 101, + "amount": "0x01", + "proof": [ + "0xe0edde0e822953b4e0829053a79f86a1e15114e9db71f6e5b844c8cf7f13fd48", + "0x1600a376b42bb946d99a1686831dc15b6dec6cb5fd5d17310e8f1b6ce6c35d07", + "0x771cb4e120fb08a7b89c5df1e50c7a6545a0ec794149afd5b45339f31bdaead3", + "0x6bc340367ac6009abe512f43268c0c5efb547c716b06709e20656240cee5d67a", + "0x71d69f595b35fee0a6d4187afc71b6bbff74c91927c4d72dae6c9dc0fb7e878a", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x92D385172c6eC14ED5a670A8148db3fD70F62A40": { + "index": 102, + "amount": "0x01", + "proof": [ + "0x0f91363c978351c76a2126378f7d5c93dc7b20edb3e4a4fb59bc09e9825ae131", + "0x8abc8ed00099d2108683f675559c7aa321002f0d2053b3ccb2c586e11ee804ea", + "0x2758e8a25cc5d66b30b697aa228db9ea85e95e74c78ae8d4bb807812ab88f7a2", + "0xb64575b2e5c17b269a7b54aad00cb5ae485e6d3cd97f9b696f2c348980c80376", + "0xcbc27f89cff792994dade0a33179d3255f98b752d247709d3ac3afbb50e6678b", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x94E2DcF00CF7e33a4643478bb458b8123043116e": { + "index": 103, + "amount": "0x01", + "proof": [ + "0x8e3c2b0da8efedca2aef5e42824cc6464bac3995ddc93e1260bb2eab1e370556", + "0x1d24b623a851d2d8288fe18d4841049213f0f31118ff4882feaefa828eebc3ff", + "0xc644c2e247edac46242eaedb98649150e3e4ed6e2a71819c401c47cdb8b7cd51", + "0xa9c14b7bde5f6bd300bce856d17e01e920e75da313902e045b4b3e048962526c", + "0xb654a1a566453851ec2f35198e6992bb9af61b4c4bbb9383d0605d3898fe90ee", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x95B92259AADaD128010B010622C65EEF5407de78": { + "index": 104, + "amount": "0x01", + "proof": [ + "0xdba1c84b79804fd868bb0da60818a9dd3cf8e86cf5ab685e7b3fe9b8f0b76a53", + "0x8ca8b6cb702054f622c5b0c6455cac153f54ec5bb278889cff32775e57182188", + "0x7a9470d7c062a7c326d834ae050d2362978da7e4f2562b3c749901732949866b", + "0x6bc340367ac6009abe512f43268c0c5efb547c716b06709e20656240cee5d67a", + "0x71d69f595b35fee0a6d4187afc71b6bbff74c91927c4d72dae6c9dc0fb7e878a", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x9716Ff369914c68DD10B7eFE567Ff0b212d6d90a": { + "index": 105, + "amount": "0x01", + "proof": [ + "0x3afd1d39fd26eb77c28e99bd0327c389859efc00951ff4239365680b34c02508", + "0x24927ba509ef8c181f0bad9f16ea987631090499e83b0901f5574acbb040e4aa", + "0xa9e692419cb4f94f85f7a3cc302df5c748e87c56568a4cb3a6f25ed770c307ee", + "0x9f2ec78bac177b82e65626eb3f7b76e2644d8a7282cc3be0840fb0ecd772d993", + "0x3784903b025be81b83e9bb4752292191cf517ec429d6662e8b71177a2d5d4ce4", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x9Ac617398E2994545162EAF5Ea5a54434168A3A6": { + "index": 106, + "amount": "0x02", + "proof": [ + "0x9af842af21207b5683efbc0a1727bb73555ed9c787cbc87edeaf469598f97e7b", + "0x8b630480ebe5c43b41a3b271bb8fb0a2a6d97e66183030521310a17eb37fa7a5", + "0x0dac557adc392ee670c09ce5feb56a9eb0694456c9b8679f870d2c6fcd1cd495", + "0xe1fb9cfbf2109f088b0cc3e464d6a88d8ce475c0df0baeaa065f9bf5438fcf28", + "0x28acf9aeee9dbbfe59ed9a35b834f1bb8f030da25f10829a720689183c091e8e", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x9Ca2C56C0F876108A5ec1C518Baad5b86E651FB3": { + "index": 107, + "amount": "0x01", + "proof": [ + "0xaf8ff5cd7bd6a26f93528cb043c0ac3e5e200fc4ace9c0102c15ba1b7e68993d", + "0x125fe10b9c4b3a5c1b71d3a3c0bd3841802b2f8620337cc64e16c638b492226d", + "0x3012485b6b7f5ab71c4b1ca94bd1af248e606331cde37d005ff3bf07f6430c78", + "0x027dd52a5591276c58d2b79d691dd8cbbc85f5645392a665f5955e389f86c024", + "0x1ae23534fd2ec3b68f5762f60ee913ca81f956ea9ddeee68a6f8f4427a5a56d5", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x9E817382A12D2b1D15246c4d383bEB8171BCdfA9": { + "index": 108, + "amount": "0x01", + "proof": [ + "0xfd16d7319a3d754888b1d58d8af304b1126918ed18d48ae25dcc3a139f489f87", + "0x0a249872a1f7ab42ea1b908b0200991e32df99685f3ed168a4c3ee35126992a9", + "0xfe622aef6c55ecad704e4012913430d112a6749301f3bcfcc64dedfdadbcb658", + "0xb867795c31665082bd4b62531e021fd6824408948736b0ddb1c8b57e1c294a11", + "0xa28387a156c9f4954d9607a9ac4f19c1c5d457a48cda78448a477aeb395467b2", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x9d7e4bEF5533DfE2BB30c77eA7C06465F9e46DeE": { + "index": 109, + "amount": "0x01", + "proof": [ + "0x58eb17699de7f24f211eb4a2bd37ac22153684ef715a6127941dcbc1286f5e01", + "0x6a13476836cb8af3e238a715f2ba2f1617d7e45af54ae4541f4e02d8ed2c1677", + "0x4166276af4821b7e02ad4e901ba1c008614f51459cd39c81ccbf08a195fadac1", + "0x2ef2c623cd26819e676f6295abaad8ef34c204b71b3ae644be0cefa86e3150b6", + "0x8a2a892a2a632adf2f1f7df50cfe964e48bf81690e7a3c82aa6be34a79635896", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x9dC9D9D428Cd616a292A913ceb31557b6F2882C7": { + "index": 110, + "amount": "0x01", + "proof": [ + "0x0e3c1a00650ba9610bd54aef375a4923d41d268df622faab100d0cc0dfba8c49", + "0x50ec89f4fb48e8f6c5bddad6acfb77324cad483cee274590dd8b76ced5491634", + "0x3a5db6056b8109ccd710bcec9b1f94d65fda06943c72c7a79ad08305276b8e63", + "0xb64575b2e5c17b269a7b54aad00cb5ae485e6d3cd97f9b696f2c348980c80376", + "0xcbc27f89cff792994dade0a33179d3255f98b752d247709d3ac3afbb50e6678b", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x9e6f4c45f869C77e7bc9e28676f22577B64Ac082": { + "index": 111, + "amount": "0x01", + "proof": [ + "0xe8b22325966494520da86f4626993eb1637eb9174d2fe8c42f363f3afa4bdb09", + "0x513cf550b0565a71891b008d28be44efbb7db973f422ee977ee84f722a2bda14", + "0x771cb4e120fb08a7b89c5df1e50c7a6545a0ec794149afd5b45339f31bdaead3", + "0x6bc340367ac6009abe512f43268c0c5efb547c716b06709e20656240cee5d67a", + "0x71d69f595b35fee0a6d4187afc71b6bbff74c91927c4d72dae6c9dc0fb7e878a", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0x9ee73ec148b8f68DA65598Ebb497F1E7E9957219": { + "index": 112, + "amount": "0x01", + "proof": [ + "0x63bbf51e3ae01e55405da19e4634d6f1b77f82728704a29d2ff9467b06f16aa0", + "0xca3754d1632b888ffaa945bc1f94575f579553560e09e716c7c0e136942e98a7", + "0xf3e7b2856b67ca0006e0458e20a848e0ac893cc6c1b59039b13d9aaaf09cc4f5", + "0xb46aef78df30b13738edb3464ba4c37561bf949ea83771c3a8ffec47c242fca4", + "0x8a2a892a2a632adf2f1f7df50cfe964e48bf81690e7a3c82aa6be34a79635896", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0x9eeEAa6b00E69be68F32a5a78F2CC8A872A0df57": { + "index": 113, + "amount": "0x01", + "proof": [ + "0x90443b72a7bd8cb1f135b918bf5b683d458076804a425cd4d52c22849d065214", + "0xe5d0d4de7efa65716c21f804bba4439f3c7f5afcd866b647c59f15bac2c8b574", + "0xf8c29056ebcfe5fae8fd66c73dc80d748471d6e92447b781ee16e15ed7060308", + "0xa9c14b7bde5f6bd300bce856d17e01e920e75da313902e045b4b3e048962526c", + "0xb654a1a566453851ec2f35198e6992bb9af61b4c4bbb9383d0605d3898fe90ee", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xA2C12dBe82f19eF06850d4693F2b2D5724b8eA3E": { + "index": 114, + "amount": "0x02", + "proof": [ + "0x8ca3043dc36b0d00533ba57a816eb66621f9ee91bcfbcefcc0f46ce76ab7fa62", + "0x6807c4aba58a9562cc0e0c540155bd191c15820b8799d52a9c6830694ca47657", + "0xc644c2e247edac46242eaedb98649150e3e4ed6e2a71819c401c47cdb8b7cd51", + "0xa9c14b7bde5f6bd300bce856d17e01e920e75da313902e045b4b3e048962526c", + "0xb654a1a566453851ec2f35198e6992bb9af61b4c4bbb9383d0605d3898fe90ee", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xA33C4eF33635a42F7C80FbCEE114a048c7a1ccE2": { + "index": 115, + "amount": "0x01", + "proof": [ + "0x64bfdb66985e1191b7674863879c8dae44e72dd0d783063f257646d33f4e746a", + "0xca3754d1632b888ffaa945bc1f94575f579553560e09e716c7c0e136942e98a7", + "0xf3e7b2856b67ca0006e0458e20a848e0ac893cc6c1b59039b13d9aaaf09cc4f5", + "0xb46aef78df30b13738edb3464ba4c37561bf949ea83771c3a8ffec47c242fca4", + "0x8a2a892a2a632adf2f1f7df50cfe964e48bf81690e7a3c82aa6be34a79635896", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xA48fC0B3bc7954C6A05B81BF5BDe133fd0ea2c50": { + "index": 116, + "amount": "0x01", + "proof": [ + "0x006fa918542b01ae7172c9dc3fc88ccea5a1d42d78e65d300124da287e550c57", + "0x3abb0375540db37e6a6400bfe1e5e8fbb4be8359e61e3338e34372f943be651c", + "0x6044382fce0c9807f54e963af1749be8460153aa0c5865106eb4ee747208d0b9", + "0xc9483a8ee2897792a07d445fd7e441987e2e09db3bd94d45a4f7b5a4164ac998", + "0xcbc27f89cff792994dade0a33179d3255f98b752d247709d3ac3afbb50e6678b", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xA4Ab16a28A8567bB7e51D536f151F8bAc1D3b464": { + "index": 117, + "amount": "0x01", + "proof": [ + "0x6a3de23c80d464a7bd5afab21140ce3875bc3ed3f522df0b1185f0fd89cf9227", + "0x62c2f8cd12c3d4bb3ea13169462ac39c59c887692229e5635fe490347ca9cc5f", + "0x656d4eb2cf8aeda1c313a6e5cf200c987172917d24ebde8f8cef67b1854f43ba", + "0xb46aef78df30b13738edb3464ba4c37561bf949ea83771c3a8ffec47c242fca4", + "0x8a2a892a2a632adf2f1f7df50cfe964e48bf81690e7a3c82aa6be34a79635896", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xA538311df7DC52bBE861F6e3EfDD749730503Cae": { + "index": 118, + "amount": "0x01", + "proof": [ + "0x67ec0c7d0b2db7ae75083c5c417592ade37b46fd19e6e2c4813836603f00ca6f", + "0x59a8c420db51cb57a961c3bc018e5df7c035f192981b8c3f38da17f1fc3c8f96", + "0x656d4eb2cf8aeda1c313a6e5cf200c987172917d24ebde8f8cef67b1854f43ba", + "0xb46aef78df30b13738edb3464ba4c37561bf949ea83771c3a8ffec47c242fca4", + "0x8a2a892a2a632adf2f1f7df50cfe964e48bf81690e7a3c82aa6be34a79635896", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xA639583dbeE6f945c57492c63D8aEac64bD168d2": { + "index": 119, + "amount": "0x01", + "proof": [ + "0x2adb9f3e9aa8a6aab0437afd668035b0c424b7b208c46e1fb861efc780e1eba4", + "0x9e6a31622515048cae116f0b54119c44469dc853028ab0b19a16dd9646fe02e0", + "0x5208575fb8340b178b6659fb29b2fbfb299ef7a72affc3bc356f4a9364de55e8", + "0xda4b6bc089b72bc047b6c6fed7fe7fcd52dd68b9d13d6be60c86383ca2ace879", + "0x3784903b025be81b83e9bb4752292191cf517ec429d6662e8b71177a2d5d4ce4", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xA94b40c53432f0576E64873CE1CEAd1aae62Fc90": { + "index": 120, + "amount": "0x01", + "proof": [ + "0x8bc89276eae0c2588d1202dd557481f96ff48d8e2604380f3835987325cc9b43", + "0x6807c4aba58a9562cc0e0c540155bd191c15820b8799d52a9c6830694ca47657", + "0xc644c2e247edac46242eaedb98649150e3e4ed6e2a71819c401c47cdb8b7cd51", + "0xa9c14b7bde5f6bd300bce856d17e01e920e75da313902e045b4b3e048962526c", + "0xb654a1a566453851ec2f35198e6992bb9af61b4c4bbb9383d0605d3898fe90ee", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5": { + "index": 121, + "amount": "0x0a", + "proof": [ + "0x7d7bc4cb798a0811b07c074d34b3f45e8e0b60d3e135189a9357b2a3b0a0f0ec", + "0xd99ecdee3eb555438db6d25ef37392bead4a46bf9f267c67c4d6f2e9526e06cc", + "0x0a5c96ccce526b37acbd9cbea1f54a3b0d7d9355bc5b2e73685641ddd1691dbe", + "0x7bd2d29f4e05262244eb00af397a27132489abd476657497c2091a5e09fd028d", + "0x6bb1e68faf6241a81d5f80cdce73750e9979840cd454e701f5027975e0839c13", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xB31a371ED6b52E1871ae6EB6ffb99b8B4FA04CED": { + "index": 122, + "amount": "0x01", + "proof": [ + "0x86777c2f17a3e698b7c379e4c39d90c45d31c4af8dcf468915993fa8e4edf3d2", + "0x5fe4716e92c56f5942e159b46246eaffd3b40df78196d03fcb4f184ca45bdd36", + "0x00c785fb523e770b855f5a8f4bcff502dc4ae56e5dcb87030ea7135262441e9a", + "0x0d0da98bee418d7d5447b0b9f149280d02d3119d074c67428254b1b6e48d4725", + "0xb654a1a566453851ec2f35198e6992bb9af61b4c4bbb9383d0605d3898fe90ee", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xB6605F98A5562b1AC821Bc5f2B75934239e8c6D6": { + "index": 123, + "amount": "0x02", + "proof": [ + "0x03bba36c285ede830c4df156a9d9c27031edc96c2d38f8ee640a38d106bb8cae", + "0x46fcb09374e0cd462e5e1f3b4e7ccdb7e6a3783ffb54b9ff10eb7931da9ae58f", + "0x4a54ff6bd65fd2eb3e648c37e076c1749a0d5447a8652ffc13ceb567def05fa2", + "0xc9483a8ee2897792a07d445fd7e441987e2e09db3bd94d45a4f7b5a4164ac998", + "0xcbc27f89cff792994dade0a33179d3255f98b752d247709d3ac3afbb50e6678b", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xBEc186F8d739a6CB1A76e48f2aD2aa19d5269A58": { + "index": 124, + "amount": "0x02", + "proof": [ + "0xff0bf540c294c529bf016f96e9a9bd8b8df3343331b8b9ad6bc8c16cad791345", + "0xff52f9472ecedb1cc3a1bb8ecff44721cd61f43fe5513fe5f81ec20d234a0b94", + "0xc95d835c748b5e7954cb0dd70b1a1bdfb56c1a4371423d44af65f6501868acdc", + "0xa28387a156c9f4954d9607a9ac4f19c1c5d457a48cda78448a477aeb395467b2", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xBbEEF5C4BD232010e68EE5191B6Bc241608B24e2": { + "index": 125, + "amount": "0x01", + "proof": [ + "0xd0ba80c1d231aad9160c63df2ebb6683170034e239ea421b4811d069ff994570", + "0xd1e0f88633251f7ae2df245025c0b5fa5121b2a83ce560dcd97e9f9064836ee4", + "0x9ff6d0995e7919e1977592bf9d9394aaba2c03cdfdc48dd0aee32d4431d791c8", + "0x5d0c037ff149aa61e68483d2aa89514545be2eba507b61f72e04da089b5134d1", + "0xce3c2cae572bf1ea81613ef7fc064010151dbd5264896982059a3d31ab366fcd", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xBeF0c7e90b367B672E8Ad633c3C21ab8B9998A14": { + "index": 126, + "amount": "0x01", + "proof": [ + "0xaa170090122e24c07be7cfb28f2b11fb688e6ce41c37715c95e22da94ca4e62c", + "0x970898f2e8126f4bd4c94b4c2f99b357013adaab0655a8e4e1ec4ad3428b36f6", + "0xb6757d5e45ae60417249acc37e28f4a986e39deb356ba67a14b501fce218e39a", + "0x027dd52a5591276c58d2b79d691dd8cbbc85f5645392a665f5955e389f86c024", + "0x1ae23534fd2ec3b68f5762f60ee913ca81f956ea9ddeee68a6f8f4427a5a56d5", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xC0D7050BA38319Affdac5ca22c4aafB5a36a98c9": { + "index": 127, + "amount": "0x01", + "proof": [ + "0xa4d3541ee59ef667bd84fe8c1425d5f42950c8497ea764b1673e9243ca5a8964", + "0x102bc83486c94932ccbfb42148d131123dfd8ab9c8ccf54032062f9fbc70d7f7", + "0x7d90615908c5080e692d6d0dd760c920eaf9db7fa051a3e8b1135ce96cc6229c", + "0x930fec2c2d175134b5a08f2432bf7e01104646b61dee15c531d62ad698c4b460", + "0x28acf9aeee9dbbfe59ed9a35b834f1bb8f030da25f10829a720689183c091e8e", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xC363Fea8f6ac0b4D5a071291105fE9b41194964B": { + "index": 128, + "amount": "0x01", + "proof": [ + "0x28d0a78189e88e4f04322ff5539cd50bd5fbe09bd9d4408ff07fa4fa68529fd8", + "0x299704d80d2fd5f865c735b846306b3dc262a611f63660fbaaf12b52df9d86c1", + "0xe11251280abfd46378ca9ca336e9954dad085a38edcbca705ec534447a68e2e4", + "0xda4b6bc089b72bc047b6c6fed7fe7fcd52dd68b9d13d6be60c86383ca2ace879", + "0x3784903b025be81b83e9bb4752292191cf517ec429d6662e8b71177a2d5d4ce4", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xC4b0F00660592819Ed9a38b6AFfE76E15d0CE502": { + "index": 129, + "amount": "0x01", + "proof": [ + "0x77d116a5d672e7aa062030d8826afb6273933f166dc4dc9dfce0f12291f7229c", + "0xb06d99a5451a1b99d26d737f7623e88fa28b99bf9fe38704e553c08ad7107916", + "0x22f1713f0f81d5e118ec7f5262909f3724ffc3ef647f9a34eaf8382a5b416f7f", + "0x472ad2456c55e2e0144a5164c7ba8b34a827db0c91aedbce9484da200426d438", + "0x6bb1e68faf6241a81d5f80cdce73750e9979840cd454e701f5027975e0839c13", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xC561C9b7035732B4EbDbAe6aC43D6a293aB53896": { + "index": 130, + "amount": "0x01", + "proof": [ + "0xcd3dd1879b98b350bdf3accffac5f86b9c56627a49b2e63fa65a46b50b4ba802", + "0x8a217160a442ea7ffc85af035cd4d65f31c4705c1a3fffa75e802a5e7f546273", + "0x458ab07c152871be5712096c4d82f8b3d3ac751c1a69e1efc1461cee12f752c9", + "0xd9184a25eeb4f87cd2425cac26ac77cf668feab72ea6bbd3b110892fbe584508", + "0xce3c2cae572bf1ea81613ef7fc064010151dbd5264896982059a3d31ab366fcd", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xC6D4E5C1cd5c2142C4592bBf66766e0f5f588d84": { + "index": 131, + "amount": "0x04", + "proof": [ + "0x00dfc969ed133f281327f7e4e0f1cdd2406459c3861208c2e78db39daf55938d", + "0x3abb0375540db37e6a6400bfe1e5e8fbb4be8359e61e3338e34372f943be651c", + "0x6044382fce0c9807f54e963af1749be8460153aa0c5865106eb4ee747208d0b9", + "0xc9483a8ee2897792a07d445fd7e441987e2e09db3bd94d45a4f7b5a4164ac998", + "0xcbc27f89cff792994dade0a33179d3255f98b752d247709d3ac3afbb50e6678b", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xC9848f9146a56b6B5676B06f454a62A06A66Cc03": { + "index": 132, + "amount": "0x01", + "proof": [ + "0x36b75e9d564706cbd98e3967c7c34a13678854c9cd4f38407d2717c37ba64af0", + "0x73341791079c8e2dd48e5072af2227208b90266cf3c8879d9622dbdf90466b38", + "0xc37ca5973cbc7282c5a31def4e2c8dea04369ac2e59b9bc0fe3b8fd28c9e5872", + "0x9f2ec78bac177b82e65626eb3f7b76e2644d8a7282cc3be0840fb0ecd772d993", + "0x3784903b025be81b83e9bb4752292191cf517ec429d6662e8b71177a2d5d4ce4", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xCA7A055c438cb30f748FB571418b4653eD50ed5f": { + "index": 133, + "amount": "0x01", + "proof": [ + "0x0a44885edacb9f42b2476e031b6ef2494df71636a1321b3c99ae2c6d3f766094", + "0x057ce8fac654ea1d9faee1b816e5dbae926b084690c3fee298f2c9ddfa250756", + "0x4a54ff6bd65fd2eb3e648c37e076c1749a0d5447a8652ffc13ceb567def05fa2", + "0xc9483a8ee2897792a07d445fd7e441987e2e09db3bd94d45a4f7b5a4164ac998", + "0xcbc27f89cff792994dade0a33179d3255f98b752d247709d3ac3afbb50e6678b", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xCC8bD74382cd27c8fa9EA2B4281592Cdb2042cB0": { + "index": 134, + "amount": "0x01", + "proof": [ + "0x3dde85bcd6b93e035f63dde1babbf6c5320e6d7934bde61ddfe3c1149785e375", + "0xfc543c4698375a26135e828192ea0bee900dba8bf3a05e5be1006f20cca48884", + "0x70c1e14739c966ef5e24983ec018e0476325243ef26be486620edc26445e05fb", + "0xda7f239c88a5b772a2ff14bce5086ce21c104bb4ede8fb05b792ecd4ca562d5b", + "0x86373cbc149bf07a85d55b4c3cb8102ed404b3acd5444c368631ed78c89511e5", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xCaA16004955F05599C7cF215aA271a4F3544D6d2": { + "index": 135, + "amount": "0x01", + "proof": [ + "0x2b1c4e4291a00c5666f45ce440e73c552005127a6cc4b6427f8635f52c4942c2", + "0x955756148e703ef9a8c9c71ca5418819127cae616dfd3d383d78feb109a662a8", + "0x5208575fb8340b178b6659fb29b2fbfb299ef7a72affc3bc356f4a9364de55e8", + "0xda4b6bc089b72bc047b6c6fed7fe7fcd52dd68b9d13d6be60c86383ca2ace879", + "0x3784903b025be81b83e9bb4752292191cf517ec429d6662e8b71177a2d5d4ce4", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xCd0D4CDb238Eec15Fcf4ff9d13d5a59051E507D7": { + "index": 136, + "amount": "0x01", + "proof": [ + "0x6357e458414713997734a01fe16ece3a16a2ba31b05998533924b52bf956d36a", + "0xc18c21692f3c869fcc64847b2fd873721527da6c40789f78d16f7f6046a7cc06", + "0xf3e7b2856b67ca0006e0458e20a848e0ac893cc6c1b59039b13d9aaaf09cc4f5", + "0xb46aef78df30b13738edb3464ba4c37561bf949ea83771c3a8ffec47c242fca4", + "0x8a2a892a2a632adf2f1f7df50cfe964e48bf81690e7a3c82aa6be34a79635896", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xCf50fB42926b255747fb8b0EA8E26D4e66952CA4": { + "index": 137, + "amount": "0x01", + "proof": [ + "0xd40629f98c0acc96f4b6dfda3c0153e29ebedfd580d48bc17f9c891c5c8e497c", + "0x73fb28028e5b620bdd6f7a00d9313680dab685f59b6b054f685857f2b17adcf2", + "0x9ff6d0995e7919e1977592bf9d9394aaba2c03cdfdc48dd0aee32d4431d791c8", + "0x5d0c037ff149aa61e68483d2aa89514545be2eba507b61f72e04da089b5134d1", + "0xce3c2cae572bf1ea81613ef7fc064010151dbd5264896982059a3d31ab366fcd", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xD3B608Dd6f10a84f5E4A1cEaB98dE44E61e1F095": { + "index": 138, + "amount": "0x01", + "proof": [ + "0xcb4c17a5ac80f7b05b8b3955c60e41b78276615ac92fbbfd23a668e0a1b0f4cb", + "0xcad84d256c4f73644a31128d98720f66c3adea2829d78cfb4a09c9fa1daa0b34", + "0xf5abed670baf0190a0a91df408d65698c3209dcf17a843f9e5fcda9bd8959a17", + "0xd9184a25eeb4f87cd2425cac26ac77cf668feab72ea6bbd3b110892fbe584508", + "0xce3c2cae572bf1ea81613ef7fc064010151dbd5264896982059a3d31ab366fcd", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xD5257a3909f522CE44f1aeE6Ecf52b5F99422581": { + "index": 139, + "amount": "0x01", + "proof": [ + "0x521b168c998d820babab060ea245531782bff799e2f981b659f8e90571d56078", + "0x0979cc5e2b0c9b56d942ff7b0a174a1ef7eaacd8322da85d957f04c8c2555cdb", + "0x89161607a370d2cf202a6b57a566ff2e4ff40dd0763aade2c7537263295ceaf7", + "0x62ca54c10d0d2e8f11b95ce1e622c1071c735ba393fa4d8574607daf6a853ebe", + "0x86373cbc149bf07a85d55b4c3cb8102ed404b3acd5444c368631ed78c89511e5", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xD75D580bE38DbDAF64Bd9a725e80A7e154612F62": { + "index": 140, + "amount": "0x01", + "proof": [ + "0xf5fef77a12dbac7fa9b857e947992bf11eaabf92d77806b25c5d85c33317ee0f", + "0x7206935654146e5f5e9b89564a312533c59782c2608ea7ebc4f1da74cd9df3d6", + "0xb5e32c61e30be19fa7f3bfd310e5b8b415935a0884b889f3193bb3f4045e29e8", + "0xed856c374c426cdff99c626612739a1e89c2035df4f6a7667e3ad58492f8df83", + "0x71d69f595b35fee0a6d4187afc71b6bbff74c91927c4d72dae6c9dc0fb7e878a", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xD9cfab54f1234AeEA22B2818AB919866A2809c1C": { + "index": 141, + "amount": "0x01", + "proof": [ + "0x173e2f8228293f9b6aa4d9129a0bbf9347581c1fd451b003ebfcdd20ece506cd", + "0xb74c9a792fcab35438fe260004d5090df457a5a35801482db3e471de88eb42ab", + "0x465e6bafbf8b6f363352a3e3a36f9e265db0c2b866ce9068dcc12adf9107ad37", + "0xb21ede7787a0a8b0437145982a83b864f2e47c687aded37139d31a4560feeaef", + "0x08516e24629ac2a05afad7d0082e47b87252429c85dba8347bb8d99ebd15917c", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xDE5c502617E96804B7ff0E590F0eb17CDf92566E": { + "index": 142, + "amount": "0x01", + "proof": [ + "0xb2476e4d5b0400dbe3a963e650b1946edd84bb19378f2075f1338c635054d414", + "0xb801af4c7b852721c9b9b5cbff315db52b300d05ea26cf3f10e2655c4dc924df", + "0xdc4e7219a44becb0ffe5cf27abd1dd6df2675bc95eefe6c0595876d9ed1a63d7", + "0x7be11c45c5666355fb967ece1269c0e78498643ab2b2435f7cddf99ab8b39422", + "0x1ae23534fd2ec3b68f5762f60ee913ca81f956ea9ddeee68a6f8f4427a5a56d5", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xE01f94F635028394cB15B572179DaEbbfC231761": { + "index": 143, + "amount": "0x01", + "proof": [ + "0x2472af6eee80f415e4a8c619dec9ebf2399ccb94515417af7ab2669b4a1dd93d", + "0x0526765e3e5369d7de5bb7ef6d825685af0116b2262ea4d31a26e72a914102a2", + "0xc30db538fdb7f80bae447b2d5300490287ab684bcf7e321bd1d145820c04a981", + "0x3e7f8382a906db03cc3d1a09d794b375222411632d321f6070b091c1a5d92686", + "0x08516e24629ac2a05afad7d0082e47b87252429c85dba8347bb8d99ebd15917c", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xE65cEE7B4C759bC1857414557b232884e7412EBE": { + "index": 144, + "amount": "0x01", + "proof": [ + "0xd7cdd59aad19f0a42dd286cd0f25b14b171dc8d9a3eac4b6c9d80d0dea556a35", + "0x3d4acc8a549c34be118beb6cc07ef1f16f1c76233c9cf81cdab19540c7edb240", + "0x99f0091db6a51b03d8a461655ef7e68150a2349be1edcb0dab9de795bdd645d9", + "0x5d0c037ff149aa61e68483d2aa89514545be2eba507b61f72e04da089b5134d1", + "0xce3c2cae572bf1ea81613ef7fc064010151dbd5264896982059a3d31ab366fcd", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xE8203154A959093dab480ec777f81e318dCf6896": { + "index": 145, + "amount": "0x01", + "proof": [ + "0xaf2d22c6d9cfe7d2c4c018d56ae5e8b4201d3acfb76116b2309bbb2a06fa35e8", + "0x125fe10b9c4b3a5c1b71d3a3c0bd3841802b2f8620337cc64e16c638b492226d", + "0x3012485b6b7f5ab71c4b1ca94bd1af248e606331cde37d005ff3bf07f6430c78", + "0x027dd52a5591276c58d2b79d691dd8cbbc85f5645392a665f5955e389f86c024", + "0x1ae23534fd2ec3b68f5762f60ee913ca81f956ea9ddeee68a6f8f4427a5a56d5", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xE849C585Fb1711aCa53d880f99Fa0B2c77452078": { + "index": 146, + "amount": "0x01", + "proof": [ + "0x9cd7fd64fb468bc0991ba5023b9ec35454dfb1665886fa55ae39dfb63cda2952", + "0x89344024be30fece69aa991bfe664f8db5a5bfeba1946d9202eae9cecfc026ab", + "0x086ebe30a2720a483fda3431b8859546cf2996b8f18a02045112e469db21cd79", + "0x930fec2c2d175134b5a08f2432bf7e01104646b61dee15c531d62ad698c4b460", + "0x28acf9aeee9dbbfe59ed9a35b834f1bb8f030da25f10829a720689183c091e8e", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xEcB50F1F8098F3D62FB5d8A1fE0fe8b5def621Fa": { + "index": 147, + "amount": "0x01", + "proof": [ + "0x84522b38dc2dae774b53ddfee26ec2f67aa3ba85ac67621d48cd8528d4f85b58", + "0x7847da268ee00e693c9e65a2b0e737dc25e278597e9f5d749bdb7ddf58b45bdc", + "0x5c107555f7f57cb8c8f52941d77a7ee7824e0ce08328394ebd3660ecb496a75b", + "0x0d0da98bee418d7d5447b0b9f149280d02d3119d074c67428254b1b6e48d4725", + "0xb654a1a566453851ec2f35198e6992bb9af61b4c4bbb9383d0605d3898fe90ee", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xF2855eF7c734eC1F965915dAAfE668450e4b8212": { + "index": 148, + "amount": "0x01", + "proof": [ + "0x57dbab4d41784f991a4a04315f09aca79c5e7337ee12c36b97ed9a11be66c832", + "0x0979cc5e2b0c9b56d942ff7b0a174a1ef7eaacd8322da85d957f04c8c2555cdb", + "0x89161607a370d2cf202a6b57a566ff2e4ff40dd0763aade2c7537263295ceaf7", + "0x62ca54c10d0d2e8f11b95ce1e622c1071c735ba393fa4d8574607daf6a853ebe", + "0x86373cbc149bf07a85d55b4c3cb8102ed404b3acd5444c368631ed78c89511e5", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xF7B18e107eb36797f4cE36dE756630B9C30969ad": { + "index": 149, + "amount": "0x01", + "proof": [ + "0x98bd3bb899bd3ba2a1eb4be24b18fd10ffe42b3eae82b85ef3456fd8d41363db", + "0x8b630480ebe5c43b41a3b271bb8fb0a2a6d97e66183030521310a17eb37fa7a5", + "0x0dac557adc392ee670c09ce5feb56a9eb0694456c9b8679f870d2c6fcd1cd495", + "0xe1fb9cfbf2109f088b0cc3e464d6a88d8ce475c0df0baeaa065f9bf5438fcf28", + "0x28acf9aeee9dbbfe59ed9a35b834f1bb8f030da25f10829a720689183c091e8e", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xF9Be5602775B96457d6Aed434a31D7E6c6a482Ec": { + "index": 150, + "amount": "0x01", + "proof": [ + "0xf3ec46f1006f400c6b9c55310f24d42f3c5fa90081dc46ee7e7fbdf6224812ee", + "0x82419df43050157ccd6e78dab17d6d749c5d9e1af305c7a37f3b94c61372538d", + "0x58bf589fe305ed7bb05181f5e2bdaa02f4e5bf894ede44f1b05c8404228bb127", + "0xed856c374c426cdff99c626612739a1e89c2035df4f6a7667e3ad58492f8df83", + "0x71d69f595b35fee0a6d4187afc71b6bbff74c91927c4d72dae6c9dc0fb7e878a", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xFFD2DF7Ba9A04672933748dc86ce71F131ff4D50": { + "index": 151, + "amount": "0x0b", + "proof": [ + "0x9735cc79bba924b8c55c2edac4e67b1cd6ba5b123f6ab15855889f3bcb60df30", + "0xe728fb845486d910b23ac90d44abe86b99c7c12d27248cc6b7152b4bac045431", + "0xb4fec3235be97a74c6d3a1ddbb5e2ca83b6851ee0a5698d087e4d674ef1523eb", + "0xe1fb9cfbf2109f088b0cc3e464d6a88d8ce475c0df0baeaa065f9bf5438fcf28", + "0x28acf9aeee9dbbfe59ed9a35b834f1bb8f030da25f10829a720689183c091e8e", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xFc6Bc96f0715596C61f2e6165F726B0D2f5a3C05": { + "index": 152, + "amount": "0x01", + "proof": [ + "0x76dd623399a392053bb4966f96fe6a36003de9a0f64ae76310046c49f3765f4d", + "0x9dc55551e92c200f6bbccb7b03c4364349523ee3f0236313a52fd1b2f1b4237c", + "0x22f1713f0f81d5e118ec7f5262909f3724ffc3ef647f9a34eaf8382a5b416f7f", + "0x472ad2456c55e2e0144a5164c7ba8b34a827db0c91aedbce9484da200426d438", + "0x6bb1e68faf6241a81d5f80cdce73750e9979840cd454e701f5027975e0839c13", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xa66B7E13467084f248E7d731eb2f9FF8E43dB1CF": { + "index": 153, + "amount": "0x01", + "proof": [ + "0xa4b0107e5dc6122d6d628ad8352336f83a1bea0814e54894008f74aaf13e22d2", + "0x102bc83486c94932ccbfb42148d131123dfd8ab9c8ccf54032062f9fbc70d7f7", + "0x7d90615908c5080e692d6d0dd760c920eaf9db7fa051a3e8b1135ce96cc6229c", + "0x930fec2c2d175134b5a08f2432bf7e01104646b61dee15c531d62ad698c4b460", + "0x28acf9aeee9dbbfe59ed9a35b834f1bb8f030da25f10829a720689183c091e8e", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xa76A8E68CF6284543D19DA9C12f446ab860cC831": { + "index": 154, + "amount": "0x01", + "proof": [ + "0x4daf27cea4774fbe497cac48ffa7e53498c282649ae0e8323f2d2ebe106c4b3e", + "0xebb27e77cb9bc98f82c42074368f6a251478e2684d0f0b5b08bbaca6b7d03c48", + "0xee0321a702d99edfdf36d62367c275274518018d5f5d106fce98072476620f9c", + "0x62ca54c10d0d2e8f11b95ce1e622c1071c735ba393fa4d8574607daf6a853ebe", + "0x86373cbc149bf07a85d55b4c3cb8102ed404b3acd5444c368631ed78c89511e5", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xa83c572C8072f3b11562F08B89d4F3077682acDB": { + "index": 155, + "amount": "0x01", + "proof": [ + "0x947534e25ab97a383497dbac20481ee76b19ad9464f0c4e3d9140d9fe2974f3d", + "0xe728fb845486d910b23ac90d44abe86b99c7c12d27248cc6b7152b4bac045431", + "0xb4fec3235be97a74c6d3a1ddbb5e2ca83b6851ee0a5698d087e4d674ef1523eb", + "0xe1fb9cfbf2109f088b0cc3e464d6a88d8ce475c0df0baeaa065f9bf5438fcf28", + "0x28acf9aeee9dbbfe59ed9a35b834f1bb8f030da25f10829a720689183c091e8e", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xaCe9BEFE277dC3D22423855f040b34C427a2e1CA": { + "index": 156, + "amount": "0x01", + "proof": [ + "0x5de64e431d7d553a18615bab790ea58fde76283b3ecf7a0fbbda0fe15caa60d5", + "0x246772b7d1010891a99b75e6d019e70cb5cc286162551f2292546369c6c99616", + "0xf92aa902ffa739c5a1075086d0bbb171c03745ac9446538e400f447857437193", + "0x2ef2c623cd26819e676f6295abaad8ef34c204b71b3ae644be0cefa86e3150b6", + "0x8a2a892a2a632adf2f1f7df50cfe964e48bf81690e7a3c82aa6be34a79635896", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xaDbb744a9434AAd006772CF76e79D246c4506D1B": { + "index": 157, + "amount": "0x01", + "proof": [ + "0x2928e4df75ed583d807260904e4e83f9ba1a2628a5340cd9577df58ad615c357", + "0x9e6a31622515048cae116f0b54119c44469dc853028ab0b19a16dd9646fe02e0", + "0x5208575fb8340b178b6659fb29b2fbfb299ef7a72affc3bc356f4a9364de55e8", + "0xda4b6bc089b72bc047b6c6fed7fe7fcd52dd68b9d13d6be60c86383ca2ace879", + "0x3784903b025be81b83e9bb4752292191cf517ec429d6662e8b71177a2d5d4ce4", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xb115a77344F46ACF8bD8B56b163913E84F13820C": { + "index": 158, + "amount": "0x01", + "proof": [ + "0xfcc7a844376e82d19bb877da885af33d1ff51f7f13d94075e03459d8eb000f21", + "0xf9540918c21cbf33d4ebfb4b010be4be3516ab4741f3f352adaa6b5e36d1ab05", + "0xfe622aef6c55ecad704e4012913430d112a6749301f3bcfcc64dedfdadbcb658", + "0xb867795c31665082bd4b62531e021fd6824408948736b0ddb1c8b57e1c294a11", + "0xa28387a156c9f4954d9607a9ac4f19c1c5d457a48cda78448a477aeb395467b2", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xb989C3717405569398750983aD5934308759287e": { + "index": 159, + "amount": "0x01", + "proof": [ + "0xb27968bb940e025c198f184b18ee2fb090750fab00b62ba0ff55c9e95434f85e", + "0xb801af4c7b852721c9b9b5cbff315db52b300d05ea26cf3f10e2655c4dc924df", + "0xdc4e7219a44becb0ffe5cf27abd1dd6df2675bc95eefe6c0595876d9ed1a63d7", + "0x7be11c45c5666355fb967ece1269c0e78498643ab2b2435f7cddf99ab8b39422", + "0x1ae23534fd2ec3b68f5762f60ee913ca81f956ea9ddeee68a6f8f4427a5a56d5", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xbE3fbEBC1Cc29E99E02237DAC84860E268CAbc9b": { + "index": 160, + "amount": "0x01", + "proof": [ + "0x520026fb03c83cb4dfaeb6cd204b8c2dfe9e3a9bebc2fc7190dbffd62eaa44ad", + "0x99ae07a4d1f66812d6c39a4910260b6bd138ec3b6204393825a3e5f947bb4fad", + "0x89161607a370d2cf202a6b57a566ff2e4ff40dd0763aade2c7537263295ceaf7", + "0x62ca54c10d0d2e8f11b95ce1e622c1071c735ba393fa4d8574607daf6a853ebe", + "0x86373cbc149bf07a85d55b4c3cb8102ed404b3acd5444c368631ed78c89511e5", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xbEc7B649FF1b72Ce87acD470da0036A0BEC6453B": { + "index": 161, + "amount": "0x01", + "proof": [ + "0xc292e581b854b9cb9c70ee1c51aab82fcad2699a5a5f89137e2cc1cbf2b036b7", + "0xd6783ce232e3dc7b5bce837e77c83e11da7430d43336f663ea9fecc00290fa6e", + "0xe09f40c84b8e41eeaa1090ec7ac0b8eb2b2c5243c7e81e00d5910e03289e229c", + "0x7be11c45c5666355fb967ece1269c0e78498643ab2b2435f7cddf99ab8b39422", + "0x1ae23534fd2ec3b68f5762f60ee913ca81f956ea9ddeee68a6f8f4427a5a56d5", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xc0607575dF410411A06833AFFc54b424a56b385D": { + "index": 162, + "amount": "0x01", + "proof": [ + "0x855b14048911e386f976d622c9e732268727ccf32a3ffc54e25ffeb24932fbb4", + "0x7847da268ee00e693c9e65a2b0e737dc25e278597e9f5d749bdb7ddf58b45bdc", + "0x5c107555f7f57cb8c8f52941d77a7ee7824e0ce08328394ebd3660ecb496a75b", + "0x0d0da98bee418d7d5447b0b9f149280d02d3119d074c67428254b1b6e48d4725", + "0xb654a1a566453851ec2f35198e6992bb9af61b4c4bbb9383d0605d3898fe90ee", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xc140AAD62f73C19764205815E6B564CF6e9504Bf": { + "index": 163, + "amount": "0x02", + "proof": [ + "0xea58bd7de81b6f6179bc8228ed1114adf0f070f2658aab68d22a02ab311b4bc5", + "0xe47cce1ecc3d20cae763512c936eeb1ed70b9cbd3cc814af99fd950860463567", + "0x58bf589fe305ed7bb05181f5e2bdaa02f4e5bf894ede44f1b05c8404228bb127", + "0xed856c374c426cdff99c626612739a1e89c2035df4f6a7667e3ad58492f8df83", + "0x71d69f595b35fee0a6d4187afc71b6bbff74c91927c4d72dae6c9dc0fb7e878a", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xc2d14C396822bA325Aa8C8D0f6213828Cb69d925": { + "index": 164, + "amount": "0x01", + "proof": [ + "0xf586e375fbc4ff3526d1899807c54cebc10334051c5fb878f2f5d48bfb373af5", + "0x7206935654146e5f5e9b89564a312533c59782c2608ea7ebc4f1da74cd9df3d6", + "0xb5e32c61e30be19fa7f3bfd310e5b8b415935a0884b889f3193bb3f4045e29e8", + "0xed856c374c426cdff99c626612739a1e89c2035df4f6a7667e3ad58492f8df83", + "0x71d69f595b35fee0a6d4187afc71b6bbff74c91927c4d72dae6c9dc0fb7e878a", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xc315155D817140250D238F140142a10b69Fa1c4e": { + "index": 165, + "amount": "0x01", + "proof": [ + "0x363920d3c82edee40a78d35899bd78b80a85cba807886d84a3fb678e110f8ea8", + "0x73341791079c8e2dd48e5072af2227208b90266cf3c8879d9622dbdf90466b38", + "0xc37ca5973cbc7282c5a31def4e2c8dea04369ac2e59b9bc0fe3b8fd28c9e5872", + "0x9f2ec78bac177b82e65626eb3f7b76e2644d8a7282cc3be0840fb0ecd772d993", + "0x3784903b025be81b83e9bb4752292191cf517ec429d6662e8b71177a2d5d4ce4", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xd2Be832911A252302bAc09e30Fc124A405E142DF": { + "index": 166, + "amount": "0x01", + "proof": [ + "0xf8ec624e86d41eb5f1c334b5a3458220551e24a8bcf2b6cf95eba33e296a33a5", + "0xa3f7b2b01e24dea7f5a238004be9f05b65628ace72790a7f77fac6e6090aa2d1", + "0x7f7d059a484fc78b87c1b6419a9f6ada2b19a94a6be65024ee86971d55c384bd", + "0xb867795c31665082bd4b62531e021fd6824408948736b0ddb1c8b57e1c294a11", + "0xa28387a156c9f4954d9607a9ac4f19c1c5d457a48cda78448a477aeb395467b2", + "0x61391c68c2ab1a9d069bd75e2dd8e05648f2d27e004b83b184e8405dab1300a9", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xd2a08007eeeaf1f81eeF54Ba6A8c4Effa1e545C6": { + "index": 167, + "amount": "0x02", + "proof": [ + "0x22f3abea246b6a7a6175b21c669ac4298da129c87eeeb5899efe1d80762bf5c6", + "0x92843fd8056cd69aad0d008d7a0c1eb18fbd3c97121fd2a3a596575677f4e452", + "0xc30db538fdb7f80bae447b2d5300490287ab684bcf7e321bd1d145820c04a981", + "0x3e7f8382a906db03cc3d1a09d794b375222411632d321f6070b091c1a5d92686", + "0x08516e24629ac2a05afad7d0082e47b87252429c85dba8347bb8d99ebd15917c", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xd30391E21741C54c32987bCfcA3D880E6D261Cb0": { + "index": 168, + "amount": "0x01", + "proof": [ + "0xa8aece1a734d8b958fccfe96ce525e6a2476210f9ebcdeb0fa4b7fe606175728", + "0x970898f2e8126f4bd4c94b4c2f99b357013adaab0655a8e4e1ec4ad3428b36f6", + "0xb6757d5e45ae60417249acc37e28f4a986e39deb356ba67a14b501fce218e39a", + "0x027dd52a5591276c58d2b79d691dd8cbbc85f5645392a665f5955e389f86c024", + "0x1ae23534fd2ec3b68f5762f60ee913ca81f956ea9ddeee68a6f8f4427a5a56d5", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xd3F01D352aA3185F45929C20Ca98DD5074be626A": { + "index": 169, + "amount": "0x01", + "proof": [ + "0x00f5a4c2f0e3affb895161d4c25ba9664b5022cd77261e8d69ba3d60e5fa850a", + "0x20f8ad8498f87f2ac7f8542060734ca575e9925b3794a66b35e6d71ccb861766", + "0x6044382fce0c9807f54e963af1749be8460153aa0c5865106eb4ee747208d0b9", + "0xc9483a8ee2897792a07d445fd7e441987e2e09db3bd94d45a4f7b5a4164ac998", + "0xcbc27f89cff792994dade0a33179d3255f98b752d247709d3ac3afbb50e6678b", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xd59e99927018b995ee9Ad6b9003677f1e7393F8A": { + "index": 170, + "amount": "0x0a", + "proof": [ + "0x40d3acbebc009d40787b1a97ee6eff23c04d902b8d572d3fe3f9f614ed10db2f", + "0x36b6c8fb03ca39598517ca8a40f1cbad83a628ede60b7042cd8078040d06f016", + "0x8d04ed65a88640cfc16aeb35d55de80ad6bddbf3f2166a56343c6dd7d9444410", + "0xda7f239c88a5b772a2ff14bce5086ce21c104bb4ede8fb05b792ecd4ca562d5b", + "0x86373cbc149bf07a85d55b4c3cb8102ed404b3acd5444c368631ed78c89511e5", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xd7Ddf70125342f44E65ccbafAe5135F2bB6526bB": { + "index": 171, + "amount": "0x01", + "proof": [ + "0x1f804012cb63ae22ec77d1ae654776deec79bd26c172399ae2e6f8ff4cbec36d", + "0x9f6f1c415c7b7027e9057a2a3e7b5e42e2feb6db00a546b8f90840d4134c6c8f", + "0x23c008de9012b3127a46540f787a48c449965235c9f502b0bbb1719973199e73", + "0x3e7f8382a906db03cc3d1a09d794b375222411632d321f6070b091c1a5d92686", + "0x08516e24629ac2a05afad7d0082e47b87252429c85dba8347bb8d99ebd15917c", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xdCa0133F7902A199ff07b32edE0b7a03907053C2": { + "index": 172, + "amount": "0x02", + "proof": [ + "0x1f3f2c8b816560bd5456b7b1930dc3fd34dceff5df01113870c78852e5182e55", + "0x9f6f1c415c7b7027e9057a2a3e7b5e42e2feb6db00a546b8f90840d4134c6c8f", + "0x23c008de9012b3127a46540f787a48c449965235c9f502b0bbb1719973199e73", + "0x3e7f8382a906db03cc3d1a09d794b375222411632d321f6070b091c1a5d92686", + "0x08516e24629ac2a05afad7d0082e47b87252429c85dba8347bb8d99ebd15917c", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xe55eD2c7734ebB3E7e9Ddaae18B1Ee592a6C8A7B": { + "index": 173, + "amount": "0x01", + "proof": [ + "0x6fdfe01e2396020d57cf1cb8fee23c867e38aa0b305ced6d3b383f5e1625821e", + "0x3017ae48b002c11b242f172900812c00b2aa04df40efea5afefc20691c88f227", + "0x8fa28fe1927369e107a95848594ef796b7bef6240d6b34a6cfff9259c5f1f55e", + "0x472ad2456c55e2e0144a5164c7ba8b34a827db0c91aedbce9484da200426d438", + "0x6bb1e68faf6241a81d5f80cdce73750e9979840cd454e701f5027975e0839c13", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xe587A3dDB0773c292F70d3c75f3A1B72370D9077": { + "index": 174, + "amount": "0x01", + "proof": [ + "0xa682db96938a967dbde297167d3e4e26aef58c41f715e879bf024b35f61ff44d", + "0x23115e32a9a585e9685aef68cf905061ba7785000006cde35f7408a92d17a805", + "0xb6757d5e45ae60417249acc37e28f4a986e39deb356ba67a14b501fce218e39a", + "0x027dd52a5591276c58d2b79d691dd8cbbc85f5645392a665f5955e389f86c024", + "0x1ae23534fd2ec3b68f5762f60ee913ca81f956ea9ddeee68a6f8f4427a5a56d5", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xe9017c8De5040968D9752A18d805cD2A983E558c": { + "index": 175, + "amount": "0x01", + "proof": [ + "0x1170d2bae84cc925888595517f65868b04ea984ab56c0fd06c0779769f582c8e", + "0x86fe57bceb22bff47dbe347de7e52aedc5a8a29805e6f0a77586999983518ee0", + "0x465e6bafbf8b6f363352a3e3a36f9e265db0c2b866ce9068dcc12adf9107ad37", + "0xb21ede7787a0a8b0437145982a83b864f2e47c687aded37139d31a4560feeaef", + "0x08516e24629ac2a05afad7d0082e47b87252429c85dba8347bb8d99ebd15917c", + "0x8523aacbf487d37cfee98d53b5e272a5fb7c28136dc5c03ae98d52cfaa545ce0", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xeCdE04E088828c93a1003b9388727a25C064e5e3": { + "index": 176, + "amount": "0x01", + "proof": [ + "0xbc8aec8dac6c29ee08a1437df9b252dae41b699ab0da4805e3d8c07550ccb81a", + "0xd32a12aa4f2759034ce7b5445123946fd33ab0c7076a5b573c1f1a3f40abd135", + "0xdc4e7219a44becb0ffe5cf27abd1dd6df2675bc95eefe6c0595876d9ed1a63d7", + "0x7be11c45c5666355fb967ece1269c0e78498643ab2b2435f7cddf99ab8b39422", + "0x1ae23534fd2ec3b68f5762f60ee913ca81f956ea9ddeee68a6f8f4427a5a56d5", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xeD2C2CdEc695be3A4Dc421c1A8a6756dc5A927b6": { + "index": 177, + "amount": "0x01", + "proof": [ + "0x7982e54e7f8b475e702de72c0300009ee226daa4acd4207cefcc24042296022d", + "0x21737959a648ed2d2e38c13b446ef218a6fb97e652be0aeaa4209d1c75577fd4", + "0x0a5c96ccce526b37acbd9cbea1f54a3b0d7d9355bc5b2e73685641ddd1691dbe", + "0x7bd2d29f4e05262244eb00af397a27132489abd476657497c2091a5e09fd028d", + "0x6bb1e68faf6241a81d5f80cdce73750e9979840cd454e701f5027975e0839c13", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xed20Bb4772f9EAB584F5F7FBC3E601431C881e96": { + "index": 178, + "amount": "0x01", + "proof": [ + "0x8f29334fa2ad453766bbea4f9b27c68aaaca422eae1b695863a328ff55e79ef3", + "0x099a0575a47fc7c90d37ad222b796f591c4f3c8cc5430b475751e7ab4cb76e9a", + "0xf8c29056ebcfe5fae8fd66c73dc80d748471d6e92447b781ee16e15ed7060308", + "0xa9c14b7bde5f6bd300bce856d17e01e920e75da313902e045b4b3e048962526c", + "0xb654a1a566453851ec2f35198e6992bb9af61b4c4bbb9383d0605d3898fe90ee", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xf1E26c020a084E77A4931fEE4c997a2b064566fc": { + "index": 179, + "amount": "0x01", + "proof": [ + "0xcd0fe3cd92b275e5a4f1d1f5aafb35869001bd57a15b27e6b4bead721bf552ef", + "0x8a217160a442ea7ffc85af035cd4d65f31c4705c1a3fffa75e802a5e7f546273", + "0x458ab07c152871be5712096c4d82f8b3d3ac751c1a69e1efc1461cee12f752c9", + "0xd9184a25eeb4f87cd2425cac26ac77cf668feab72ea6bbd3b110892fbe584508", + "0xce3c2cae572bf1ea81613ef7fc064010151dbd5264896982059a3d31ab366fcd", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xf45f34330bd4DeDAc13824e15624D97FBb430183": { + "index": 180, + "amount": "0x01", + "proof": [ + "0xce697c5f8c9bb292625c411cbc290e4eaa7288ec67507d467ebcf10a82e3ed3d", + "0xe5267359a68ce5a917a20b834e11fde6bb06625695e259a6ce29c59c072bb5c6", + "0x458ab07c152871be5712096c4d82f8b3d3ac751c1a69e1efc1461cee12f752c9", + "0xd9184a25eeb4f87cd2425cac26ac77cf668feab72ea6bbd3b110892fbe584508", + "0xce3c2cae572bf1ea81613ef7fc064010151dbd5264896982059a3d31ab366fcd", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xf53cAB0C6F25f48F985d1e2c40E03FC7C1963364": { + "index": 181, + "amount": "0x01", + "proof": [ + "0x783487661e7fde1580e4865f7f240b2751dc391bab08690d7c68336261431524", + "0x21737959a648ed2d2e38c13b446ef218a6fb97e652be0aeaa4209d1c75577fd4", + "0x0a5c96ccce526b37acbd9cbea1f54a3b0d7d9355bc5b2e73685641ddd1691dbe", + "0x7bd2d29f4e05262244eb00af397a27132489abd476657497c2091a5e09fd028d", + "0x6bb1e68faf6241a81d5f80cdce73750e9979840cd454e701f5027975e0839c13", + "0x3b88bbef87bdc360cd5dd18420ee58bddf73e8f853b5d14358a6f1bc69f684a1", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xf5dCb2a47f738d8bA39F9Fa2DdC7592f268a262A": { + "index": 182, + "amount": "0x01", + "proof": [ + "0x2866d72d00255c80d0ea924db4202da2157a8a331c6a7fcc0b002845735bc1e2", + "0x299704d80d2fd5f865c735b846306b3dc262a611f63660fbaaf12b52df9d86c1", + "0xe11251280abfd46378ca9ca336e9954dad085a38edcbca705ec534447a68e2e4", + "0xda4b6bc089b72bc047b6c6fed7fe7fcd52dd68b9d13d6be60c86383ca2ace879", + "0x3784903b025be81b83e9bb4752292191cf517ec429d6662e8b71177a2d5d4ce4", + "0x5d2bb7ac3b15ba8dbd1d52f8d2de0816cd32a427443b2c39b8118f898da0d830", + "0x3d656657f640a0809ba06513e17794779a3ea8425ffcbb232465e1d7d09435d8", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xf69EA6646cf682262E84cd7c67133eac59cef07b": { + "index": 183, + "amount": "0x01", + "proof": [ + "0x866f6939673737d6724842418b1635495f6a1e659a5465b0bf91ef5fefc28e63", + "0x5018e747d85c5ea88baa6da77e8044b33263864e5f30b5efeb5e97f5ef55ba07", + "0x00c785fb523e770b855f5a8f4bcff502dc4ae56e5dcb87030ea7135262441e9a", + "0x0d0da98bee418d7d5447b0b9f149280d02d3119d074c67428254b1b6e48d4725", + "0xb654a1a566453851ec2f35198e6992bb9af61b4c4bbb9383d0605d3898fe90ee", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xf91d8Ef97D5c7c08d7453D1852168fc36aa95dA4": { + "index": 184, + "amount": "0x01", + "proof": [ + "0x9c4e4d28b7cb50e1f43ce1d39a25a61c49cb4dca81a84e042e435441cf5aa8f6", + "0x11c8fd41523bd50072f2b4c078fcf414d0bab2796bd421c41346025eeafea12f", + "0x0dac557adc392ee670c09ce5feb56a9eb0694456c9b8679f870d2c6fcd1cd495", + "0xe1fb9cfbf2109f088b0cc3e464d6a88d8ce475c0df0baeaa065f9bf5438fcf28", + "0x28acf9aeee9dbbfe59ed9a35b834f1bb8f030da25f10829a720689183c091e8e", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + }, + "0xf96D09c553db50EF8198eED965dF9E660133C23A": { + "index": 185, + "amount": "0x02", + "proof": [ + "0xaaba1cb1936166c543fdf12bc85326e1c491a80b5232788a67c7d6c42bb96022", + "0xbc89bcb2d25063236537c931fd5443acf73349866e003e97bf024509f41a94b2", + "0x3012485b6b7f5ab71c4b1ca94bd1af248e606331cde37d005ff3bf07f6430c78", + "0x027dd52a5591276c58d2b79d691dd8cbbc85f5645392a665f5955e389f86c024", + "0x1ae23534fd2ec3b68f5762f60ee913ca81f956ea9ddeee68a6f8f4427a5a56d5", + "0xf89b2eaa9bdd4a82cbe2b57e19574248d64943eacdf604133ef22ab972ddccaf", + "0xb1ada1f04b7470c0358dbad2bcc66cc846c9e2876d200ca76873a4ca52a23b7b" + ] + }, + "0xfe98C7ea1b52D634Fa8A9C769bDec68365BC445A": { + "index": 186, + "amount": "0x01", + "proof": [ + "0xa5587018a565ecac48f479af8dedef6ddcfc548e993731052820dc8ec498debd", + "0xd5c80b252f62333501c948d1eacc5d0d183eb99eb6cc099f2beb609de0317752", + "0x7d90615908c5080e692d6d0dd760c920eaf9db7fa051a3e8b1135ce96cc6229c", + "0x930fec2c2d175134b5a08f2432bf7e01104646b61dee15c531d62ad698c4b460", + "0x28acf9aeee9dbbfe59ed9a35b834f1bb8f030da25f10829a720689183c091e8e", + "0xe83204ba6ee21e8a993a40ce9199cbe5df18a0e422f7a8a3160f72c1e26032ae", + "0x4465b0c2032247b6a960ac62abaec56d6fe7797231a1aad83a90ef81873fde79", + "0x2caab40876e71296877ca0c3c057992a6ab1333778ab3c6a4aac3830eba368a5" + ] + } + } + }, + { + "merkleRoot": "0xd0791b641b66f43eee59bc4d01e7e3ab2861385ab34353baa151cac695a4c445", + "tierIndex": 2, + "tokenTotal": "0xe1", + "claims": { + "0x0226068cE182ad66482ac08219d41e00Eae74aa7": { + "index": 0, + "amount": "0x01", + "proof": [ + "0xf2e471a680f836bfffb228af93f98d55125da61b6fc42fa114f162916c7c22c1", + "0xe4571e4963e85765e5f11de8db697fab75815154ad9a2301cd4c01d530bdd659", + "0xbc557a38c021854da14c864d8a612675692de555773b4f6f584a208db0946e6f", + "0xa7881a3153361de44ef539fff5315a464cb160cd0a73bf8db168d90af45d8d74", + "0x2fb599c492cfabf47640b63933b28995b0dd9d24c707b037db861b4bda99e3d0", + "0x8a9f8746387cd1d719c52f955a938b7e888ad62dbf864cc0a28347dbd84eab8c" + ] + }, + "0x03feF62a00c67520e1f77F07e34a8e64787Ea2a2": { + "index": 1, + "amount": "0x01", + "proof": [ + "0x0d78edeade77433890cab8ae5272ed8482543549b221e06c01576bb0030e4a26", + "0x66aef1bf13096c6a75cd20402fb489fa69c451202fbbf848fce543396a174c63", + "0x81a0fd1941b47d83a67c83d06df3139bbc20746761bb0a50c7e4681716a03c28", + "0x6c5886f920bb55f50a31ed3f4a69ec1efbb1c9d260336cc5f170b526f5759fbd", + "0xd27a7356541e491e70e040dfd164006df8e22100461d2a1a348411305d7b4bd1", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x044a9c43e95AA9FD28EEa25131A62b602D304F1f": { + "index": 2, + "amount": "0x02", + "proof": [ + "0x8e3e1755528fa81853379883cac37693bb21e820a1ab9549984fcdd0d1ce0404", + "0xbea09374fc097988e1ad96da1fee810e661aa868c44dcd6c9a1671be3c36dfa0", + "0xd767f3a32e0f77b4930165e6157d655a7ab7c488ef813f8552aa28fc0a2f878c", + "0x5a944baed22990b8e21cf58278da897e30ef6fc2921c804225dd11ec2ee21520", + "0xd75e5fa046a5b39a159c7f7713289fe87705858151008f31dced2f8ee56b5c3c", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x06e0Fe46a6590d32377EB0D9A8AD6f9D9adFd74C": { + "index": 3, + "amount": "0x01", + "proof": [ + "0x8669f13ecf0bb97a097e9b5944a74ea399973c3a743bdf29bf75c22f57708d02", + "0x6b2894f5d15c2eb869bb8d4c22fd8a7d592083538332d22e1d5f1d8b6feaa36b", + "0x94fa9e8fa4365ba5fcd407aec6841ab80c846875955560b04b6f95082a1a3b2e", + "0x5a944baed22990b8e21cf58278da897e30ef6fc2921c804225dd11ec2ee21520", + "0xd75e5fa046a5b39a159c7f7713289fe87705858151008f31dced2f8ee56b5c3c", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x0865aB296021946dC8Ce735e0d006aB33ba485be": { + "index": 4, + "amount": "0x07", + "proof": [ + "0x7a0da70d1aea150387da909164ad2c27d3cb5b88245f25b3b39f6b171a04d8e8", + "0xab69e5a0da944d90177421fc6129ca4550fc43285da217ab7dc7894049897292", + "0x05120c41e07e3b65b808187288cc7a5f85c946beb664d8a539686da10df18641", + "0xd86e9605374e6a7d4814dd6573551efb05032e760f43248939b5b489ee66277b", + "0xd75e5fa046a5b39a159c7f7713289fe87705858151008f31dced2f8ee56b5c3c", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x0998160bdF3Ff6D86A4E9D5c31e0eFC3Ca7e7D01": { + "index": 5, + "amount": "0x01", + "proof": [ + "0xc5489701dd34d7d32f3543094bfb0c61ceb21ea59b62b17852dd6774a5ee2370", + "0xacd923847be0ec4581a6f0ab69aee3f2ecbb479e7e4840b8ec98486316b76333", + "0x0d7f284d0a7106548f749450cd4cc64b69359fa1e8ffd3ffded6c5d2633b7c8c", + "0x6f45a04a87f1b905ded26d8cc81b8e2911ec5dc43d21ce9b5ddd70f9415e0681", + "0x6da7908e73d9f24053173ebb3f96a1f75b07f788134614128d97f72ed17dc046", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x0Aa350FB487F75d4f5d6ED920A5ae0923ded06E1": { + "index": 6, + "amount": "0x01", + "proof": [ + "0x346173e8f68813fa049f4204d2cfa1d71f06796b95fca0fd2949450eaa11bfe6", + "0xbeede05385444073837d97f7d6077e5ff2c58f70faf1985d1ebcfe2c5ced172f", + "0x3b0d6434b14f9799a303699a10eb258bc9481aea1ae11a249837d336bb687d72", + "0xb4711eda6a872fd3af62c107a195616009ccf580b231b50f957f8392cc0ad232", + "0xbe57b1104fa15c6024916d7f103143f08a337bd1f86e87bbc441cf6384c2c0dc", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x0B7E38BF0Bca35D9c5b435DAe88aE6C74aCaB7ee": { + "index": 7, + "amount": "0x01", + "proof": [ + "0x61e57e76bf9e25ed21a7b4dbc39143c64a668e1e65b38c98c6fbdf189c35624f", + "0x0c78762b3fc8ac4b7527d138f257b28f0fb7a8252b1c94647f2bbb9f3c040e21", + "0x58657bf0c703b38bb2e546a30e7cb9b5282fd26d0af967d449792761333cd559", + "0x4c62c1758dacf4387d8b03b08f77c5d8366ec9cfdfdb0de537340f8ca90b5ec8", + "0x53603755304d04a9224a8e709ce2bc8dd412e06a4cbb83727793a9881e556a5b", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x0Cb38052ba5D15DBEe0Eb4cB6a1779F28343DA09": { + "index": 8, + "amount": "0x01", + "proof": [ + "0xd8b67a99281fbc4b6c7113a0c229b4caf2e30a4003b128928fbd2dbe4da96090", + "0xbbd9bd000946f267803674e8c793de16ec387cadf37dfb40cfeb3829224b9905", + "0x5b4ef21840313a74dd07ab6b62e2d62dc79b3bc521345abba0167941286c5db6", + "0xf63cfa68f62fc044d5f3ee9a8c1d2f2a23da53f29485a55be519052c617003a7", + "0x639591b737c65a392edb3f7a8be50407ba55cc8551a7a3d638e48b7865853ab0", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x0Eb96D5ec478B68fF0d48628Ab4DF6A63c21ddAa": { + "index": 9, + "amount": "0x01", + "proof": [ + "0x4201cad45d25148ba57a9d569d94dc7208f545efbabfa1bc5b089ce809b7e399", + "0x75150f06f9fc74b9bc214e59401ae1b04b3a597fc45f5647711dcb98b1e9cb5d", + "0x3e246c533c956ec897a458a019f8a18193cc6c38efa9ad198798b5a0d867fdef", + "0xdfbc762d844655a02f4c4a2e54aa70ab4f1f442539d1904b1393a9201f1b0183", + "0xb0d931443cc2b12d482c98645d2953f321e6bba9c885e4b9b6f8a6cb3410e190", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x0F0eAE91990140C560D4156DB4f00c854Dc8F09E": { + "index": 10, + "amount": "0x01", + "proof": [ + "0xaf343ea2b63698fcf668e06ea1e6b6d2fe1c6d71ee32a04a748968b7fa2634c9", + "0x4518848ea2d76058032a5d127c3fedb092b4b5c90978026c1d39204fffe0c15a", + "0x3bea0db679a50cbfa728790d3c9989c52f9d4be82f44db6f8904aabc1de5fe8b", + "0x76fa309cc3308a6a1b68c368dc64127791cc20f02aec2f04048bdcd24ac89108", + "0x6da7908e73d9f24053173ebb3f96a1f75b07f788134614128d97f72ed17dc046", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x0FE5E887dAe7A24836a192622fB84Ce7B97ac306": { + "index": 11, + "amount": "0x01", + "proof": [ + "0x939630574be8147015763d5f7e54036e5bb3cd3751c0674d40403b79ea0f0194", + "0x72682a4f96764b1a0ec8cf6889a44540a5614e197ba204b77f4521357a15c160", + "0x967653830cb7587ccce3a695e55866f8f6ff9a6395e61064c9a5887effcfcb55", + "0x8100df3417a3c454a86f42d81ed5a1a9138e76181b3d04ebdc19d8c3dcc3d68b", + "0x0c72dfa360ac239440f62348d8c138293533cc729f1d0ba3c6fe11634a6f7729", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x183B6267cb9F985A8AA7Fc912672A21d644a4102": { + "index": 12, + "amount": "0x01", + "proof": [ + "0x7c15bee9a29842f69955d4cf4fde59642a59d69585b8c522f3682d1ced84ddc4", + "0xab69e5a0da944d90177421fc6129ca4550fc43285da217ab7dc7894049897292", + "0x05120c41e07e3b65b808187288cc7a5f85c946beb664d8a539686da10df18641", + "0xd86e9605374e6a7d4814dd6573551efb05032e760f43248939b5b489ee66277b", + "0xd75e5fa046a5b39a159c7f7713289fe87705858151008f31dced2f8ee56b5c3c", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x1CE2304369d957fc1F0Dd32C983F445E449F4C7A": { + "index": 13, + "amount": "0x01", + "proof": [ + "0x0a3ec29621cad67a0ded1aeecd54ce1e42afce48e9b9e08867bbfb0a8ffd987b", + "0x66aef1bf13096c6a75cd20402fb489fa69c451202fbbf848fce543396a174c63", + "0x81a0fd1941b47d83a67c83d06df3139bbc20746761bb0a50c7e4681716a03c28", + "0x6c5886f920bb55f50a31ed3f4a69ec1efbb1c9d260336cc5f170b526f5759fbd", + "0xd27a7356541e491e70e040dfd164006df8e22100461d2a1a348411305d7b4bd1", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x2079C29Be9c8095042edB95f293B5b510203d6cE": { + "index": 14, + "amount": "0x04", + "proof": [ + "0x1f942ccb9ccab49eac068f4de904ec7efe76ded6cfa5325a03e00357fc819bf7", + "0xd16a5fb012a1f0c02fcf73d1b85f28c34981d107ca369d711d19dc4fb904be4d", + "0xd5cd1288deee3dbfd0571dac04ef05d7405ea11949ea8ff37fba1025a4a949df", + "0xf4c2497eedcf38142d0d50ca185254f5a051a3ba6184b121326e7c3b36029eaf", + "0xd27a7356541e491e70e040dfd164006df8e22100461d2a1a348411305d7b4bd1", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x228c1334fc57Eb6E02EcC448E749a041124321c1": { + "index": 15, + "amount": "0x01", + "proof": [ + "0x4f077b65749c22f833bf36b4d2aefc1d27c32c5d7c9c36285d1b7cf1ed60dcb1", + "0x0ac60961c502e3ee7c43927faba20bca1de95d6d8988f23a2ffacbb6f1e5858e", + "0x4ac7402f21fe8901d75d40f5aed1b36d3621bc7e4e1afccd6483996c7a78d98d", + "0xa3a5bc515aec1ddfe0097cb857bb0dc9eb0285104af5c61120fc791ec6075419", + "0xb0d931443cc2b12d482c98645d2953f321e6bba9c885e4b9b6f8a6cb3410e190", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x23d3bC42D4211346DF008657F6143113a618946E": { + "index": 16, + "amount": "0x09", + "proof": [ + "0xeeb2b67ed444252a897680a5e344ff2963edb50ddf617cee17e4f1714c17a408", + "0xac6fb57a2ce6c1e662c250d264f621c5904e81a480368d7a20e0f0b129e47786", + "0x0300d57531ed3de4dbabbd7127000254fbe4bfbc2dda958b72b566840b715651", + "0x5216d1b0bee3076cf71d2cc80c70d66628ddeb0c500d173c873e9ca804ddce21", + "0x2fb599c492cfabf47640b63933b28995b0dd9d24c707b037db861b4bda99e3d0", + "0x8a9f8746387cd1d719c52f955a938b7e888ad62dbf864cc0a28347dbd84eab8c" + ] + }, + "0x264571c538137922c6e8aF4927C3D3F681399E50": { + "index": 17, + "amount": "0x01", + "proof": [ + "0x7942cd6cd25b4c449d0d3df8270da94ab3e14d16798c00a57a07f63422257642", + "0xfb059472ce7b9e8ba22d19840002817a62c2ca905c80d7250a67de5915e970d4", + "0x05120c41e07e3b65b808187288cc7a5f85c946beb664d8a539686da10df18641", + "0xd86e9605374e6a7d4814dd6573551efb05032e760f43248939b5b489ee66277b", + "0xd75e5fa046a5b39a159c7f7713289fe87705858151008f31dced2f8ee56b5c3c", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x2762c7fE932B8688508Fff24eCECbBCa92A128C4": { + "index": 18, + "amount": "0x01", + "proof": [ + "0x9777502ece00c1332cc9666a58f9a7d70cf94967292c482b6b959cbccce7a845", + "0x23f06c974d7798ef4309719f0b6540d892ca110772c869ee61c6402d1a1ecf35", + "0x615c4f9260b4f01ff05147dfaad31b595addb465ed0d3af829d21774fb19bb13", + "0x8100df3417a3c454a86f42d81ed5a1a9138e76181b3d04ebdc19d8c3dcc3d68b", + "0x0c72dfa360ac239440f62348d8c138293533cc729f1d0ba3c6fe11634a6f7729", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x27a7F6Fca0431C02C3C5fb6116fF019A25be526d": { + "index": 19, + "amount": "0x01", + "proof": [ + "0xf6d5c8eff0d8578e08916a25b8d27a983cf19de5c82a153da3a608da4ae033df", + "0x77ce39f015889ad4290717b62d9078bbce0933d8ac80a7a5ea48b3f30ed6bcbd", + "0x38d6f503c021f05b476b4b2b24c4b2e532e1ed256bfc779d3d5e6549995b8ed1", + "0xa7881a3153361de44ef539fff5315a464cb160cd0a73bf8db168d90af45d8d74", + "0x2fb599c492cfabf47640b63933b28995b0dd9d24c707b037db861b4bda99e3d0", + "0x8a9f8746387cd1d719c52f955a938b7e888ad62dbf864cc0a28347dbd84eab8c" + ] + }, + "0x286204Bfb8371Afd83DFb2F3F8a8196a18b46ed6": { + "index": 20, + "amount": "0x01", + "proof": [ + "0x5f481b763157069eee8d19b5089a184214edcb3426bb5b038cdf6c8115932b43", + "0xef9ea0772f5aef9cb9bfee89b7124624e5c36bb23748158ba57c631b8fff33cb", + "0x58657bf0c703b38bb2e546a30e7cb9b5282fd26d0af967d449792761333cd559", + "0x4c62c1758dacf4387d8b03b08f77c5d8366ec9cfdfdb0de537340f8ca90b5ec8", + "0x53603755304d04a9224a8e709ce2bc8dd412e06a4cbb83727793a9881e556a5b", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x28AeE851E7b65A46b71DE302CFfEeB2c557847C6": { + "index": 21, + "amount": "0x01", + "proof": [ + "0xc4873ed803beeff8f5d21c0de3e1d65d312302c79a2c8de279bf7b3828e539ad", + "0x7e72cb692fd9ffd51d7d2ade2b9070801a4c14d814c40f576d4a4732d568c7dd", + "0x0d7f284d0a7106548f749450cd4cc64b69359fa1e8ffd3ffded6c5d2633b7c8c", + "0x6f45a04a87f1b905ded26d8cc81b8e2911ec5dc43d21ce9b5ddd70f9415e0681", + "0x6da7908e73d9f24053173ebb3f96a1f75b07f788134614128d97f72ed17dc046", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x28C01B64F2492D82fd58FEECF8c71603c769BB4A": { + "index": 22, + "amount": "0x01", + "proof": [ + "0xfaad7a6c469719ee25c075a5874970e0cae1a58d3f219a0e6a58f922e5738a93", + "0xff7881052c23cd014cd049236af59c45a517f1304a862671736938004f48a2e7", + "0x8b963b8ea027df8f0802e83e86b5ba06588c71e7ea9394ade928631f4319cc8c", + "0x8a9f8746387cd1d719c52f955a938b7e888ad62dbf864cc0a28347dbd84eab8c" + ] + }, + "0x2cADf1261E6E1eEbbDf1a4B50a8d610400289520": { + "index": 23, + "amount": "0x01", + "proof": [ + "0xc312c6fc61862a20c559a603b4edf18f78d1f128cd9fb5cb6fdf3511a9cf5b10", + "0x34ba81e10925979fe7fe3e3a70195efee7980b22c211524c056abf38fe3fdb0e", + "0x8532a232a91f58b1a45385ff40e09a0f9565bbb1d779c8e41a05c0335312418c", + "0x6f45a04a87f1b905ded26d8cc81b8e2911ec5dc43d21ce9b5ddd70f9415e0681", + "0x6da7908e73d9f24053173ebb3f96a1f75b07f788134614128d97f72ed17dc046", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x31468523E226b9212E12688B7BFf7d8B6D3b94bf": { + "index": 24, + "amount": "0x01", + "proof": [ + "0x3322faff6e0760ac39f6262f14bc3d29ac3ad0710063ed9f001c48ee5ae346c3", + "0x108fa170abd377c427f2567291da7a600043e935f414f0142581f99fac06118e", + "0xf2fd5c16b389d137e666d73d205461fa2fabffa277d0d3cfa553bc36e77564f8", + "0xbc4a511e020853ee2178b38f1763ed063614c33685d3ca4c1aa44cc2404d1b51", + "0xbe57b1104fa15c6024916d7f103143f08a337bd1f86e87bbc441cf6384c2c0dc", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x31902313a140f32194058aaa352e282a542e45A7": { + "index": 25, + "amount": "0x08", + "proof": [ + "0xcd8567ee94bc24a44f4decdfdb29b85a258ec31e1f36bc4bf650cdbb907ceaf6", + "0x14fcf9ea56ba0b27d39ded21a2f3c09d28d861c7aa7ac234c08883224f1dcde6", + "0xbcd9110d9a5aa583583c6042a1dd99df5e548f2b9ba2246218c580be9902d589", + "0x73def4e56a6689530d5ef5e845e927f0a9f9d8f7ee2748be7b25b5d06e811c94", + "0x639591b737c65a392edb3f7a8be50407ba55cc8551a7a3d638e48b7865853ab0", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x31fE8439F34ed04514288a6f0F19f26c647Cd6aD": { + "index": 26, + "amount": "0x01", + "proof": [ + "0x57621a8a7bde7eba9c4f495d3f5286e18f435493f33b91ee298fd8d1c2f0fffb", + "0xa5e3a433644bf316455de46200e4e05a0e3a81f583b80d5b5be1ae6d4348d0e8", + "0x05587dbe5f3fc1e7b5acdb230c8eef57f92b43a387ea89f8e4944a2d584a00e7", + "0xa3a5bc515aec1ddfe0097cb857bb0dc9eb0285104af5c61120fc791ec6075419", + "0xb0d931443cc2b12d482c98645d2953f321e6bba9c885e4b9b6f8a6cb3410e190", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x323622f9e2692Bcae113Ac10fae42583fB4Fa568": { + "index": 27, + "amount": "0x01", + "proof": [ + "0x4661985b07377714d365d3e634048cdc09e2be8a775fdffd8acac5b03c50f72b", + "0xc69043128a81022053d959a6021584666aa61b1a8a67b8f1ad4220e56baa1e67", + "0x5278fa3e1d6a528e7bda38f332d996584dba533e08c2b62fd6b06daf5cb50463", + "0xdfbc762d844655a02f4c4a2e54aa70ab4f1f442539d1904b1393a9201f1b0183", + "0xb0d931443cc2b12d482c98645d2953f321e6bba9c885e4b9b6f8a6cb3410e190", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x3303b6AED6F306A6d7cf5e8C8956bEFd8F1Bd2e2": { + "index": 28, + "amount": "0x01", + "proof": [ + "0x2b5b26a8e3e701524e47ce24a7f3208d262bf1fdb92a51501f6e39cad3b089dc", + "0x2bc043dfeee3f04f74a1e43de01191f7fc248170c080646bf23b7f838d9d07b1", + "0x8b464f63d43336259b3582e0657654cec480e52339bb22514ec623408c946eca", + "0xbc4a511e020853ee2178b38f1763ed063614c33685d3ca4c1aa44cc2404d1b51", + "0xbe57b1104fa15c6024916d7f103143f08a337bd1f86e87bbc441cf6384c2c0dc", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x33b4C240C7a3aF3e5365Ebb2Cda44bad82e4878E": { + "index": 29, + "amount": "0x01", + "proof": [ + "0xf7ef0a3e20bf49f8e044ea35b7947bb9b64c7453f453bd9e48459736a89c865a", + "0x6bc22635ac5a01b2a3f6b80a7b32fbf5639d7307dc98be0e1df77c5633446c0c", + "0x38d6f503c021f05b476b4b2b24c4b2e532e1ed256bfc779d3d5e6549995b8ed1", + "0xa7881a3153361de44ef539fff5315a464cb160cd0a73bf8db168d90af45d8d74", + "0x2fb599c492cfabf47640b63933b28995b0dd9d24c707b037db861b4bda99e3d0", + "0x8a9f8746387cd1d719c52f955a938b7e888ad62dbf864cc0a28347dbd84eab8c" + ] + }, + "0x33eBB62DC9ddBf6B8F3C0efdF5BccC2e7AC60211": { + "index": 30, + "amount": "0x02", + "proof": [ + "0xafdd068c25cc4d95618dffbe84933266d863855037fa499ccc1111e9d3de33ee", + "0x4518848ea2d76058032a5d127c3fedb092b4b5c90978026c1d39204fffe0c15a", + "0x3bea0db679a50cbfa728790d3c9989c52f9d4be82f44db6f8904aabc1de5fe8b", + "0x76fa309cc3308a6a1b68c368dc64127791cc20f02aec2f04048bdcd24ac89108", + "0x6da7908e73d9f24053173ebb3f96a1f75b07f788134614128d97f72ed17dc046", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x344651A2445484bd2928eB46D2610DaaC1B42A66": { + "index": 31, + "amount": "0x01", + "proof": [ + "0x6f22340179877c4c91ef12373c38d0c9ffca6b8e91bd958863d6c18770302592", + "0xfd1769b2bd0778cfae755b2a90c3952c70786ff5882b705479474fa5eafbec5e", + "0x2d81bdcabd0a9e4803cbf01cb1586d253a61dc351e69add58de9d437e61bc4ba", + "0xee65780562aa1c820d5b1cd70b8768d759b6831a97103be7e28044256fcc4257", + "0x53603755304d04a9224a8e709ce2bc8dd412e06a4cbb83727793a9881e556a5b", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x35E14B0722Dc1a81893FF8F7f99F931aca5B2d25": { + "index": 32, + "amount": "0x03", + "proof": [ + "0x2809aee157bcd9ec983b3d023c772a38e7961c514aeb82d9734091f5401b2927", + "0xfde458f0611383cdccb0655cf7053a61fd88b9070b1994089efac325d43ed776", + "0xd5cd1288deee3dbfd0571dac04ef05d7405ea11949ea8ff37fba1025a4a949df", + "0xf4c2497eedcf38142d0d50ca185254f5a051a3ba6184b121326e7c3b36029eaf", + "0xd27a7356541e491e70e040dfd164006df8e22100461d2a1a348411305d7b4bd1", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x3631401a11Ba7004d1311e24d177B05Ece39B4b3": { + "index": 33, + "amount": "0x01", + "proof": [ + "0xc0981227ed5fc212524c05e3894a3574e133696b855a900c55528906bd7d63b8", + "0x913a7b6c22a3f617542cc3a5dd0973598d2648ac3917efb2e659971395fad528", + "0x8532a232a91f58b1a45385ff40e09a0f9565bbb1d779c8e41a05c0335312418c", + "0x6f45a04a87f1b905ded26d8cc81b8e2911ec5dc43d21ce9b5ddd70f9415e0681", + "0x6da7908e73d9f24053173ebb3f96a1f75b07f788134614128d97f72ed17dc046", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x36837e2c2893b2d34fA80694B70eb53677aa6D4a": { + "index": 34, + "amount": "0x01", + "proof": [ + "0xcb4c17a5ac80f7b05b8b3955c60e41b78276615ac92fbbfd23a668e0a1b0f4cb", + "0xacd923847be0ec4581a6f0ab69aee3f2ecbb479e7e4840b8ec98486316b76333", + "0x0d7f284d0a7106548f749450cd4cc64b69359fa1e8ffd3ffded6c5d2633b7c8c", + "0x6f45a04a87f1b905ded26d8cc81b8e2911ec5dc43d21ce9b5ddd70f9415e0681", + "0x6da7908e73d9f24053173ebb3f96a1f75b07f788134614128d97f72ed17dc046", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x38148eCC2078dA7f65E6233DDA28eFaf4C51E96F": { + "index": 35, + "amount": "0x01", + "proof": [ + "0x2f53d4e69c33c2817af9015b71feab98365b4d5f96d2941b14c68a939f6eb90e", + "0x108fa170abd377c427f2567291da7a600043e935f414f0142581f99fac06118e", + "0xf2fd5c16b389d137e666d73d205461fa2fabffa277d0d3cfa553bc36e77564f8", + "0xbc4a511e020853ee2178b38f1763ed063614c33685d3ca4c1aa44cc2404d1b51", + "0xbe57b1104fa15c6024916d7f103143f08a337bd1f86e87bbc441cf6384c2c0dc", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x391891Af67E29D97E61E30C3036a0874F5Da411e": { + "index": 36, + "amount": "0x01", + "proof": [ + "0xd4062e27d01588549c2d9c0a3a272a3742c29e9597a44ffca3303526cc14730b", + "0x3989bc418fabf027e136cd60a9c1b08ce04cfc101a1e761149745a57c3360622", + "0x8af93c64e19d0e90276afd05a9af3d42ecefff8601f7db57dc58c28985082484", + "0x73def4e56a6689530d5ef5e845e927f0a9f9d8f7ee2748be7b25b5d06e811c94", + "0x639591b737c65a392edb3f7a8be50407ba55cc8551a7a3d638e48b7865853ab0", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x3E067baD76736b9d782a106d02b5E2efDC1C43E5": { + "index": 37, + "amount": "0x01", + "proof": [ + "0xd3c684df3b8a63e8820aee1578eec4fe8572fd7c40048d8b15f4e5b6c9bc89ba", + "0x14fcf9ea56ba0b27d39ded21a2f3c09d28d861c7aa7ac234c08883224f1dcde6", + "0xbcd9110d9a5aa583583c6042a1dd99df5e548f2b9ba2246218c580be9902d589", + "0x73def4e56a6689530d5ef5e845e927f0a9f9d8f7ee2748be7b25b5d06e811c94", + "0x639591b737c65a392edb3f7a8be50407ba55cc8551a7a3d638e48b7865853ab0", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x3c229864378b3B0adF98aE247Ca33986AED8EC1E": { + "index": 38, + "amount": "0x01", + "proof": [ + "0xc2cc2d80c35b97f0069a9eaa7ba4e21ce76ace7b0f04f4c1f2e390dfc9839a8a", + "0x913a7b6c22a3f617542cc3a5dd0973598d2648ac3917efb2e659971395fad528", + "0x8532a232a91f58b1a45385ff40e09a0f9565bbb1d779c8e41a05c0335312418c", + "0x6f45a04a87f1b905ded26d8cc81b8e2911ec5dc43d21ce9b5ddd70f9415e0681", + "0x6da7908e73d9f24053173ebb3f96a1f75b07f788134614128d97f72ed17dc046", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x3e7cB76985f08346b924F9f3235A484208E25e1F": { + "index": 39, + "amount": "0x01", + "proof": [ + "0xac9974a76440f0b617b36e3a29ecc19ce08199f70d01ce40cba99816ea50aa11", + "0xeda92cd8d0674071678d96ce62823bf9f674c199932afcf5a49701ba5ec61d03", + "0x2d73ef59c8b434636958c61870d49afb92f00b7c516594a25165c7c8e7627fab", + "0xfdec23d47a2988a8df7640a4615e4245f7bcbe625eeb89b59939f558cf3bde59", + "0x0c72dfa360ac239440f62348d8c138293533cc729f1d0ba3c6fe11634a6f7729", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x409628Ef5D4bd177dF233bB3ce64B87251F534E6": { + "index": 40, + "amount": "0x01", + "proof": [ + "0x2ec2a52b5d9bcc5c5f78b1517742b3b7b6ca77377c6e0199977f868024a69dbf", + "0x92d77bbc831b12029ce0974c477704bbe4587d83c172af7a7188c2f2c5194573", + "0xf2fd5c16b389d137e666d73d205461fa2fabffa277d0d3cfa553bc36e77564f8", + "0xbc4a511e020853ee2178b38f1763ed063614c33685d3ca4c1aa44cc2404d1b51", + "0xbe57b1104fa15c6024916d7f103143f08a337bd1f86e87bbc441cf6384c2c0dc", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x45C2700a0b0e84FffFfC74dbe4Ca415BC940F93d": { + "index": 41, + "amount": "0x01", + "proof": [ + "0xd547e20eaa4d1cb3940e98528bd580faef3f7f5b91ce557a7b8627fd7cbfd097", + "0xbf8fd1c95f4ca9f7dc0dc149df715da56e20abdb6c2f40adaf870231a6f92126", + "0x8af93c64e19d0e90276afd05a9af3d42ecefff8601f7db57dc58c28985082484", + "0x73def4e56a6689530d5ef5e845e927f0a9f9d8f7ee2748be7b25b5d06e811c94", + "0x639591b737c65a392edb3f7a8be50407ba55cc8551a7a3d638e48b7865853ab0", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x491E3F994B6151Ddb643E19Ef49666b4cDc2E320": { + "index": 42, + "amount": "0x01", + "proof": [ + "0x7920a613dd761fcfe456f7590222e7c22e392970059126683d1602fd2350ca0c", + "0xfb059472ce7b9e8ba22d19840002817a62c2ca905c80d7250a67de5915e970d4", + "0x05120c41e07e3b65b808187288cc7a5f85c946beb664d8a539686da10df18641", + "0xd86e9605374e6a7d4814dd6573551efb05032e760f43248939b5b489ee66277b", + "0xd75e5fa046a5b39a159c7f7713289fe87705858151008f31dced2f8ee56b5c3c", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x4D61e5156866D83b8B9a48D5F86a53686BDe6B9D": { + "index": 43, + "amount": "0x01", + "proof": [ + "0xea3ced953756f708d6cf0abe04b5a6a729844dead498f4107d7c09e9245841de", + "0x3e60fdbe1c5675dc5f9507a5ad037ef3e1d9598e58cb61c3648042ca6f5fcfab", + "0x0300d57531ed3de4dbabbd7127000254fbe4bfbc2dda958b72b566840b715651", + "0x5216d1b0bee3076cf71d2cc80c70d66628ddeb0c500d173c873e9ca804ddce21", + "0x2fb599c492cfabf47640b63933b28995b0dd9d24c707b037db861b4bda99e3d0", + "0x8a9f8746387cd1d719c52f955a938b7e888ad62dbf864cc0a28347dbd84eab8c" + ] + }, + "0x4c1bcC8F570e9F98Fab0eAE6b14F4df6E90CB8F7": { + "index": 44, + "amount": "0x01", + "proof": [ + "0x6166b785bf8903b325b770a560b3b88481d7cc1cfc96508bc0e3d2ff4679114a", + "0x0c78762b3fc8ac4b7527d138f257b28f0fb7a8252b1c94647f2bbb9f3c040e21", + "0x58657bf0c703b38bb2e546a30e7cb9b5282fd26d0af967d449792761333cd559", + "0x4c62c1758dacf4387d8b03b08f77c5d8366ec9cfdfdb0de537340f8ca90b5ec8", + "0x53603755304d04a9224a8e709ce2bc8dd412e06a4cbb83727793a9881e556a5b", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x512a49C299F5F60EDc1EE147abF1d68B41de4737": { + "index": 45, + "amount": "0x01", + "proof": [ + "0x0a0cdd66d440affc3297a5e781269183077d3aad30dda89f8823b54e1a7f2f85", + "0xdb648fb7c467eaabfa0fb1778d900d7282a8b937109b8258e70f571c625bffc3", + "0xae099d30789aec8fbd35bb3344ee9bc0672ecacbd2937d956a6d6c45a7309e3c", + "0x6c5886f920bb55f50a31ed3f4a69ec1efbb1c9d260336cc5f170b526f5759fbd", + "0xd27a7356541e491e70e040dfd164006df8e22100461d2a1a348411305d7b4bd1", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x5221E4a2e1faCe94Bf61d7b6D8534D66D633bd01": { + "index": 46, + "amount": "0x01", + "proof": [ + "0x1a63b71ccea202d20ebb3d8cc10d914ce19fe70c9b120710149c1fc678849d3c", + "0x685ca8dd70a455b78722d15d04239ebee054f9743c3848586c13457fbb2a1ea1", + "0xbd5af09c424a97f6d726c08bdcda0f57bbb412158792024e68c9874f49e00d7c", + "0xf4c2497eedcf38142d0d50ca185254f5a051a3ba6184b121326e7c3b36029eaf", + "0xd27a7356541e491e70e040dfd164006df8e22100461d2a1a348411305d7b4bd1", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x5477729b43A0A9beA8c41367C62e7864123B57d8": { + "index": 47, + "amount": "0x01", + "proof": [ + "0x886f39944353f1a9a61e1899b492411e9041b1e8ce0d49814b18bd48f7b5a56f", + "0x59a284f9c8047275a272df686fd48936d0983dd60f30ee3daf8b71f38a9025fe", + "0xd767f3a32e0f77b4930165e6157d655a7ab7c488ef813f8552aa28fc0a2f878c", + "0x5a944baed22990b8e21cf58278da897e30ef6fc2921c804225dd11ec2ee21520", + "0xd75e5fa046a5b39a159c7f7713289fe87705858151008f31dced2f8ee56b5c3c", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x54BbF603af39b028dA873CaA1218A220E07D65E6": { + "index": 48, + "amount": "0x01", + "proof": [ + "0x44438235d202f02b3ceef2bf7df6972d8ba616eff1d81ee461d77793bdcf0d28", + "0x011309a1a07282d1823d3a763a7ace772e3b6bbeb9c9385325018944cb1b9256", + "0x5278fa3e1d6a528e7bda38f332d996584dba533e08c2b62fd6b06daf5cb50463", + "0xdfbc762d844655a02f4c4a2e54aa70ab4f1f442539d1904b1393a9201f1b0183", + "0xb0d931443cc2b12d482c98645d2953f321e6bba9c885e4b9b6f8a6cb3410e190", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x5523f46cC1E83784c8CcE92C9a98b725129b0879": { + "index": 49, + "amount": "0x01", + "proof": [ + "0x034384c3fdfa3867a95327af75c8dad66149038eaa65ba7770f580afa8a9777a", + "0xe500ea2f66f787d9db736cde61620c8a1bbd7c17b2a657bf91243d11a40e06ae", + "0xae099d30789aec8fbd35bb3344ee9bc0672ecacbd2937d956a6d6c45a7309e3c", + "0x6c5886f920bb55f50a31ed3f4a69ec1efbb1c9d260336cc5f170b526f5759fbd", + "0xd27a7356541e491e70e040dfd164006df8e22100461d2a1a348411305d7b4bd1", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x559C4b03a2474b04074c3678d08Fd5B8BaE85028": { + "index": 50, + "amount": "0x01", + "proof": [ + "0x9bd0a039e43dbadc5046baf11aec2f4369dda0777adabd453793787f00785bd9", + "0x17c196030d4108b2abacb323fa67c34d735d5165ba48a2f79a030c1371b787d0", + "0x615c4f9260b4f01ff05147dfaad31b595addb465ed0d3af829d21774fb19bb13", + "0x8100df3417a3c454a86f42d81ed5a1a9138e76181b3d04ebdc19d8c3dcc3d68b", + "0x0c72dfa360ac239440f62348d8c138293533cc729f1d0ba3c6fe11634a6f7729", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x568106712b41EacbF2A8643Ed2095b5327B61a5D": { + "index": 51, + "amount": "0x01", + "proof": [ + "0x965839b79bb82f0eefd4ae81dadd37d636d612e13b9db527b29e44ad80c21b74", + "0x7d8b245ad7dec545ff030e347cb319b05bc0cea79c26813f6641dc70395e360f", + "0x967653830cb7587ccce3a695e55866f8f6ff9a6395e61064c9a5887effcfcb55", + "0x8100df3417a3c454a86f42d81ed5a1a9138e76181b3d04ebdc19d8c3dcc3d68b", + "0x0c72dfa360ac239440f62348d8c138293533cc729f1d0ba3c6fe11634a6f7729", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x5784fF641C2AeEE1339c4c32dA28d2E2E975BD3f": { + "index": 52, + "amount": "0x01", + "proof": [ + "0x887d5bc41caae3e5ef23109e43fc7f75fd27dc37f6464d12b661226244bcc012", + "0xbea09374fc097988e1ad96da1fee810e661aa868c44dcd6c9a1671be3c36dfa0", + "0xd767f3a32e0f77b4930165e6157d655a7ab7c488ef813f8552aa28fc0a2f878c", + "0x5a944baed22990b8e21cf58278da897e30ef6fc2921c804225dd11ec2ee21520", + "0xd75e5fa046a5b39a159c7f7713289fe87705858151008f31dced2f8ee56b5c3c", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x57fB6C359c8Cf9Caf0eC8beaC0c8b944cb63d9b8": { + "index": 53, + "amount": "0x01", + "proof": [ + "0xcce4c04b12d2005aba5c079e6eb113c7ff9b1aeacb5ac71d0d3c4ec433735365", + "0xfe536d1e8cd2fd6eda7bb57c76e3d535223373aeb63004dcea2739686004161f", + "0xbcd9110d9a5aa583583c6042a1dd99df5e548f2b9ba2246218c580be9902d589", + "0x73def4e56a6689530d5ef5e845e927f0a9f9d8f7ee2748be7b25b5d06e811c94", + "0x639591b737c65a392edb3f7a8be50407ba55cc8551a7a3d638e48b7865853ab0", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x57fcF904efC785e098676922d406e64A4e0e7ea2": { + "index": 54, + "amount": "0x03", + "proof": [ + "0xcc78a03e955fb5bd6afc8c52ba7ad084ffcc344ff49f20bfb57c867f1b472ab7", + "0xfe536d1e8cd2fd6eda7bb57c76e3d535223373aeb63004dcea2739686004161f", + "0xbcd9110d9a5aa583583c6042a1dd99df5e548f2b9ba2246218c580be9902d589", + "0x73def4e56a6689530d5ef5e845e927f0a9f9d8f7ee2748be7b25b5d06e811c94", + "0x639591b737c65a392edb3f7a8be50407ba55cc8551a7a3d638e48b7865853ab0", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x5B53d310c73Afd70f03b7a373b3e2451983228c1": { + "index": 55, + "amount": "0x01", + "proof": [ + "0xf98f6da40de3c384a0eacc57c06c19527eea27506dfb349af57b739bf83ac196", + "0x6bc22635ac5a01b2a3f6b80a7b32fbf5639d7307dc98be0e1df77c5633446c0c", + "0x38d6f503c021f05b476b4b2b24c4b2e532e1ed256bfc779d3d5e6549995b8ed1", + "0xa7881a3153361de44ef539fff5315a464cb160cd0a73bf8db168d90af45d8d74", + "0x2fb599c492cfabf47640b63933b28995b0dd9d24c707b037db861b4bda99e3d0", + "0x8a9f8746387cd1d719c52f955a938b7e888ad62dbf864cc0a28347dbd84eab8c" + ] + }, + "0x5bbB65fe6E990f2DCDF95FE7E71f07264c5993ac": { + "index": 56, + "amount": "0x01", + "proof": [ + "0xde11fa903bc72b0a3ed9e40d9408863739158c60fe116d99c2def5a2fbb1082b", + "0xc36d8499e8f8f179a424064dc8b9eeeb4e1623d13934d5fe0343a517617d6705", + "0x5b4ef21840313a74dd07ab6b62e2d62dc79b3bc521345abba0167941286c5db6", + "0xf63cfa68f62fc044d5f3ee9a8c1d2f2a23da53f29485a55be519052c617003a7", + "0x639591b737c65a392edb3f7a8be50407ba55cc8551a7a3d638e48b7865853ab0", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x5edfA1d84e9BB67DF816ff8380db056b6911B330": { + "index": 57, + "amount": "0x01", + "proof": [ + "0x652581469e1a859e2ca4e7c96458685d99da6042a4f4922050e1aaa023289581", + "0x58bff1dbdd299fa56333b5d93ebda49f51c884232a7e161979905b0dabd237a8", + "0xcaa8359951a076396426fe0bae0dc6e891ce555235907dd3884d2bad35600e82", + "0xee65780562aa1c820d5b1cd70b8768d759b6831a97103be7e28044256fcc4257", + "0x53603755304d04a9224a8e709ce2bc8dd412e06a4cbb83727793a9881e556a5b", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x6186290B28D511bFF971631c916244A9fC539cfE": { + "index": 58, + "amount": "0x01", + "proof": [ + "0x6165c0f93b75ed0cc11a80e4066a96af838d4913b06dc355985296b7fd578cc2", + "0xef9ea0772f5aef9cb9bfee89b7124624e5c36bb23748158ba57c631b8fff33cb", + "0x58657bf0c703b38bb2e546a30e7cb9b5282fd26d0af967d449792761333cd559", + "0x4c62c1758dacf4387d8b03b08f77c5d8366ec9cfdfdb0de537340f8ca90b5ec8", + "0x53603755304d04a9224a8e709ce2bc8dd412e06a4cbb83727793a9881e556a5b", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x6368CE2750325f5002587C70C8Bc298B4df61EBA": { + "index": 59, + "amount": "0x01", + "proof": [ + "0xe3cce1c533f7d7e703cf3d79ba422862f503385ddb704b317525fd027e638a07", + "0x643ce3bf8c7f1df5d1a1acf7ab77000a49fb24950c3ee124f704571e51822de5", + "0x89364a4d28977c6e2f307f26e4ca5c8c7a1a542d63e6970a21e1bae21cbd11fe", + "0xf63cfa68f62fc044d5f3ee9a8c1d2f2a23da53f29485a55be519052c617003a7", + "0x639591b737c65a392edb3f7a8be50407ba55cc8551a7a3d638e48b7865853ab0", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x645b585A741a395f6B02B2AB9E2647bd83C4F20C": { + "index": 60, + "amount": "0x01", + "proof": [ + "0x10ec7a5f0bead6600eb2ad1de43783359a3dda2c7923b9acb8a78253bf60dcc9", + "0xfd95d4438c06627d4aa5d8fba0ca0b59b0152f4aa8f695151ed2de667ec1087c", + "0x81a0fd1941b47d83a67c83d06df3139bbc20746761bb0a50c7e4681716a03c28", + "0x6c5886f920bb55f50a31ed3f4a69ec1efbb1c9d260336cc5f170b526f5759fbd", + "0xd27a7356541e491e70e040dfd164006df8e22100461d2a1a348411305d7b4bd1", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x65CAc1fc7489f7B08156e2e95db4cb35C7C29b4f": { + "index": 61, + "amount": "0x01", + "proof": [ + "0x09e29ba67a16de8833d553b39e7ac4b87df55a7c05e8856c6207f2042f434b2c", + "0xdb648fb7c467eaabfa0fb1778d900d7282a8b937109b8258e70f571c625bffc3", + "0xae099d30789aec8fbd35bb3344ee9bc0672ecacbd2937d956a6d6c45a7309e3c", + "0x6c5886f920bb55f50a31ed3f4a69ec1efbb1c9d260336cc5f170b526f5759fbd", + "0xd27a7356541e491e70e040dfd164006df8e22100461d2a1a348411305d7b4bd1", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x66981917ADf18dFfC2b41A3b181C313f506D5355": { + "index": 62, + "amount": "0x01", + "proof": [ + "0x3ee36ff50abd5d7ed1efc0b950adf4861e4db32849234d92a89b1c22a64e2a95", + "0x75150f06f9fc74b9bc214e59401ae1b04b3a597fc45f5647711dcb98b1e9cb5d", + "0x3e246c533c956ec897a458a019f8a18193cc6c38efa9ad198798b5a0d867fdef", + "0xdfbc762d844655a02f4c4a2e54aa70ab4f1f442539d1904b1393a9201f1b0183", + "0xb0d931443cc2b12d482c98645d2953f321e6bba9c885e4b9b6f8a6cb3410e190", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x67D33CF1C7c699078f86D517A5a1cd1444A1E85C": { + "index": 63, + "amount": "0x01", + "proof": [ + "0x573df6ef7a50b458b077515b525747a5bf98d0bb1b909e75c9954a255b8c9452", + "0xdebeeb2558c065cf158b24dd9037ef563cb56dce0f67141ccc79b4fb8d3513f7", + "0x05587dbe5f3fc1e7b5acdb230c8eef57f92b43a387ea89f8e4944a2d584a00e7", + "0xa3a5bc515aec1ddfe0097cb857bb0dc9eb0285104af5c61120fc791ec6075419", + "0xb0d931443cc2b12d482c98645d2953f321e6bba9c885e4b9b6f8a6cb3410e190", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x69C6bfa41106Be696C18f62db8D6a1A982FCeBcc": { + "index": 64, + "amount": "0x07", + "proof": [ + "0xf4db935ed05dfeb3267915f924fc0430e5ad87091f3b5ecb11e2f53c90e14ce3", + "0x533e2c7f972ee1bdd8626f9aac4bfb3e787d4a6c825c64e64329e72253b4d999", + "0xbc557a38c021854da14c864d8a612675692de555773b4f6f584a208db0946e6f", + "0xa7881a3153361de44ef539fff5315a464cb160cd0a73bf8db168d90af45d8d74", + "0x2fb599c492cfabf47640b63933b28995b0dd9d24c707b037db861b4bda99e3d0", + "0x8a9f8746387cd1d719c52f955a938b7e888ad62dbf864cc0a28347dbd84eab8c" + ] + }, + "0x6A9ee69B6781C18164ee9F7C58f1763BcFfC7c51": { + "index": 65, + "amount": "0x01", + "proof": [ + "0xfd49d69717096bd8de4b76a0b6a272063a62cc206adf24d7c8213950cb0120c3", + "0xff7881052c23cd014cd049236af59c45a517f1304a862671736938004f48a2e7", + "0x8b963b8ea027df8f0802e83e86b5ba06588c71e7ea9394ade928631f4319cc8c", + "0x8a9f8746387cd1d719c52f955a938b7e888ad62dbf864cc0a28347dbd84eab8c" + ] + }, + "0x6Ec4DEFaAA028bbEe11494baaCb9067F083C359f": { + "index": 66, + "amount": "0x01", + "proof": [ + "0x3c9b288532a8b313250c0883ca2273ef46db3ab951bdc71d31dc708598a77d5b", + "0x407f30a30803833364a15c78eb8805899dc5b25bae33805b50b7f8093086b52f", + "0x58c430d302de98f4e7cb5243208be576affa2259142537b31872f6d2895823ef", + "0xb4711eda6a872fd3af62c107a195616009ccf580b231b50f957f8392cc0ad232", + "0xbe57b1104fa15c6024916d7f103143f08a337bd1f86e87bbc441cf6384c2c0dc", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x712fdD09AC64D5776077e2B813FCd1B0431F5278": { + "index": 67, + "amount": "0x01", + "proof": [ + "0x742a94f4d253cab3223d652074d3e68f9e862aeba5204508e58a888f2b71c971", + "0x1b8941ff719058a5777ee1d51ec974a021465e6097d091e418eedda69cd01f83", + "0x81f53032d8e6411fbdd1cc3a0b7a0bcb13f5315fa7ffac066632e728fda36338", + "0xd86e9605374e6a7d4814dd6573551efb05032e760f43248939b5b489ee66277b", + "0xd75e5fa046a5b39a159c7f7713289fe87705858151008f31dced2f8ee56b5c3c", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x721931508DF2764fD4F70C53Da646Cb8aEd16acE": { + "index": 68, + "amount": "0x01", + "proof": [ + "0xf45df12efd648cfc476489acce0fc77e12f679c2995c5d4086025190174836da", + "0x8b963b8ea027df8f0802e83e86b5ba06588c71e7ea9394ade928631f4319cc8c", + "0x8a9f8746387cd1d719c52f955a938b7e888ad62dbf864cc0a28347dbd84eab8c" + ] + }, + "0x7360dC8B89Cba6d241Edc2DF723c2824855cbeC1": { + "index": 69, + "amount": "0x01", + "proof": [ + "0x666f7f40d977012d497a062a4d6b307e64556b9a96ab118f0aa7801dac216a1b", + "0x58bff1dbdd299fa56333b5d93ebda49f51c884232a7e161979905b0dabd237a8", + "0xcaa8359951a076396426fe0bae0dc6e891ce555235907dd3884d2bad35600e82", + "0xee65780562aa1c820d5b1cd70b8768d759b6831a97103be7e28044256fcc4257", + "0x53603755304d04a9224a8e709ce2bc8dd412e06a4cbb83727793a9881e556a5b", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x751893105B1eCe3b7fEda367B92Cd1Bcf2Abd673": { + "index": 70, + "amount": "0x01", + "proof": [ + "0x72d6d59ab9e3775b2826ca12ae34329f11d8b26e48313c36c0c970a4a37f9955", + "0x50be7334028e2bda05cedfff8bf29285df64497121fc50e6e5c97a6bddc14060", + "0x2d81bdcabd0a9e4803cbf01cb1586d253a61dc351e69add58de9d437e61bc4ba", + "0xee65780562aa1c820d5b1cd70b8768d759b6831a97103be7e28044256fcc4257", + "0x53603755304d04a9224a8e709ce2bc8dd412e06a4cbb83727793a9881e556a5b", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x762d0629c46a1D6EC9D83F0f146F177922333039": { + "index": 71, + "amount": "0x01", + "proof": [ + "0x76c989af9e06706af4fb0e9b437eabd2bf60c199e6f5a99375c8accc035f2fa9", + "0x33310bce293eb1df1299a7cb92e877934aa22fd5266a4c7e1ee40fdf35fb77b4", + "0x81f53032d8e6411fbdd1cc3a0b7a0bcb13f5315fa7ffac066632e728fda36338", + "0xd86e9605374e6a7d4814dd6573551efb05032e760f43248939b5b489ee66277b", + "0xd75e5fa046a5b39a159c7f7713289fe87705858151008f31dced2f8ee56b5c3c", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x786a567eb7928fA25ed4b32a19982313FE89C743": { + "index": 72, + "amount": "0x01", + "proof": [ + "0x59641e78b5e8f7c08b4e67485c8f49bd6edb3a746e63e5b501fd8745c8ea75f9", + "0xa5e3a433644bf316455de46200e4e05a0e3a81f583b80d5b5be1ae6d4348d0e8", + "0x05587dbe5f3fc1e7b5acdb230c8eef57f92b43a387ea89f8e4944a2d584a00e7", + "0xa3a5bc515aec1ddfe0097cb857bb0dc9eb0285104af5c61120fc791ec6075419", + "0xb0d931443cc2b12d482c98645d2953f321e6bba9c885e4b9b6f8a6cb3410e190", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x78d58Cc37cDAaBFde72c9a45B57Acbc3aBc3D7C9": { + "index": 73, + "amount": "0x01", + "proof": [ + "0x15f2ec51c349a4233febc6eb33b3c5bb9459e805c288673afe3a604651c1d27a", + "0xbb31272d5a37e4ea25aa8bf5bee6e93f9ed09f91e99b9260572ba1fabb2ed7fe", + "0xbd5af09c424a97f6d726c08bdcda0f57bbb412158792024e68c9874f49e00d7c", + "0xf4c2497eedcf38142d0d50ca185254f5a051a3ba6184b121326e7c3b36029eaf", + "0xd27a7356541e491e70e040dfd164006df8e22100461d2a1a348411305d7b4bd1", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x7ca2b8b8A6c81Cbd6d69267bC7854273D048294D": { + "index": 74, + "amount": "0x01", + "proof": [ + "0xdd4751a5e90da00d46585187b7df42975ed4dc0d2ff631fc225fcd1d0c789631", + "0xc36d8499e8f8f179a424064dc8b9eeeb4e1623d13934d5fe0343a517617d6705", + "0x5b4ef21840313a74dd07ab6b62e2d62dc79b3bc521345abba0167941286c5db6", + "0xf63cfa68f62fc044d5f3ee9a8c1d2f2a23da53f29485a55be519052c617003a7", + "0x639591b737c65a392edb3f7a8be50407ba55cc8551a7a3d638e48b7865853ab0", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x7d4c4d5380Ca2F9C7A091bb622B80613da7Eae8C": { + "index": 75, + "amount": "0x01", + "proof": [ + "0x3c41f4685d63fd8028f0448d86be0d9f62e30ec28cd1d2bde23d527a4fafb93f", + "0x407f30a30803833364a15c78eb8805899dc5b25bae33805b50b7f8093086b52f", + "0x58c430d302de98f4e7cb5243208be576affa2259142537b31872f6d2895823ef", + "0xb4711eda6a872fd3af62c107a195616009ccf580b231b50f957f8392cc0ad232", + "0xbe57b1104fa15c6024916d7f103143f08a337bd1f86e87bbc441cf6384c2c0dc", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x81f7e5dd3a12F88ef7239915a255fe8Dd22373B5": { + "index": 76, + "amount": "0x01", + "proof": [ + "0x462f2f83c16cfc03c3abaa53ef9056c7d7dcad92c44357d557fc80eb98ab5eba", + "0xc69043128a81022053d959a6021584666aa61b1a8a67b8f1ad4220e56baa1e67", + "0x5278fa3e1d6a528e7bda38f332d996584dba533e08c2b62fd6b06daf5cb50463", + "0xdfbc762d844655a02f4c4a2e54aa70ab4f1f442539d1904b1393a9201f1b0183", + "0xb0d931443cc2b12d482c98645d2953f321e6bba9c885e4b9b6f8a6cb3410e190", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x82209322516809C33889D5048Dce1860577C5584": { + "index": 77, + "amount": "0x01", + "proof": [ + "0x3b9731c02dc0b5f1da2f742ba6a860ce5bb11d8681ca1d2cf3a78bf8efa1039b", + "0x745adce7655a25f394c12d88c882b8b4c3997997b44931fab273afde393d721a", + "0x58c430d302de98f4e7cb5243208be576affa2259142537b31872f6d2895823ef", + "0xb4711eda6a872fd3af62c107a195616009ccf580b231b50f957f8392cc0ad232", + "0xbe57b1104fa15c6024916d7f103143f08a337bd1f86e87bbc441cf6384c2c0dc", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x854F1269b659A727a2268AB86FF77CFB30BfB358": { + "index": 78, + "amount": "0x01", + "proof": [ + "0xeccac9fdd8c6dc5c3a2a85913e6bc55f001b12045cdb81b5ef18943d146b23fa", + "0xac6fb57a2ce6c1e662c250d264f621c5904e81a480368d7a20e0f0b129e47786", + "0x0300d57531ed3de4dbabbd7127000254fbe4bfbc2dda958b72b566840b715651", + "0x5216d1b0bee3076cf71d2cc80c70d66628ddeb0c500d173c873e9ca804ddce21", + "0x2fb599c492cfabf47640b63933b28995b0dd9d24c707b037db861b4bda99e3d0", + "0x8a9f8746387cd1d719c52f955a938b7e888ad62dbf864cc0a28347dbd84eab8c" + ] + }, + "0x87616fA850c87a78f307878f32D808dad8f4d401": { + "index": 79, + "amount": "0x01", + "proof": [ + "0xd6e92135d67a2332f9173af29f1f9ac5d8a50ff2871ab32ac6957d1faf2551fa", + "0xbf8fd1c95f4ca9f7dc0dc149df715da56e20abdb6c2f40adaf870231a6f92126", + "0x8af93c64e19d0e90276afd05a9af3d42ecefff8601f7db57dc58c28985082484", + "0x73def4e56a6689530d5ef5e845e927f0a9f9d8f7ee2748be7b25b5d06e811c94", + "0x639591b737c65a392edb3f7a8be50407ba55cc8551a7a3d638e48b7865853ab0", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x896b94f4f27f12369698C302e2049cAe86936BbB": { + "index": 80, + "amount": "0x02", + "proof": [ + "0x27d8f41675bf770cba35c56a07cf406c8f8a19e31cec399971b590b70eec92ca", + "0xfde458f0611383cdccb0655cf7053a61fd88b9070b1994089efac325d43ed776", + "0xd5cd1288deee3dbfd0571dac04ef05d7405ea11949ea8ff37fba1025a4a949df", + "0xf4c2497eedcf38142d0d50ca185254f5a051a3ba6184b121326e7c3b36029eaf", + "0xd27a7356541e491e70e040dfd164006df8e22100461d2a1a348411305d7b4bd1", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x8e4a4eBB5D1f689aFaaBCe37eec80BA50b0748D1": { + "index": 81, + "amount": "0x01", + "proof": [ + "0xc426967ddb8da7955f841bc3c9891840a54e999f9c503153c1a67dc8b02a7dc9", + "0x34ba81e10925979fe7fe3e3a70195efee7980b22c211524c056abf38fe3fdb0e", + "0x8532a232a91f58b1a45385ff40e09a0f9565bbb1d779c8e41a05c0335312418c", + "0x6f45a04a87f1b905ded26d8cc81b8e2911ec5dc43d21ce9b5ddd70f9415e0681", + "0x6da7908e73d9f24053173ebb3f96a1f75b07f788134614128d97f72ed17dc046", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x90828E4504971670604834eaB1702d1abCF3a376": { + "index": 82, + "amount": "0x01", + "proof": [ + "0x2e4fea6513dd413c412a5431178209a90352f75e479b5380721c2f44f09cdf41", + "0x92d77bbc831b12029ce0974c477704bbe4587d83c172af7a7188c2f2c5194573", + "0xf2fd5c16b389d137e666d73d205461fa2fabffa277d0d3cfa553bc36e77564f8", + "0xbc4a511e020853ee2178b38f1763ed063614c33685d3ca4c1aa44cc2404d1b51", + "0xbe57b1104fa15c6024916d7f103143f08a337bd1f86e87bbc441cf6384c2c0dc", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x92cfdcEEb276a6Bc2f13B6907CD8E6aC245dD0FE": { + "index": 83, + "amount": "0x01", + "proof": [ + "0x2609fc04a4be1a8a1cf75e5e63dc4e7da5044403e2d3c7f5e14cbd7af7f7ba0e", + "0xd16a5fb012a1f0c02fcf73d1b85f28c34981d107ca369d711d19dc4fb904be4d", + "0xd5cd1288deee3dbfd0571dac04ef05d7405ea11949ea8ff37fba1025a4a949df", + "0xf4c2497eedcf38142d0d50ca185254f5a051a3ba6184b121326e7c3b36029eaf", + "0xd27a7356541e491e70e040dfd164006df8e22100461d2a1a348411305d7b4bd1", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x94E2DcF00CF7e33a4643478bb458b8123043116e": { + "index": 84, + "amount": "0x01", + "proof": [ + "0x5bd844d9368dfafab07effdf9cad3cf723761668f9b4228598e916c767762aec", + "0xa4824f7bc0708f7fb481ba1e32bf44f8293877f2efdf973d1e6fa3d76826db5c", + "0x93ace1dc79c2bdf39b5620fe288675192e9e8bea130393c6c99f1eae23603cd6", + "0x4c62c1758dacf4387d8b03b08f77c5d8366ec9cfdfdb0de537340f8ca90b5ec8", + "0x53603755304d04a9224a8e709ce2bc8dd412e06a4cbb83727793a9881e556a5b", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x9716Ff369914c68DD10B7eFE567Ff0b212d6d90a": { + "index": 85, + "amount": "0x01", + "proof": [ + "0x71f4b6bd6fd477bca9451f7ff9774215b242e29f01d9c861f07aef2ec1a605ba", + "0x50be7334028e2bda05cedfff8bf29285df64497121fc50e6e5c97a6bddc14060", + "0x2d81bdcabd0a9e4803cbf01cb1586d253a61dc351e69add58de9d437e61bc4ba", + "0xee65780562aa1c820d5b1cd70b8768d759b6831a97103be7e28044256fcc4257", + "0x53603755304d04a9224a8e709ce2bc8dd412e06a4cbb83727793a9881e556a5b", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x97944E369a1Af4040816f157134eDCA8E9F82eCD": { + "index": 86, + "amount": "0x01", + "proof": [ + "0x070f01b8e83dd70e16504db1e61f4989891fea4e3e23fa0989af6f479fe9d9fd", + "0xe500ea2f66f787d9db736cde61620c8a1bbd7c17b2a657bf91243d11a40e06ae", + "0xae099d30789aec8fbd35bb3344ee9bc0672ecacbd2937d956a6d6c45a7309e3c", + "0x6c5886f920bb55f50a31ed3f4a69ec1efbb1c9d260336cc5f170b526f5759fbd", + "0xd27a7356541e491e70e040dfd164006df8e22100461d2a1a348411305d7b4bd1", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x97fC31117F7F252F99C696d4Cd24eFb91d30cac8": { + "index": 87, + "amount": "0x01", + "proof": [ + "0x7fc161133c2fbda27f5617eefb23ca0453ba986451e2c4205ea594c6891ec4f9", + "0xb6bbd35b7fe9d4d2abbd59de51cdd915234f2c5691072599e61ecb6c3813704f", + "0x94fa9e8fa4365ba5fcd407aec6841ab80c846875955560b04b6f95082a1a3b2e", + "0x5a944baed22990b8e21cf58278da897e30ef6fc2921c804225dd11ec2ee21520", + "0xd75e5fa046a5b39a159c7f7713289fe87705858151008f31dced2f8ee56b5c3c", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x99a811E5c62ADD613975456292F836115AEa0164": { + "index": 88, + "amount": "0x01", + "proof": [ + "0xe764fc0e242fee53e0c168d5f21ef941d272362d512f3b59ff6740678fa5390c", + "0x643ce3bf8c7f1df5d1a1acf7ab77000a49fb24950c3ee124f704571e51822de5", + "0x89364a4d28977c6e2f307f26e4ca5c8c7a1a542d63e6970a21e1bae21cbd11fe", + "0xf63cfa68f62fc044d5f3ee9a8c1d2f2a23da53f29485a55be519052c617003a7", + "0x639591b737c65a392edb3f7a8be50407ba55cc8551a7a3d638e48b7865853ab0", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0x9b0c19000a8631c1f555bb365bDE308384E4f2Ff": { + "index": 89, + "amount": "0x01", + "proof": [ + "0xf5cb6df314defd5940255bbc1111123e377868ee2bc6581888c62a8283b3ac76", + "0x77ce39f015889ad4290717b62d9078bbce0933d8ac80a7a5ea48b3f30ed6bcbd", + "0x38d6f503c021f05b476b4b2b24c4b2e532e1ed256bfc779d3d5e6549995b8ed1", + "0xa7881a3153361de44ef539fff5315a464cb160cd0a73bf8db168d90af45d8d74", + "0x2fb599c492cfabf47640b63933b28995b0dd9d24c707b037db861b4bda99e3d0", + "0x8a9f8746387cd1d719c52f955a938b7e888ad62dbf864cc0a28347dbd84eab8c" + ] + }, + "0xA14964479Ebf9cD336011ad80652b08CD83dFE3A": { + "index": 90, + "amount": "0x02", + "proof": [ + "0x34c6539a5341aa88832313a1d9c81186620cb607d2310def6cb8bdd66af0051e", + "0xbeede05385444073837d97f7d6077e5ff2c58f70faf1985d1ebcfe2c5ced172f", + "0x3b0d6434b14f9799a303699a10eb258bc9481aea1ae11a249837d336bb687d72", + "0xb4711eda6a872fd3af62c107a195616009ccf580b231b50f957f8392cc0ad232", + "0xbe57b1104fa15c6024916d7f103143f08a337bd1f86e87bbc441cf6384c2c0dc", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xA3947BcD0538594E2bC571015144d9D5a58b2344": { + "index": 91, + "amount": "0x09", + "proof": [ + "0x4f1dbc9a6b0be2f2143f73e1c3d5ff24e2eefd662e2c808905dcc8cefc7930a8", + "0x07d230318ed277d599476c9c96fcc0d2fed30c809e281a49b7aa15c5417a88ad", + "0x4ac7402f21fe8901d75d40f5aed1b36d3621bc7e4e1afccd6483996c7a78d98d", + "0xa3a5bc515aec1ddfe0097cb857bb0dc9eb0285104af5c61120fc791ec6075419", + "0xb0d931443cc2b12d482c98645d2953f321e6bba9c885e4b9b6f8a6cb3410e190", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xA4Ab16a28A8567bB7e51D536f151F8bAc1D3b464": { + "index": 92, + "amount": "0x01", + "proof": [ + "0xf4ac25486bc87a53657408cac395c9a13b30cef62416addbf9d5fddb42ffbfeb", + "0x533e2c7f972ee1bdd8626f9aac4bfb3e787d4a6c825c64e64329e72253b4d999", + "0xbc557a38c021854da14c864d8a612675692de555773b4f6f584a208db0946e6f", + "0xa7881a3153361de44ef539fff5315a464cb160cd0a73bf8db168d90af45d8d74", + "0x2fb599c492cfabf47640b63933b28995b0dd9d24c707b037db861b4bda99e3d0", + "0x8a9f8746387cd1d719c52f955a938b7e888ad62dbf864cc0a28347dbd84eab8c" + ] + }, + "0xA538311df7DC52bBE861F6e3EfDD749730503Cae": { + "index": 93, + "amount": "0x01", + "proof": [ + "0xe9de40d0e5d5c822988c219033f34e5f2947ca246b15aad8c7c473a40bedad12", + "0xfb5dcfb1813fc967fec15d9432fc150a353ddd23659a52eed4f69a07921f5028", + "0x89364a4d28977c6e2f307f26e4ca5c8c7a1a542d63e6970a21e1bae21cbd11fe", + "0xf63cfa68f62fc044d5f3ee9a8c1d2f2a23da53f29485a55be519052c617003a7", + "0x639591b737c65a392edb3f7a8be50407ba55cc8551a7a3d638e48b7865853ab0", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xA639583dbeE6f945c57492c63D8aEac64bD168d2": { + "index": 94, + "amount": "0x01", + "proof": [ + "0xab1af7d0c652a7d9dc9245ad1b63cde8d72311dd6f399c86f4122431bfa40775", + "0xeda92cd8d0674071678d96ce62823bf9f674c199932afcf5a49701ba5ec61d03", + "0x2d73ef59c8b434636958c61870d49afb92f00b7c516594a25165c7c8e7627fab", + "0xfdec23d47a2988a8df7640a4615e4245f7bcbe625eeb89b59939f558cf3bde59", + "0x0c72dfa360ac239440f62348d8c138293533cc729f1d0ba3c6fe11634a6f7729", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xA92BE7F728Ef585851212b1cEB318B8A2fBacc96": { + "index": 95, + "amount": "0x01", + "proof": [ + "0xeee3c04b4088c79da24635817136702fb722ebc484c46ab6069ee432139ab484", + "0x11403e4f9351fafea54407296d1a72845034a8b52ff0dad0ad8048def2b8651d", + "0xcdb54601f2ca0a400cc657b0227777d405206c3131d688c0124c252369c80301", + "0x5216d1b0bee3076cf71d2cc80c70d66628ddeb0c500d173c873e9ca804ddce21", + "0x2fb599c492cfabf47640b63933b28995b0dd9d24c707b037db861b4bda99e3d0", + "0x8a9f8746387cd1d719c52f955a938b7e888ad62dbf864cc0a28347dbd84eab8c" + ] + }, + "0xB3915599BD061D01A67C79d5E5372C2d288eDbEe": { + "index": 96, + "amount": "0x01", + "proof": [ + "0x803d7ee2efac2f6f0ea2dc3602b42e32260ecdbdbdeec2273b28456cc282e148", + "0xb6bbd35b7fe9d4d2abbd59de51cdd915234f2c5691072599e61ecb6c3813704f", + "0x94fa9e8fa4365ba5fcd407aec6841ab80c846875955560b04b6f95082a1a3b2e", + "0x5a944baed22990b8e21cf58278da897e30ef6fc2921c804225dd11ec2ee21520", + "0xd75e5fa046a5b39a159c7f7713289fe87705858151008f31dced2f8ee56b5c3c", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xBCD57B9228Fe1D358A46FaF20dE8Be83bC6Bf2DB": { + "index": 97, + "amount": "0x03", + "proof": [ + "0xa1e89e472de9f88b27e7b4af90de7bdd3b540367bebf745a543454d6fed68ba9", + "0x7e0af3728ce6a736f58203eeee92b66add38972b04fba1b5bf7969d446958183", + "0xcf5d665603ed44efb72330584aba585cae4f0f8a3230d096e82af628e53626f9", + "0xfdec23d47a2988a8df7640a4615e4245f7bcbe625eeb89b59939f558cf3bde59", + "0x0c72dfa360ac239440f62348d8c138293533cc729f1d0ba3c6fe11634a6f7729", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xC0D7050BA38319Affdac5ca22c4aafB5a36a98c9": { + "index": 98, + "amount": "0x01", + "proof": [ + "0xc4590bf3d1949a86bdbe3c4037321fe830d06159b92f285a743fa3973102e4a3", + "0x7e72cb692fd9ffd51d7d2ade2b9070801a4c14d814c40f576d4a4732d568c7dd", + "0x0d7f284d0a7106548f749450cd4cc64b69359fa1e8ffd3ffded6c5d2633b7c8c", + "0x6f45a04a87f1b905ded26d8cc81b8e2911ec5dc43d21ce9b5ddd70f9415e0681", + "0x6da7908e73d9f24053173ebb3f96a1f75b07f788134614128d97f72ed17dc046", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xC363Fea8f6ac0b4D5a071291105fE9b41194964B": { + "index": 99, + "amount": "0x01", + "proof": [ + "0x43f528391da71eebe58e7613ea36dc76f1e1f3a69f375dff72884cfb9b10cd3a", + "0xdca56f83739bc0fc76c6148b5659bd85119d19b36bb73465537c76cb64e55cdf", + "0x3e246c533c956ec897a458a019f8a18193cc6c38efa9ad198798b5a0d867fdef", + "0xdfbc762d844655a02f4c4a2e54aa70ab4f1f442539d1904b1393a9201f1b0183", + "0xb0d931443cc2b12d482c98645d2953f321e6bba9c885e4b9b6f8a6cb3410e190", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xC54bD1f466f2F4F36dE59F4024e86885386d6f1b": { + "index": 100, + "amount": "0x01", + "proof": [ + "0x66aec8709f71514d4c3e7704456e026652cdc6a62efdc07b61ed0d5cc1e10d9e", + "0x129938e81d74039637415b8fd664e8fdcb2a4ec52a303c63e61e4019c86d0d6d", + "0xcaa8359951a076396426fe0bae0dc6e891ce555235907dd3884d2bad35600e82", + "0xee65780562aa1c820d5b1cd70b8768d759b6831a97103be7e28044256fcc4257", + "0x53603755304d04a9224a8e709ce2bc8dd412e06a4cbb83727793a9881e556a5b", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xC6D4E5C1cd5c2142C4592bBf66766e0f5f588d84": { + "index": 101, + "amount": "0x01", + "proof": [ + "0x6a77407d07e9100f0fd8bf65916f9a4a174e69d90d390718c4600411290d4e17", + "0x129938e81d74039637415b8fd664e8fdcb2a4ec52a303c63e61e4019c86d0d6d", + "0xcaa8359951a076396426fe0bae0dc6e891ce555235907dd3884d2bad35600e82", + "0xee65780562aa1c820d5b1cd70b8768d759b6831a97103be7e28044256fcc4257", + "0x53603755304d04a9224a8e709ce2bc8dd412e06a4cbb83727793a9881e556a5b", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xC9848f9146a56b6B5676B06f454a62A06A66Cc03": { + "index": 102, + "amount": "0x01", + "proof": [ + "0xa992872606b28751efb3cb5864003d4c2bb310c4d441bd61196bec5bf3129d3a", + "0xbfbadacf0ee246b4db9a66fb211ecd6a09053d48a1e9800e54b983cbf72dc0fe", + "0x2d73ef59c8b434636958c61870d49afb92f00b7c516594a25165c7c8e7627fab", + "0xfdec23d47a2988a8df7640a4615e4245f7bcbe625eeb89b59939f558cf3bde59", + "0x0c72dfa360ac239440f62348d8c138293533cc729f1d0ba3c6fe11634a6f7729", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xCDe0C4E5C2C3A85BC822538348FF96Ae28BE5BF8": { + "index": 103, + "amount": "0x01", + "proof": [ + "0x2bab13b68cc791156a36c60c87c5588d93e053296d6aac7dd940283d7cb3a908", + "0x65995fe1ea25c05d84a8a70008542635cfa0c68da6a5d705c0bb4f45198701c6", + "0x8b464f63d43336259b3582e0657654cec480e52339bb22514ec623408c946eca", + "0xbc4a511e020853ee2178b38f1763ed063614c33685d3ca4c1aa44cc2404d1b51", + "0xbe57b1104fa15c6024916d7f103143f08a337bd1f86e87bbc441cf6384c2c0dc", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xCab532dD7A22784AFbfed080705f377e20b647E8": { + "index": 104, + "amount": "0x01", + "proof": [ + "0xacbd24b6895ebf5175a9bec438a1fa7e2d83485612dfafc0ba4718a4d3b343b1", + "0x5f38da9e914f5d9bbf0bd66dd0020c0257238af63edbe7fc127bc5311c76a5d6", + "0x3bea0db679a50cbfa728790d3c9989c52f9d4be82f44db6f8904aabc1de5fe8b", + "0x76fa309cc3308a6a1b68c368dc64127791cc20f02aec2f04048bdcd24ac89108", + "0x6da7908e73d9f24053173ebb3f96a1f75b07f788134614128d97f72ed17dc046", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xCd0D4CDb238Eec15Fcf4ff9d13d5a59051E507D7": { + "index": 105, + "amount": "0x01", + "proof": [ + "0x76728d2293d1682fb98c0f68359efb839a0595fddc7a5faef4221e8da9ec7181", + "0x33310bce293eb1df1299a7cb92e877934aa22fd5266a4c7e1ee40fdf35fb77b4", + "0x81f53032d8e6411fbdd1cc3a0b7a0bcb13f5315fa7ffac066632e728fda36338", + "0xd86e9605374e6a7d4814dd6573551efb05032e760f43248939b5b489ee66277b", + "0xd75e5fa046a5b39a159c7f7713289fe87705858151008f31dced2f8ee56b5c3c", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xCef3fe4013A08545A753af1DE45b5e965ca622fc": { + "index": 106, + "amount": "0x01", + "proof": [ + "0xadbfc9afc45ca23935dcfa5277df866647a56367d1c27420d88ce5e4fc3f6e44", + "0x5f38da9e914f5d9bbf0bd66dd0020c0257238af63edbe7fc127bc5311c76a5d6", + "0x3bea0db679a50cbfa728790d3c9989c52f9d4be82f44db6f8904aabc1de5fe8b", + "0x76fa309cc3308a6a1b68c368dc64127791cc20f02aec2f04048bdcd24ac89108", + "0x6da7908e73d9f24053173ebb3f96a1f75b07f788134614128d97f72ed17dc046", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xCf50fB42926b255747fb8b0EA8E26D4e66952CA4": { + "index": 107, + "amount": "0x01", + "proof": [ + "0x3a6c54cf52c4ed89402c7066f86296a03aa4ecf4e61bbb6d07440d295864cac2", + "0xf2089ed072dbf4f53cd8cda4c533f986ed5101318d3db8f43f30403a58d78974", + "0x3b0d6434b14f9799a303699a10eb258bc9481aea1ae11a249837d336bb687d72", + "0xb4711eda6a872fd3af62c107a195616009ccf580b231b50f957f8392cc0ad232", + "0xbe57b1104fa15c6024916d7f103143f08a337bd1f86e87bbc441cf6384c2c0dc", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xCfc7D04AD2Bd4524D01d1d0b3dd9BA885164c63E": { + "index": 108, + "amount": "0x01", + "proof": [ + "0xbac5b80ec0d4a058373cbcb532dad632939b4fb7a648c264488956ba87ce21cd", + "0xf3a245057fd682b637851dcfaa44348dfc7da720de0babcebe15e77e4acd8708", + "0xd5d407b11e1a40db7053386673dfddc66a7504fdb743516879cafdbcecea772f", + "0x76fa309cc3308a6a1b68c368dc64127791cc20f02aec2f04048bdcd24ac89108", + "0x6da7908e73d9f24053173ebb3f96a1f75b07f788134614128d97f72ed17dc046", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xD0F0b33573950C4fd9faD0Fc04B321996F958Dd6": { + "index": 109, + "amount": "0x01", + "proof": [ + "0x1a812c8ab89630f856579906e3e7687d6259ee0eb0f13567499aa2b1e2e0d00c", + "0x685ca8dd70a455b78722d15d04239ebee054f9743c3848586c13457fbb2a1ea1", + "0xbd5af09c424a97f6d726c08bdcda0f57bbb412158792024e68c9874f49e00d7c", + "0xf4c2497eedcf38142d0d50ca185254f5a051a3ba6184b121326e7c3b36029eaf", + "0xd27a7356541e491e70e040dfd164006df8e22100461d2a1a348411305d7b4bd1", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xD18001F022154654149ed45888C9c29Def6d3CE6": { + "index": 110, + "amount": "0x01", + "proof": [ + "0x9b760051410fe20798afe044f44d4f44fdd7b165d0e92328254811cfa7a62c95", + "0x17c196030d4108b2abacb323fa67c34d735d5165ba48a2f79a030c1371b787d0", + "0x615c4f9260b4f01ff05147dfaad31b595addb465ed0d3af829d21774fb19bb13", + "0x8100df3417a3c454a86f42d81ed5a1a9138e76181b3d04ebdc19d8c3dcc3d68b", + "0x0c72dfa360ac239440f62348d8c138293533cc729f1d0ba3c6fe11634a6f7729", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xD3474BD2f558B12e83810EC7d8aF14f2d1D08137": { + "index": 111, + "amount": "0x01", + "proof": [ + "0xa759a376ff9821921c1a608eb0b0d7dae4da9bbe6ef23124ca40d8ea6b6f4f1a", + "0x7e0af3728ce6a736f58203eeee92b66add38972b04fba1b5bf7969d446958183", + "0xcf5d665603ed44efb72330584aba585cae4f0f8a3230d096e82af628e53626f9", + "0xfdec23d47a2988a8df7640a4615e4245f7bcbe625eeb89b59939f558cf3bde59", + "0x0c72dfa360ac239440f62348d8c138293533cc729f1d0ba3c6fe11634a6f7729", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xD6AB3210442765D0BD806Db6643Da28d307eb422": { + "index": 112, + "amount": "0x01", + "proof": [ + "0x5e934e69a75465b94b54aef45ecfe3fe8379286ec8d8658fb787b1124aa8df55", + "0x3cbe1c7570b561d572c826722149100fe22e1c38643f7ea8770fe57066e3f57d", + "0x93ace1dc79c2bdf39b5620fe288675192e9e8bea130393c6c99f1eae23603cd6", + "0x4c62c1758dacf4387d8b03b08f77c5d8366ec9cfdfdb0de537340f8ca90b5ec8", + "0x53603755304d04a9224a8e709ce2bc8dd412e06a4cbb83727793a9881e556a5b", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xD75D580bE38DbDAF64Bd9a725e80A7e154612F62": { + "index": 113, + "amount": "0x01", + "proof": [ + "0x5a9d562a7bb9283bc2d9e64223a3c1f9c9a9b1b8023c68f15bba347d3ba352da", + "0xa4824f7bc0708f7fb481ba1e32bf44f8293877f2efdf973d1e6fa3d76826db5c", + "0x93ace1dc79c2bdf39b5620fe288675192e9e8bea130393c6c99f1eae23603cd6", + "0x4c62c1758dacf4387d8b03b08f77c5d8366ec9cfdfdb0de537340f8ca90b5ec8", + "0x53603755304d04a9224a8e709ce2bc8dd412e06a4cbb83727793a9881e556a5b", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xDFedDc98ae6eDcb5F63178A8589f41B6477F6C42": { + "index": 114, + "amount": "0x01", + "proof": [ + "0xf46827929158b39b9c1f8d641256cf86b6251577690f32db5884a68cc6828ad2", + "0xe4571e4963e85765e5f11de8db697fab75815154ad9a2301cd4c01d530bdd659", + "0xbc557a38c021854da14c864d8a612675692de555773b4f6f584a208db0946e6f", + "0xa7881a3153361de44ef539fff5315a464cb160cd0a73bf8db168d90af45d8d74", + "0x2fb599c492cfabf47640b63933b28995b0dd9d24c707b037db861b4bda99e3d0", + "0x8a9f8746387cd1d719c52f955a938b7e888ad62dbf864cc0a28347dbd84eab8c" + ] + }, + "0xE3939654Deae5f54fD3e6B84b3A7F75f245062d8": { + "index": 115, + "amount": "0x01", + "proof": [ + "0x434d3f3b2d122b1ce406cb7b9b898de2f4fde64b47d7fb562c01b7955a7d7c11", + "0xdca56f83739bc0fc76c6148b5659bd85119d19b36bb73465537c76cb64e55cdf", + "0x3e246c533c956ec897a458a019f8a18193cc6c38efa9ad198798b5a0d867fdef", + "0xdfbc762d844655a02f4c4a2e54aa70ab4f1f442539d1904b1393a9201f1b0183", + "0xb0d931443cc2b12d482c98645d2953f321e6bba9c885e4b9b6f8a6cb3410e190", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xE3D47BeCcb31D105C149B37A9486d945Cca1E469": { + "index": 116, + "amount": "0x01", + "proof": [ + "0x6b7143770703562511dbdb121b0837d628cb19c59131e8c4fb24171850a8b2d4", + "0xfd1769b2bd0778cfae755b2a90c3952c70786ff5882b705479474fa5eafbec5e", + "0x2d81bdcabd0a9e4803cbf01cb1586d253a61dc351e69add58de9d437e61bc4ba", + "0xee65780562aa1c820d5b1cd70b8768d759b6831a97103be7e28044256fcc4257", + "0x53603755304d04a9224a8e709ce2bc8dd412e06a4cbb83727793a9881e556a5b", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xE52eF21875615682dc5Fa75D6a33a546e200f5f6": { + "index": 117, + "amount": "0x01", + "proof": [ + "0x457686ebee97f221ed6b01c97ea8f18ecf7220eb92a8c4d997dea68651c524c2", + "0x011309a1a07282d1823d3a763a7ace772e3b6bbeb9c9385325018944cb1b9256", + "0x5278fa3e1d6a528e7bda38f332d996584dba533e08c2b62fd6b06daf5cb50463", + "0xdfbc762d844655a02f4c4a2e54aa70ab4f1f442539d1904b1393a9201f1b0183", + "0xb0d931443cc2b12d482c98645d2953f321e6bba9c885e4b9b6f8a6cb3410e190", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xE65cEE7B4C759bC1857414557b232884e7412EBE": { + "index": 118, + "amount": "0x01", + "proof": [ + "0xbe3bc9357c98ff55f8682a587eeb9b4ac302a3ed856372e2ba911f2cf50293b9", + "0xf3a245057fd682b637851dcfaa44348dfc7da720de0babcebe15e77e4acd8708", + "0xd5d407b11e1a40db7053386673dfddc66a7504fdb743516879cafdbcecea772f", + "0x76fa309cc3308a6a1b68c368dc64127791cc20f02aec2f04048bdcd24ac89108", + "0x6da7908e73d9f24053173ebb3f96a1f75b07f788134614128d97f72ed17dc046", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xE7Ed7b3bd702E0D7cb9c56ebAf8a2FdeaF18F100": { + "index": 119, + "amount": "0x01", + "proof": [ + "0x5ecce18e353e879e922c5fd4bd5a3f01069eb15c7d9b3e2cdde84c61738bfe5e", + "0x3cbe1c7570b561d572c826722149100fe22e1c38643f7ea8770fe57066e3f57d", + "0x93ace1dc79c2bdf39b5620fe288675192e9e8bea130393c6c99f1eae23603cd6", + "0x4c62c1758dacf4387d8b03b08f77c5d8366ec9cfdfdb0de537340f8ca90b5ec8", + "0x53603755304d04a9224a8e709ce2bc8dd412e06a4cbb83727793a9881e556a5b", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xEF7CD78bdF7cE6E3903572E3d584839643df2f0a": { + "index": 120, + "amount": "0x01", + "proof": [ + "0x86acf901c92cabbb908ec9de96b331bc2bf326dbaafe5af2d862476c313ce809", + "0x59a284f9c8047275a272df686fd48936d0983dd60f30ee3daf8b71f38a9025fe", + "0xd767f3a32e0f77b4930165e6157d655a7ab7c488ef813f8552aa28fc0a2f878c", + "0x5a944baed22990b8e21cf58278da897e30ef6fc2921c804225dd11ec2ee21520", + "0xd75e5fa046a5b39a159c7f7713289fe87705858151008f31dced2f8ee56b5c3c", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xEcB50F1F8098F3D62FB5d8A1fE0fe8b5def621Fa": { + "index": 121, + "amount": "0x01", + "proof": [ + "0x3b390e550997c31776b79fa296970ffb3f624ae1bb2bd890cf191522790c2043", + "0x745adce7655a25f394c12d88c882b8b4c3997997b44931fab273afde393d721a", + "0x58c430d302de98f4e7cb5243208be576affa2259142537b31872f6d2895823ef", + "0xb4711eda6a872fd3af62c107a195616009ccf580b231b50f957f8392cc0ad232", + "0xbe57b1104fa15c6024916d7f103143f08a337bd1f86e87bbc441cf6384c2c0dc", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xF00Bf178E3372C4eF6E15A1676fd770DAD2aDdfB": { + "index": 122, + "amount": "0x01", + "proof": [ + "0xd7236812c9489dcc2cdc51be6a5eb6a32c6bd7bf88117a6990b2645b57ece35e", + "0xbbd9bd000946f267803674e8c793de16ec387cadf37dfb40cfeb3829224b9905", + "0x5b4ef21840313a74dd07ab6b62e2d62dc79b3bc521345abba0167941286c5db6", + "0xf63cfa68f62fc044d5f3ee9a8c1d2f2a23da53f29485a55be519052c617003a7", + "0x639591b737c65a392edb3f7a8be50407ba55cc8551a7a3d638e48b7865853ab0", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xF7B18e107eb36797f4cE36dE756630B9C30969ad": { + "index": 123, + "amount": "0x01", + "proof": [ + "0xa86e83cc9d6da4a59b0cbcf3d8202c2f0b88eeedb73e8e1ce604ecb3c511651f", + "0xbfbadacf0ee246b4db9a66fb211ecd6a09053d48a1e9800e54b983cbf72dc0fe", + "0x2d73ef59c8b434636958c61870d49afb92f00b7c516594a25165c7c8e7627fab", + "0xfdec23d47a2988a8df7640a4615e4245f7bcbe625eeb89b59939f558cf3bde59", + "0x0c72dfa360ac239440f62348d8c138293533cc729f1d0ba3c6fe11634a6f7729", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xF8decCaF8f60a0F64AF61da2A87Fd2c6c07426F8": { + "index": 124, + "amount": "0x01", + "proof": [ + "0x398a68768bc30a43cf05edf67db6a60b721777782975f790e408e6db825a74a5", + "0xf2089ed072dbf4f53cd8cda4c533f986ed5101318d3db8f43f30403a58d78974", + "0x3b0d6434b14f9799a303699a10eb258bc9481aea1ae11a249837d336bb687d72", + "0xb4711eda6a872fd3af62c107a195616009ccf580b231b50f957f8392cc0ad232", + "0xbe57b1104fa15c6024916d7f103143f08a337bd1f86e87bbc441cf6384c2c0dc", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xFFD2DF7Ba9A04672933748dc86ce71F131ff4D50": { + "index": 125, + "amount": "0x0a", + "proof": [ + "0xb8bea2ab9362afe72474f67d0e0129846f13c994aa9df7517e087d671609bbfc", + "0x29698637a1f92a697b01426163ea13799a7eebe7a042b0c6f910602b3955476b", + "0xd5d407b11e1a40db7053386673dfddc66a7504fdb743516879cafdbcecea772f", + "0x76fa309cc3308a6a1b68c368dc64127791cc20f02aec2f04048bdcd24ac89108", + "0x6da7908e73d9f24053173ebb3f96a1f75b07f788134614128d97f72ed17dc046", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xa1Ae13999DF5740B709af82A727980C113A2527f": { + "index": 126, + "amount": "0x01", + "proof": [ + "0xf00a1788054dacf3631d1e2389ff244b13cc95478a56007667c134fea7173b00", + "0x5cc94f5e5a3e108fe6b6d762f15b0b9e3688dd4354f982f4227ce5530fbfc2bc", + "0xcdb54601f2ca0a400cc657b0227777d405206c3131d688c0124c252369c80301", + "0x5216d1b0bee3076cf71d2cc80c70d66628ddeb0c500d173c873e9ca804ddce21", + "0x2fb599c492cfabf47640b63933b28995b0dd9d24c707b037db861b4bda99e3d0", + "0x8a9f8746387cd1d719c52f955a938b7e888ad62dbf864cc0a28347dbd84eab8c" + ] + }, + "0xa6b6fB6a424f4d107fbdd6F3BCA610B568cCB2EA": { + "index": 127, + "amount": "0x01", + "proof": [ + "0xf13c103bdbf37a4a6bc54836474b7ee56f9e1db719ffef43075ba29f6ea74600", + "0x5cc94f5e5a3e108fe6b6d762f15b0b9e3688dd4354f982f4227ce5530fbfc2bc", + "0xcdb54601f2ca0a400cc657b0227777d405206c3131d688c0124c252369c80301", + "0x5216d1b0bee3076cf71d2cc80c70d66628ddeb0c500d173c873e9ca804ddce21", + "0x2fb599c492cfabf47640b63933b28995b0dd9d24c707b037db861b4bda99e3d0", + "0x8a9f8746387cd1d719c52f955a938b7e888ad62dbf864cc0a28347dbd84eab8c" + ] + }, + "0xb71D05cF5CdF7a9B15B20b9aaB5E91332C271c96": { + "index": 128, + "amount": "0x01", + "proof": [ + "0xe8b3c7eec1a0012625f91e7cdbcd7a4b1eb044369319cee345616a7b60177d1c", + "0xfb5dcfb1813fc967fec15d9432fc150a353ddd23659a52eed4f69a07921f5028", + "0x89364a4d28977c6e2f307f26e4ca5c8c7a1a542d63e6970a21e1bae21cbd11fe", + "0xf63cfa68f62fc044d5f3ee9a8c1d2f2a23da53f29485a55be519052c617003a7", + "0x639591b737c65a392edb3f7a8be50407ba55cc8551a7a3d638e48b7865853ab0", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xb989C3717405569398750983aD5934308759287e": { + "index": 129, + "amount": "0x01", + "proof": [ + "0x2a2a3fdc13fe8b0b9228dbe0f3cdeb0a584eb56788c6e41a49727aca83158e9d", + "0x2bc043dfeee3f04f74a1e43de01191f7fc248170c080646bf23b7f838d9d07b1", + "0x8b464f63d43336259b3582e0657654cec480e52339bb22514ec623408c946eca", + "0xbc4a511e020853ee2178b38f1763ed063614c33685d3ca4c1aa44cc2404d1b51", + "0xbe57b1104fa15c6024916d7f103143f08a337bd1f86e87bbc441cf6384c2c0dc", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xbBcE15Ee9bdE24B77031ed6a82e9DD9B6C7492dC": { + "index": 130, + "amount": "0x01", + "proof": [ + "0xa1674c6420f7cd3789775ee6085046cd80b48548e1b7458268c4eb2cd9c19a32", + "0x9b41f24a61f733d007c82c432d3b45cec9e28c78dae890459cfe92c6920b55aa", + "0xcf5d665603ed44efb72330584aba585cae4f0f8a3230d096e82af628e53626f9", + "0xfdec23d47a2988a8df7640a4615e4245f7bcbe625eeb89b59939f558cf3bde59", + "0x0c72dfa360ac239440f62348d8c138293533cc729f1d0ba3c6fe11634a6f7729", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xbEc7B649FF1b72Ce87acD470da0036A0BEC6453B": { + "index": 131, + "amount": "0x01", + "proof": [ + "0x8ee4565573c554857a23346958b4370c153e6e1314372ed48277123fa1c470f5", + "0x72682a4f96764b1a0ec8cf6889a44540a5614e197ba204b77f4521357a15c160", + "0x967653830cb7587ccce3a695e55866f8f6ff9a6395e61064c9a5887effcfcb55", + "0x8100df3417a3c454a86f42d81ed5a1a9138e76181b3d04ebdc19d8c3dcc3d68b", + "0x0c72dfa360ac239440f62348d8c138293533cc729f1d0ba3c6fe11634a6f7729", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xc140AAD62f73C19764205815E6B564CF6e9504Bf": { + "index": 132, + "amount": "0x01", + "proof": [ + "0xbaae58712ed40ff17d11bdc300285f38f7771a39c606daa7c8e5a07839331311", + "0x29698637a1f92a697b01426163ea13799a7eebe7a042b0c6f910602b3955476b", + "0xd5d407b11e1a40db7053386673dfddc66a7504fdb743516879cafdbcecea772f", + "0x76fa309cc3308a6a1b68c368dc64127791cc20f02aec2f04048bdcd24ac89108", + "0x6da7908e73d9f24053173ebb3f96a1f75b07f788134614128d97f72ed17dc046", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xc219CafDE6855f60dA76d9cacC3873fda65516E6": { + "index": 133, + "amount": "0x01", + "proof": [ + "0xeee5edddb59e71fea942df935626466c1133e0b9e5f1acecfdb3d79f9720ac64", + "0x11403e4f9351fafea54407296d1a72845034a8b52ff0dad0ad8048def2b8651d", + "0xcdb54601f2ca0a400cc657b0227777d405206c3131d688c0124c252369c80301", + "0x5216d1b0bee3076cf71d2cc80c70d66628ddeb0c500d173c873e9ca804ddce21", + "0x2fb599c492cfabf47640b63933b28995b0dd9d24c707b037db861b4bda99e3d0", + "0x8a9f8746387cd1d719c52f955a938b7e888ad62dbf864cc0a28347dbd84eab8c" + ] + }, + "0xc315155D817140250D238F140142a10b69Fa1c4e": { + "index": 134, + "amount": "0x01", + "proof": [ + "0xa0ace4ce5459b0315e09020b3801d709cbf8020fa2c0c7724663c92bd1828a37", + "0x9b41f24a61f733d007c82c432d3b45cec9e28c78dae890459cfe92c6920b55aa", + "0xcf5d665603ed44efb72330584aba585cae4f0f8a3230d096e82af628e53626f9", + "0xfdec23d47a2988a8df7640a4615e4245f7bcbe625eeb89b59939f558cf3bde59", + "0x0c72dfa360ac239440f62348d8c138293533cc729f1d0ba3c6fe11634a6f7729", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xc579047Ca63eB74646e3e798575c70Cc57A6EA02": { + "index": 135, + "amount": "0x15", + "proof": [ + "0xea7d657051dbb3c4d1ac1a8ec0615bd5115c7b08d627274756289d59afbda516", + "0x3e60fdbe1c5675dc5f9507a5ad037ef3e1d9598e58cb61c3648042ca6f5fcfab", + "0x0300d57531ed3de4dbabbd7127000254fbe4bfbc2dda958b72b566840b715651", + "0x5216d1b0bee3076cf71d2cc80c70d66628ddeb0c500d173c873e9ca804ddce21", + "0x2fb599c492cfabf47640b63933b28995b0dd9d24c707b037db861b4bda99e3d0", + "0x8a9f8746387cd1d719c52f955a938b7e888ad62dbf864cc0a28347dbd84eab8c" + ] + }, + "0xd7Ddf70125342f44E65ccbafAe5135F2bB6526bB": { + "index": 136, + "amount": "0x01", + "proof": [ + "0x15739f87e56ed2c14f885ea93929f26322b0be7663c4f234f73429ac76bd5889", + "0xfd95d4438c06627d4aa5d8fba0ca0b59b0152f4aa8f695151ed2de667ec1087c", + "0x81a0fd1941b47d83a67c83d06df3139bbc20746761bb0a50c7e4681716a03c28", + "0x6c5886f920bb55f50a31ed3f4a69ec1efbb1c9d260336cc5f170b526f5759fbd", + "0xd27a7356541e491e70e040dfd164006df8e22100461d2a1a348411305d7b4bd1", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xe1D29d0a39962a9a8d2A297ebe82e166F8b8EC18": { + "index": 137, + "amount": "0x01", + "proof": [ + "0x4bafb319a287365e4f9fc2a5e89b4f8b646faaf4edd3711ac95b0dfbe8c3374a", + "0x0ac60961c502e3ee7c43927faba20bca1de95d6d8988f23a2ffacbb6f1e5858e", + "0x4ac7402f21fe8901d75d40f5aed1b36d3621bc7e4e1afccd6483996c7a78d98d", + "0xa3a5bc515aec1ddfe0097cb857bb0dc9eb0285104af5c61120fc791ec6075419", + "0xb0d931443cc2b12d482c98645d2953f321e6bba9c885e4b9b6f8a6cb3410e190", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xe7A0bAcbC114Bb2f861Dfce5FF11a3560b7014e1": { + "index": 138, + "amount": "0x01", + "proof": [ + "0x18435e12ca72dcfcb946d248efa336fa46e4d00fb0a098a61f0b51f6b4fc8f30", + "0xbb31272d5a37e4ea25aa8bf5bee6e93f9ed09f91e99b9260572ba1fabb2ed7fe", + "0xbd5af09c424a97f6d726c08bdcda0f57bbb412158792024e68c9874f49e00d7c", + "0xf4c2497eedcf38142d0d50ca185254f5a051a3ba6184b121326e7c3b36029eaf", + "0xd27a7356541e491e70e040dfd164006df8e22100461d2a1a348411305d7b4bd1", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xe9017c8De5040968D9752A18d805cD2A983E558c": { + "index": 139, + "amount": "0x01", + "proof": [ + "0xd42687804f06d84a779e1ca0e14c322cec5d9184ca232bf0dc31921822eea5d3", + "0x3989bc418fabf027e136cd60a9c1b08ce04cfc101a1e761149745a57c3360622", + "0x8af93c64e19d0e90276afd05a9af3d42ecefff8601f7db57dc58c28985082484", + "0x73def4e56a6689530d5ef5e845e927f0a9f9d8f7ee2748be7b25b5d06e811c94", + "0x639591b737c65a392edb3f7a8be50407ba55cc8551a7a3d638e48b7865853ab0", + "0xeeb5bbd0f5cba10215ade031786b54388217969e9d1d089ba64cb9b0718cb251", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xeD2C2CdEc695be3A4Dc421c1A8a6756dc5A927b6": { + "index": 140, + "amount": "0x01", + "proof": [ + "0x82e740b4ca147ba3422dd8dce1bb1fbd214323408b1b957ac3cc3700cb4347de", + "0x6b2894f5d15c2eb869bb8d4c22fd8a7d592083538332d22e1d5f1d8b6feaa36b", + "0x94fa9e8fa4365ba5fcd407aec6841ab80c846875955560b04b6f95082a1a3b2e", + "0x5a944baed22990b8e21cf58278da897e30ef6fc2921c804225dd11ec2ee21520", + "0xd75e5fa046a5b39a159c7f7713289fe87705858151008f31dced2f8ee56b5c3c", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xec142e3590aCff7204852c7F2F336DD1Aa3616E4": { + "index": 141, + "amount": "0x01", + "proof": [ + "0x56589ab6a5b80034c046baccd5f18a005b1157da5d2220636921bba761eb4b24", + "0xdebeeb2558c065cf158b24dd9037ef563cb56dce0f67141ccc79b4fb8d3513f7", + "0x05587dbe5f3fc1e7b5acdb230c8eef57f92b43a387ea89f8e4944a2d584a00e7", + "0xa3a5bc515aec1ddfe0097cb857bb0dc9eb0285104af5c61120fc791ec6075419", + "0xb0d931443cc2b12d482c98645d2953f321e6bba9c885e4b9b6f8a6cb3410e190", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xf208f126FfcF2F40C91f92eaB8D05844434a309C": { + "index": 142, + "amount": "0x01", + "proof": [ + "0x958ec68659f734a90e72adabecb46629558af516e7457f74c9db60ab45c3e24c", + "0x7d8b245ad7dec545ff030e347cb319b05bc0cea79c26813f6641dc70395e360f", + "0x967653830cb7587ccce3a695e55866f8f6ff9a6395e61064c9a5887effcfcb55", + "0x8100df3417a3c454a86f42d81ed5a1a9138e76181b3d04ebdc19d8c3dcc3d68b", + "0x0c72dfa360ac239440f62348d8c138293533cc729f1d0ba3c6fe11634a6f7729", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xf53cAB0C6F25f48F985d1e2c40E03FC7C1963364": { + "index": 143, + "amount": "0x01", + "proof": [ + "0x2b6d2530b9ed90f0d0c718ab42f5d6abcffbb6b61b62c8d1133d70cfc1fedf0b", + "0x65995fe1ea25c05d84a8a70008542635cfa0c68da6a5d705c0bb4f45198701c6", + "0x8b464f63d43336259b3582e0657654cec480e52339bb22514ec623408c946eca", + "0xbc4a511e020853ee2178b38f1763ed063614c33685d3ca4c1aa44cc2404d1b51", + "0xbe57b1104fa15c6024916d7f103143f08a337bd1f86e87bbc441cf6384c2c0dc", + "0x0b55b8f3fac628336faa043ef0e2c96d9c9a0db41b02b0c3543d26c1568d3185", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xf69EA6646cf682262E84cd7c67133eac59cef07b": { + "index": 144, + "amount": "0x02", + "proof": [ + "0x9b3a9ca25a1aab0534e0bb2f4bd0a8049682c7f4e03b5f05e5b628be1f7d24f3", + "0x23f06c974d7798ef4309719f0b6540d892ca110772c869ee61c6402d1a1ecf35", + "0x615c4f9260b4f01ff05147dfaad31b595addb465ed0d3af829d21774fb19bb13", + "0x8100df3417a3c454a86f42d81ed5a1a9138e76181b3d04ebdc19d8c3dcc3d68b", + "0x0c72dfa360ac239440f62348d8c138293533cc729f1d0ba3c6fe11634a6f7729", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xf74311d88F6724DbDdaa16D0f0516D3f6D954498": { + "index": 145, + "amount": "0x01", + "proof": [ + "0x73bbad22305b136831fbe2af259adf74368e237bf18b61ad766fbd5aff2fffb7", + "0x1b8941ff719058a5777ee1d51ec974a021465e6097d091e418eedda69cd01f83", + "0x81f53032d8e6411fbdd1cc3a0b7a0bcb13f5315fa7ffac066632e728fda36338", + "0xd86e9605374e6a7d4814dd6573551efb05032e760f43248939b5b489ee66277b", + "0xd75e5fa046a5b39a159c7f7713289fe87705858151008f31dced2f8ee56b5c3c", + "0xccac904d2ee04e983ffe38be3cfeffcc800d22288478de49daa8caf942558018", + "0xc8de241a8de3722fa09ad49a74474cd8a117d8690b5217115d1404e06de7e695", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + }, + "0xf7Eab72Ee14daD3DFEf597420F669c25B39f938C": { + "index": 146, + "amount": "0x01", + "proof": [ + "0x54436bdc9813f0377389db683807e69fcfd202415869dcf00e648cff00be38d3", + "0x07d230318ed277d599476c9c96fcc0d2fed30c809e281a49b7aa15c5417a88ad", + "0x4ac7402f21fe8901d75d40f5aed1b36d3621bc7e4e1afccd6483996c7a78d98d", + "0xa3a5bc515aec1ddfe0097cb857bb0dc9eb0285104af5c61120fc791ec6075419", + "0xb0d931443cc2b12d482c98645d2953f321e6bba9c885e4b9b6f8a6cb3410e190", + "0x08c63c40c3001c4e7f8eae50824ead67d374479e54d63af604eebdf23ba635ac", + "0xc54eef85f356cb007a4643cf7aa8c96c09a1d775b3380e5264621e43b9bc0b17", + "0x2d70b7b8f8dfb68bd59756dda503220dc73c9ccfc19dd655f351122e6ccef96f" + ] + } + } + }, + { + "merkleRoot": "0xc38b6ec672040da431d013990fa677dfc8494398731bed0701e7b88d085b533e", + "tierIndex": 3, + "tokenTotal": "0x64", + "claims": { + "0x032ade653b7D6AbE56De3D12E2a474b40FA31d89": { + "index": 0, + "amount": "0x01", + "proof": [ + "0xc8ff50d7c42417f7a5ef3026aafec0891921928ca104f2a0c294181e75fa7b8b", + "0xd483560cc8ca12d4b1aae888ab7da87f86142178783d41da7f325dade426dc62", + "0x9ab03a9b8cd0920640163093c95e34dc75d9e53faad37ab74ff2c0f2b88fd39c", + "0x99bd1cb49e60b5b689b521e432cf5d494c5148c1ffafa19d6162f55151423dcd", + "0x91222200ceb881bd06d4cac77e4a96a3b5de35c754203419d66c8e011950d974", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0x1f92DabE3Cfa2dB47666c57a3AE44d820cdEb225": { + "index": 1, + "amount": "0x01", + "proof": [ + "0x287f6ef020d7d85f60471135387160fe07368c2790bf05ac01999b1d38535b5d", + "0xc23cd7bd57b6f32ae82365e3cd045cf86996c7f361632b1447b541b322cca307", + "0x1219ca39ac97655cc13775f0a2b4c579a0fa79630397d15ecae2555fe00448c9", + "0x956734a9f94983d18e18286915cec0bcf12e16e7555951cf1c5056f5a631fe2e", + "0x81b8f6afd557fef18b5fc87033d15748d174f617ba5b90055faa135f645d6b61", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0x2EEcBa66581512087181895b0dE8d5FaA3Db21e5": { + "index": 2, + "amount": "0x01", + "proof": [ + "0x9974bff088d0f45831728aa051958e87fe40489ef7065f2041d6cacbf20d9031", + "0x925a98381f8154d8acabbb1439182afe03145ae221759759143512be57c0292d", + "0xcad7757a166e3244e6ee822988f561d4eb64a54e7bc96ade6e8b998c6b58b6f6", + "0x99bd1cb49e60b5b689b521e432cf5d494c5148c1ffafa19d6162f55151423dcd", + "0x91222200ceb881bd06d4cac77e4a96a3b5de35c754203419d66c8e011950d974", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0x38148eCC2078dA7f65E6233DDA28eFaf4C51E96F": { + "index": 3, + "amount": "0x01", + "proof": [ + "0xc5f1f929ca8ff2c7584d02c52d6f7eae923dfe99de487503522545ebac9db780", + "0x1587ec4d2a62476d41dbc846d8929ef84289c882806bceeacfac921512074d92", + "0x9ab03a9b8cd0920640163093c95e34dc75d9e53faad37ab74ff2c0f2b88fd39c", + "0x99bd1cb49e60b5b689b521e432cf5d494c5148c1ffafa19d6162f55151423dcd", + "0x91222200ceb881bd06d4cac77e4a96a3b5de35c754203419d66c8e011950d974", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0x391891Af67E29D97E61E30C3036a0874F5Da411e": { + "index": 4, + "amount": "0x0f", + "proof": [ + "0xfec5586a69cf3b927d686a23d344222024838e3fc1b632b1ce4a851f617020d7", + "0x267c55f7d7797778855208c196db6df8a5ff1d39df5fe4c6dd8924d2027ce813", + "0xf8aa23084f04066e7c070e436596d16503ca51db778229c552f2394fced35660" + ] + }, + "0x397eADFF98b18a0E8c1c1866b9e83aE887bAc1f1": { + "index": 5, + "amount": "0x01", + "proof": [ + "0x4b57630294b3ec5a168b59a26686d90ccd683461a39d98ef70aa1f1ffbcd2f91", + "0xac0c973bea4aa4fa6107e1ae8f2515d0168cab3e04971cf036e26fd8b36ec85a", + "0x8af56aa87161019efae0e96457b879fb5f18a126458353d4ada585b151affe1e", + "0x43f2012043a8c396d8f7ba351ba44dba34bd3dd551ec7d73ab76b3e4be758d43", + "0x91222200ceb881bd06d4cac77e4a96a3b5de35c754203419d66c8e011950d974", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0x42ea21d77813533667f7f0E40aF037183fAf8814": { + "index": 6, + "amount": "0x01", + "proof": [ + "0x6b9afbd25de205d8597bb2e3380ee1713625911b9861872a8b8765c2160d7c64", + "0x4137fd74e61d69e3a69bc0d4c833a0af23951e0895dd90385a823600efcda2ab", + "0x0b5556aa8574a1b33ac79fa947783dd475af7b109b6f1ad0b1e3f3be1e874fa3", + "0x43f2012043a8c396d8f7ba351ba44dba34bd3dd551ec7d73ab76b3e4be758d43", + "0x91222200ceb881bd06d4cac77e4a96a3b5de35c754203419d66c8e011950d974", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0x50F27CdB650879A41fb07038bF2B818845c20e17": { + "index": 7, + "amount": "0x08", + "proof": [ + "0x751c97f8995671228ac93ffd818446f12299ada00ed2e45e15e2cf778890e36f", + "0x4137fd74e61d69e3a69bc0d4c833a0af23951e0895dd90385a823600efcda2ab", + "0x0b5556aa8574a1b33ac79fa947783dd475af7b109b6f1ad0b1e3f3be1e874fa3", + "0x43f2012043a8c396d8f7ba351ba44dba34bd3dd551ec7d73ab76b3e4be758d43", + "0x91222200ceb881bd06d4cac77e4a96a3b5de35c754203419d66c8e011950d974", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0x5444C3377842568E5cCd77Df6F8b26C2c2eF3878": { + "index": 8, + "amount": "0x01", + "proof": [ + "0xc8d831abd2a94a6df9b9b9c4fe2407701b0c4d993f84a499edf739ed944e7bdf", + "0x1587ec4d2a62476d41dbc846d8929ef84289c882806bceeacfac921512074d92", + "0x9ab03a9b8cd0920640163093c95e34dc75d9e53faad37ab74ff2c0f2b88fd39c", + "0x99bd1cb49e60b5b689b521e432cf5d494c5148c1ffafa19d6162f55151423dcd", + "0x91222200ceb881bd06d4cac77e4a96a3b5de35c754203419d66c8e011950d974", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0x5477729b43A0A9beA8c41367C62e7864123B57d8": { + "index": 9, + "amount": "0x01", + "proof": [ + "0x01e1db3ba02349a25f6b900cc5bdf2347b9ccd7aef23051b3a0fabb165edf016", + "0xe9ac795a4968617e550162c93536b0448a9f38b6b67ba61a9550a223ff4657e8", + "0xb75ec1abcf5bee52467be878e8219bdff9ec8c3f3cca84a1842cb6bfc88c3a2d", + "0x956734a9f94983d18e18286915cec0bcf12e16e7555951cf1c5056f5a631fe2e", + "0x81b8f6afd557fef18b5fc87033d15748d174f617ba5b90055faa135f645d6b61", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0x57fcF904efC785e098676922d406e64A4e0e7ea2": { + "index": 10, + "amount": "0x16", + "proof": [ + "0x7f3027afe3a745c4aa5f38aad1e473aacb446b17b69a9a8a4b29c4a42f021a96", + "0x61e554607ee536c9591ada19ca9a03e6682b4b862b6558baef4a0627f2f7cc8d", + "0x0b5556aa8574a1b33ac79fa947783dd475af7b109b6f1ad0b1e3f3be1e874fa3", + "0x43f2012043a8c396d8f7ba351ba44dba34bd3dd551ec7d73ab76b3e4be758d43", + "0x91222200ceb881bd06d4cac77e4a96a3b5de35c754203419d66c8e011950d974", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0x5ACb790c82B19166b248E516A4f5E505306d4268": { + "index": 11, + "amount": "0x01", + "proof": [ + "0x4c0e52738f013c77100fb99eb6701abd1aae07d472b9585ed3c1da03d25833ae", + "0xac0c973bea4aa4fa6107e1ae8f2515d0168cab3e04971cf036e26fd8b36ec85a", + "0x8af56aa87161019efae0e96457b879fb5f18a126458353d4ada585b151affe1e", + "0x43f2012043a8c396d8f7ba351ba44dba34bd3dd551ec7d73ab76b3e4be758d43", + "0x91222200ceb881bd06d4cac77e4a96a3b5de35c754203419d66c8e011950d974", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0x5bbB65fe6E990f2DCDF95FE7E71f07264c5993ac": { + "index": 12, + "amount": "0x07", + "proof": [ + "0xe723c58e2da240deaece744daecb3069c2392e1f896b76361439319de2839b6a", + "0x0852d0aa901bd119fa45ae5f92622d2fee0cfc149902378db3a77ed46c373e42", + "0xf8aa23084f04066e7c070e436596d16503ca51db778229c552f2394fced35660" + ] + }, + "0x646469ee06FD4974edB05c84e290612658cFbbbc": { + "index": 13, + "amount": "0x02", + "proof": [ + "0x2eb6923d6238e381bb57c9e14996e782f0c8dfa6fe51f9e8beb2d3576c6bed6e", + "0x4e8d82f23fdcf500f92c8c5986ffb7816999fc858894fe756f687cf6c18cea35", + "0x95fb8e69e9ca6536df06abfb7fe28bb0cdc4264ea09a1505b0934b695e4f4f36", + "0xec923bed5fc2b30abe50d09d610d60bec9bd12be1b5911565986ab44dc12c3b9", + "0x81b8f6afd557fef18b5fc87033d15748d174f617ba5b90055faa135f645d6b61", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0x736cB793b7Bd1921fd7809EEEF1393fDa06FAE04": { + "index": 14, + "amount": "0x01", + "proof": [ + "0x13fbd18b0292460a2752231551735ceedce8f2cd083803def27e292ca7b2770c", + "0xcfca377e03ab98c82e4f2fc12dcecf50da74eb505cf3dd5478b79f7146257815", + "0xb75ec1abcf5bee52467be878e8219bdff9ec8c3f3cca84a1842cb6bfc88c3a2d", + "0x956734a9f94983d18e18286915cec0bcf12e16e7555951cf1c5056f5a631fe2e", + "0x81b8f6afd557fef18b5fc87033d15748d174f617ba5b90055faa135f645d6b61", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0x7864fAe9c4b0AdF486245664617123D692f6c440": { + "index": 15, + "amount": "0x02", + "proof": [ + "0x5d600a887aacb06a051840e387df672a82a4b7c898f460755021d5a2573d9c00", + "0xc728637a91aa731dce0f086e88931902704ccc69c1c2a3487f72a2c091e727e8", + "0x8af56aa87161019efae0e96457b879fb5f18a126458353d4ada585b151affe1e", + "0x43f2012043a8c396d8f7ba351ba44dba34bd3dd551ec7d73ab76b3e4be758d43", + "0x91222200ceb881bd06d4cac77e4a96a3b5de35c754203419d66c8e011950d974", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0x91724b63Dc4e723609f3E0fACa1B0e7b78579C47": { + "index": 16, + "amount": "0x01", + "proof": [ + "0xaf010d5d28a3f5ed8d513092e5fd155b0dab4b43278ba1e3568645ac7f894fd9", + "0x3b60221a2a0a81a3b5792d6fcf9968e26113f70099c8aea8362107b42ee0d2b9", + "0xcad7757a166e3244e6ee822988f561d4eb64a54e7bc96ade6e8b998c6b58b6f6", + "0x99bd1cb49e60b5b689b521e432cf5d494c5148c1ffafa19d6162f55151423dcd", + "0x91222200ceb881bd06d4cac77e4a96a3b5de35c754203419d66c8e011950d974", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0x99F7eE5FDcE389EA6DE36334D1D3471A28b7e77D": { + "index": 17, + "amount": "0x01", + "proof": [ + "0x3967e78af5bebc0b09bee380da3c46237018f9a83669451ee0ce8576093e344d", + "0x4e8d82f23fdcf500f92c8c5986ffb7816999fc858894fe756f687cf6c18cea35", + "0x95fb8e69e9ca6536df06abfb7fe28bb0cdc4264ea09a1505b0934b695e4f4f36", + "0xec923bed5fc2b30abe50d09d610d60bec9bd12be1b5911565986ab44dc12c3b9", + "0x81b8f6afd557fef18b5fc87033d15748d174f617ba5b90055faa135f645d6b61", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0x9a5cDC551713f81849367f65446A054C7C02079B": { + "index": 18, + "amount": "0x01", + "proof": [ + "0x2d52425755d15bb8e6893b07ff20ece419b10e4e415657a425a2aff0546f8b21", + "0x68cd0fb4fddaeab476891f40290efac5030df95b0ca5a5146da2bff69f3030ac", + "0x95fb8e69e9ca6536df06abfb7fe28bb0cdc4264ea09a1505b0934b695e4f4f36", + "0xec923bed5fc2b30abe50d09d610d60bec9bd12be1b5911565986ab44dc12c3b9", + "0x81b8f6afd557fef18b5fc87033d15748d174f617ba5b90055faa135f645d6b61", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0x9d137567c35d6704B9155A88c8480237c7B24705": { + "index": 19, + "amount": "0x01", + "proof": [ + "0x4742d6401320244a95ec518771d8e6bd6f7875c19b51220115e4297ee0b20b3d", + "0x67035756126b8545211be8adc08bccafdc42c39b2da018fdda64034fb5557875", + "0xa2ab1a40bbeced8c54bc1ff8c92cfa16a87dc7a3ceaec2675a0e8b47cbfc5764", + "0xec923bed5fc2b30abe50d09d610d60bec9bd12be1b5911565986ab44dc12c3b9", + "0x81b8f6afd557fef18b5fc87033d15748d174f617ba5b90055faa135f645d6b61", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0xA38D3EF13046C3c3124f1eB1b0b96F04F2d2f8f9": { + "index": 20, + "amount": "0x02", + "proof": [ + "0x9906a8fc9ff1a381d5b3a331d7b9e2ef36e8571c3f9cf5ee6cffd52b8bdfe129", + "0x925a98381f8154d8acabbb1439182afe03145ae221759759143512be57c0292d", + "0xcad7757a166e3244e6ee822988f561d4eb64a54e7bc96ade6e8b998c6b58b6f6", + "0x99bd1cb49e60b5b689b521e432cf5d494c5148c1ffafa19d6162f55151423dcd", + "0x91222200ceb881bd06d4cac77e4a96a3b5de35c754203419d66c8e011950d974", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0xA7D7Ac8Fe7e8693B5599C69cC7d4F6226677845B": { + "index": 21, + "amount": "0x07", + "proof": [ + "0x1e5217d0979a317e7ebdcc771ef832e8b86a372e13837bb0d7207762c23118cf", + "0xc23cd7bd57b6f32ae82365e3cd045cf86996c7f361632b1447b541b322cca307", + "0x1219ca39ac97655cc13775f0a2b4c579a0fa79630397d15ecae2555fe00448c9", + "0x956734a9f94983d18e18286915cec0bcf12e16e7555951cf1c5056f5a631fe2e", + "0x81b8f6afd557fef18b5fc87033d15748d174f617ba5b90055faa135f645d6b61", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0xB16B0f76e5328076923423fe8c985f69EC12eF84": { + "index": 22, + "amount": "0x02", + "proof": [ + "0x1d0dc3b22a3fd185d5612546d7b634d15e830960550f4688d366f5c28dba2dfd", + "0x0f5a3f182883a54a20e3c372ab64991e35efd84afe44c53a07cc24234e6c599d", + "0x1219ca39ac97655cc13775f0a2b4c579a0fa79630397d15ecae2555fe00448c9", + "0x956734a9f94983d18e18286915cec0bcf12e16e7555951cf1c5056f5a631fe2e", + "0x81b8f6afd557fef18b5fc87033d15748d174f617ba5b90055faa135f645d6b61", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0xCf50fB42926b255747fb8b0EA8E26D4e66952CA4": { + "index": 23, + "amount": "0x02", + "proof": [ + "0x0c3a3fb662b1394ab96e0dd5296be1649a8402894e1282e204dc77780a75e53e", + "0xcfca377e03ab98c82e4f2fc12dcecf50da74eb505cf3dd5478b79f7146257815", + "0xb75ec1abcf5bee52467be878e8219bdff9ec8c3f3cca84a1842cb6bfc88c3a2d", + "0x956734a9f94983d18e18286915cec0bcf12e16e7555951cf1c5056f5a631fe2e", + "0x81b8f6afd557fef18b5fc87033d15748d174f617ba5b90055faa135f645d6b61", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0xD7dc9B1BC54Ddb735A3823951C037a6b324C4D2D": { + "index": 24, + "amount": "0x01", + "proof": [ + "0x4127f438bcfd5f4dd39e7b845ae838e6758a673667708b35f80391eb280fa952", + "0x9819faee4ddb40150babbe35ceb120c350bd737b78d8ad896f65117efa67aa04", + "0xa2ab1a40bbeced8c54bc1ff8c92cfa16a87dc7a3ceaec2675a0e8b47cbfc5764", + "0xec923bed5fc2b30abe50d09d610d60bec9bd12be1b5911565986ab44dc12c3b9", + "0x81b8f6afd557fef18b5fc87033d15748d174f617ba5b90055faa135f645d6b61", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0xDa258189e6731b95C4667c5c62146C18f5249e51": { + "index": 25, + "amount": "0x01", + "proof": [ + "0x7882ce4e27f0a720a9f139b3bc8d4d146a3391e777baafd935f4942869e5b714", + "0x61e554607ee536c9591ada19ca9a03e6682b4b862b6558baef4a0627f2f7cc8d", + "0x0b5556aa8574a1b33ac79fa947783dd475af7b109b6f1ad0b1e3f3be1e874fa3", + "0x43f2012043a8c396d8f7ba351ba44dba34bd3dd551ec7d73ab76b3e4be758d43", + "0x91222200ceb881bd06d4cac77e4a96a3b5de35c754203419d66c8e011950d974", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0xEDBC7D68195A411D5c6a32d3bd93703880Ad7692": { + "index": 26, + "amount": "0x03", + "proof": [ + "0x07579ad6d88e9dcaf0377b5e77c058bba2f01d9ba710ca0fbb35950da0a9837f", + "0xe9ac795a4968617e550162c93536b0448a9f38b6b67ba61a9550a223ff4657e8", + "0xb75ec1abcf5bee52467be878e8219bdff9ec8c3f3cca84a1842cb6bfc88c3a2d", + "0x956734a9f94983d18e18286915cec0bcf12e16e7555951cf1c5056f5a631fe2e", + "0x81b8f6afd557fef18b5fc87033d15748d174f617ba5b90055faa135f645d6b61", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0xF0F225E01cf084d3C246Ad595Ab60d0D4F5b4c78": { + "index": 27, + "amount": "0x01", + "proof": [ + "0x2b723753c61e8be4d550d043396a79b3dc451412f5c06bf61c1a4eb28735af0d", + "0x68cd0fb4fddaeab476891f40290efac5030df95b0ca5a5146da2bff69f3030ac", + "0x95fb8e69e9ca6536df06abfb7fe28bb0cdc4264ea09a1505b0934b695e4f4f36", + "0xec923bed5fc2b30abe50d09d610d60bec9bd12be1b5911565986ab44dc12c3b9", + "0x81b8f6afd557fef18b5fc87033d15748d174f617ba5b90055faa135f645d6b61", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0xF9107317B0fF77eD5b7ADea15e50514A3564002B": { + "index": 28, + "amount": "0x01", + "proof": [ + "0xaef94e419d72ca9ff01679ab9fdb9e5c940f72446923a1a60c8376c09b529ff7", + "0x3b60221a2a0a81a3b5792d6fcf9968e26113f70099c8aea8362107b42ee0d2b9", + "0xcad7757a166e3244e6ee822988f561d4eb64a54e7bc96ade6e8b998c6b58b6f6", + "0x99bd1cb49e60b5b689b521e432cf5d494c5148c1ffafa19d6162f55151423dcd", + "0x91222200ceb881bd06d4cac77e4a96a3b5de35c754203419d66c8e011950d974", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0xa4FB55600853c9D01FAA2A03ccD09f91d7E6DEFe": { + "index": 29, + "amount": "0x01", + "proof": [ + "0xe692ef5ffb203f1b0e8e1768e964434fb96ec80df167835f53666dc719b3cf7a", + "0x0852d0aa901bd119fa45ae5f92622d2fee0cfc149902378db3a77ed46c373e42", + "0xf8aa23084f04066e7c070e436596d16503ca51db778229c552f2394fced35660" + ] + }, + "0xa6885B504A881A7aaFf51fBe497abb1Cd7AF684f": { + "index": 30, + "amount": "0x01", + "proof": [ + "0x1c3ac1b86ae4881d91cfa94d7044a115826020f6e68c28bfc47bcbf48fc93eea", + "0x0f5a3f182883a54a20e3c372ab64991e35efd84afe44c53a07cc24234e6c599d", + "0x1219ca39ac97655cc13775f0a2b4c579a0fa79630397d15ecae2555fe00448c9", + "0x956734a9f94983d18e18286915cec0bcf12e16e7555951cf1c5056f5a631fe2e", + "0x81b8f6afd557fef18b5fc87033d15748d174f617ba5b90055faa135f645d6b61", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0xb3e9c2B96B2cC9dEfA63634dd748F45523205250": { + "index": 31, + "amount": "0x01", + "proof": [ + "0x454a39aa4de0788447144adc755d3b99311bca41bb4b8d718191cce65156f97a", + "0x67035756126b8545211be8adc08bccafdc42c39b2da018fdda64034fb5557875", + "0xa2ab1a40bbeced8c54bc1ff8c92cfa16a87dc7a3ceaec2675a0e8b47cbfc5764", + "0xec923bed5fc2b30abe50d09d610d60bec9bd12be1b5911565986ab44dc12c3b9", + "0x81b8f6afd557fef18b5fc87033d15748d174f617ba5b90055faa135f645d6b61", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0xb9dc2fbBEeeaEF6aE0082FFE0afF3FB798c5E735": { + "index": 32, + "amount": "0x01", + "proof": [ + "0x63d13ddc0505bfdeed56b94c5e44fc3ed05b91af2236fe496288897ba83d3972", + "0xc728637a91aa731dce0f086e88931902704ccc69c1c2a3487f72a2c091e727e8", + "0x8af56aa87161019efae0e96457b879fb5f18a126458353d4ada585b151affe1e", + "0x43f2012043a8c396d8f7ba351ba44dba34bd3dd551ec7d73ab76b3e4be758d43", + "0x91222200ceb881bd06d4cac77e4a96a3b5de35c754203419d66c8e011950d974", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0xd836da33a6629548271eb9ef4f62D083376eB4A6": { + "index": 33, + "amount": "0x04", + "proof": [ + "0xea596a3c5f338aec9ac5cf944e60d6371291139fd2ebccfea97a08b03ec8d1e4", + "0x267c55f7d7797778855208c196db6df8a5ff1d39df5fe4c6dd8924d2027ce813", + "0xf8aa23084f04066e7c070e436596d16503ca51db778229c552f2394fced35660" + ] + }, + "0xe1D9298FBeC55da67e97F344DfAF9a30F5eb4331": { + "index": 34, + "amount": "0x01", + "proof": [ + "0xcebaa479537409f812f5879c8288743ef65a4ea964a2a86a60a08e9955493e23", + "0xd483560cc8ca12d4b1aae888ab7da87f86142178783d41da7f325dade426dc62", + "0x9ab03a9b8cd0920640163093c95e34dc75d9e53faad37ab74ff2c0f2b88fd39c", + "0x99bd1cb49e60b5b689b521e432cf5d494c5148c1ffafa19d6162f55151423dcd", + "0x91222200ceb881bd06d4cac77e4a96a3b5de35c754203419d66c8e011950d974", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + }, + "0xe51e75dE078483BE2112442F36e920360227a46d": { + "index": 35, + "amount": "0x01", + "proof": [ + "0x3d09c7d4b26f0cbd638e269b2da14dab36949325e8c57fb6d0c6916fa730568d", + "0x9819faee4ddb40150babbe35ceb120c350bd737b78d8ad896f65117efa67aa04", + "0xa2ab1a40bbeced8c54bc1ff8c92cfa16a87dc7a3ceaec2675a0e8b47cbfc5764", + "0xec923bed5fc2b30abe50d09d610d60bec9bd12be1b5911565986ab44dc12c3b9", + "0x81b8f6afd557fef18b5fc87033d15748d174f617ba5b90055faa135f645d6b61", + "0x41e0f11d9d776f7601516fc037d07a48d93bd5ddbbab5a34841804b659fcaa92" + ] + } + } + }, + { + "merkleRoot": "0x5533ff0d078b4b3173c2a68134396dfc4549bbef117ba4fa4cedbbb4d57488b3", + "tierIndex": 2, + "tokenTotal": "0x01", + "claims": { + "0x391891Af67E29D97E61E30C3036a0874F5Da411e": { + "index": 0, + "amount": "0x01", + "proof": [] + } + } + }, + { + "merkleRoot": "0xa87a802bfc927ba55c7807638ea6309a7c37aaa432af03ebca0d0a204b4688f6", + "tierIndex": 0, + "tokenTotal": "0x20", + "claims": { + "0x049808d5EAA90a2665b9703d2246DDed34F1EB73": { + "index": 0, + "amount": "0x01", + "proof": [ + "0xd8467f2d3ea30471f7b82f0244e3daabe065e37229f8e1bdba751c11401160ca", + "0x2bb725896bf95b031b6c63d1dcf3e7389675bbbb6e578c56f7e75505991d56bc", + "0x56e244ce77ba5877482dea41c0f070d32ff2a51169055d7528031187a9243591", + "0x248e22c2e24d9e1dad91dabc8cc375f7bc1b7fbc88426acc43226c20922f7521", + "0x7d43255ea593649053ec7a75c92dfda694ce4f9986bb8e36e10aee02a67fa449" + ] + }, + "0x09f258F399c421aFFf697FF75CAca4bA3C73f02b": { + "index": 1, + "amount": "0x01", + "proof": [ + "0x2446289598ddc4111828d6fd0c2fa1036eec2c7569d6273141bf53a7ce723b25", + "0x2bd08281d0c4357a92979ef13752b9615a0a9af05db691018348f6f6a1c362fd", + "0x792f99d6ada6ea52d5e2b596c8b3292ca0b3c7aba4377502ab2225cb2f993a01", + "0x2bd0e98e3ff78f61fa91d9fad8b6b769a7132a5ebe9e7f2b60f06fd82bc7c874", + "0xa852216be12264416d20b6bcc1c377956f822bcbc631497014c16f82e5f50b0b" + ] + }, + "0x0D2D49D2570B9075E07778dc6E5f59d091FA835e": { + "index": 2, + "amount": "0x01", + "proof": [ + "0xb9d2b54fabbed794ae7ff24ba1c1fc6403424494a341bfa777ca1c4ffefc44bd", + "0x6d51d6d3d0f80d6a41aa55b05b1ef894e4524fdd3d6da82c74c304c033028804", + "0xd83e152f95abaf9144eaed16f070bfdc90d7253413a530fc2871346adb7a3f23", + "0xbf4ff3fb344f4e24a6aed2d70676441bbf9ffedec0dc08e1ea9471948e8ad60b", + "0x7d43255ea593649053ec7a75c92dfda694ce4f9986bb8e36e10aee02a67fa449" + ] + }, + "0x11b67a503B3B702104EeeF69a4eA1365D0F2c658": { + "index": 3, + "amount": "0x01", + "proof": [ + "0xe87f494a27e2b7566484086f6b9f0ac39f481fdcdfd38e7c57f888744f35481d", + "0x302d6f3e5e889856f308d0149b30439b44c7c63cd889adb569c544b03fd7fcfc", + "0x70173e061dcfdc96ea7b2d0547896bd7c88c6a898e0507d3628552c3a26b598d", + "0x248e22c2e24d9e1dad91dabc8cc375f7bc1b7fbc88426acc43226c20922f7521", + "0x7d43255ea593649053ec7a75c92dfda694ce4f9986bb8e36e10aee02a67fa449" + ] + }, + "0x1e550B93a628Dc2bD7f6A592f23867241e562AeE": { + "index": 4, + "amount": "0x01", + "proof": [ + "0xdf926f4666048d2ce60d7d8948114dd45f09e30e10d0ed3e49b8fb4ec916669c", + "0x2bb725896bf95b031b6c63d1dcf3e7389675bbbb6e578c56f7e75505991d56bc", + "0x56e244ce77ba5877482dea41c0f070d32ff2a51169055d7528031187a9243591", + "0x248e22c2e24d9e1dad91dabc8cc375f7bc1b7fbc88426acc43226c20922f7521", + "0x7d43255ea593649053ec7a75c92dfda694ce4f9986bb8e36e10aee02a67fa449" + ] + }, + "0x323410305c69C44b28874417c0221F065c25318E": { + "index": 5, + "amount": "0x01", + "proof": [ + "0x00972a003f089534b7bfbbaf96a916140fc12aa4efa0d49ccda0ae574ae01e6c", + "0x2da9a976a0554ea7b5c7daee8262ca2895fe85b239c0e975eeefc87590234230", + "0xb6eaf71d51f23cb43c696360250edbbb1b50e1f1fb4b9612f0c318cca18e3f90", + "0x2bd0e98e3ff78f61fa91d9fad8b6b769a7132a5ebe9e7f2b60f06fd82bc7c874", + "0xa852216be12264416d20b6bcc1c377956f822bcbc631497014c16f82e5f50b0b" + ] + }, + "0x32B21cf35Bb38b2304914bB256dA77f12B9AE825": { + "index": 6, + "amount": "0x01", + "proof": [ + "0x7d6b7167beada9189b4ca96a09c54b4a91607ab55dfe6650c130f75a9ee63bd2", + "0x15bf82150f5adfb1521684e1f16fd3f71d3f06c9d478770f94c2eb4ba08a095f", + "0x70ef6fad82be08cf80a938e4493306da3c2993b0c4b9dfbb9514012aa20b41a0", + "0xbf4ff3fb344f4e24a6aed2d70676441bbf9ffedec0dc08e1ea9471948e8ad60b", + "0x7d43255ea593649053ec7a75c92dfda694ce4f9986bb8e36e10aee02a67fa449" + ] + }, + "0x359E65B68Bc002DABDeF259D9fC4D30f600F35f8": { + "index": 7, + "amount": "0x01", + "proof": [ + "0x1b99ad64d6f81a2e130909ae89a9c8c85e8c2d2accff481292aba03533b8f35f", + "0x2bd08281d0c4357a92979ef13752b9615a0a9af05db691018348f6f6a1c362fd", + "0x792f99d6ada6ea52d5e2b596c8b3292ca0b3c7aba4377502ab2225cb2f993a01", + "0x2bd0e98e3ff78f61fa91d9fad8b6b769a7132a5ebe9e7f2b60f06fd82bc7c874", + "0xa852216be12264416d20b6bcc1c377956f822bcbc631497014c16f82e5f50b0b" + ] + }, + "0x38148eCC2078dA7f65E6233DDA28eFaf4C51E96F": { + "index": 8, + "amount": "0x01", + "proof": [ + "0x67c61a2508350894acd290d7f6dbbcf8c374486babe65a4aa783c45e318de0a4", + "0x40ab6376959e31abca87808077cd13bdb5b0fcce40e5976d2fe2df751548b4cf", + "0xd1c0979b63f0c371b449bc7f898188809c740baccfc47590dc86a7fc9be80d47", + "0x7b3703275600195abb1df97fa7d3f760a0c50b626094ecfb44d577be6d6848c4", + "0xa852216be12264416d20b6bcc1c377956f822bcbc631497014c16f82e5f50b0b" + ] + }, + "0x4077F83253414347CDa19e997db1aaC7D9DFcE0b": { + "index": 9, + "amount": "0x01", + "proof": [ + "0x7f8258c8783fa1ae9746d9ec132dd1d669b6f42a8ef901c41f6a6eb3709018bd", + "0x15bf82150f5adfb1521684e1f16fd3f71d3f06c9d478770f94c2eb4ba08a095f", + "0x70ef6fad82be08cf80a938e4493306da3c2993b0c4b9dfbb9514012aa20b41a0", + "0xbf4ff3fb344f4e24a6aed2d70676441bbf9ffedec0dc08e1ea9471948e8ad60b", + "0x7d43255ea593649053ec7a75c92dfda694ce4f9986bb8e36e10aee02a67fa449" + ] + }, + "0x42D2184dac8580e6224b361A36CA3a917F7EA67b": { + "index": 10, + "amount": "0x01", + "proof": [ + "0x3d6d3950279178509f9849ff555f2be2cb597e162814241654430ef482cd8477", + "0x509ec6ddcf72ffa300ed55fe1d5e4de172f44bb8b39db76d8f7993b41bf06f3b", + "0x792f99d6ada6ea52d5e2b596c8b3292ca0b3c7aba4377502ab2225cb2f993a01", + "0x2bd0e98e3ff78f61fa91d9fad8b6b769a7132a5ebe9e7f2b60f06fd82bc7c874", + "0xa852216be12264416d20b6bcc1c377956f822bcbc631497014c16f82e5f50b0b" + ] + }, + "0x4c0DC41E82a9da9162bE29B379687C648AEe4388": { + "index": 11, + "amount": "0x01", + "proof": [ + "0x72cdd282af482474a82740ad0941323edecd78bb8da178d7afdc47f47061e6c3", + "0x40ab6376959e31abca87808077cd13bdb5b0fcce40e5976d2fe2df751548b4cf", + "0xd1c0979b63f0c371b449bc7f898188809c740baccfc47590dc86a7fc9be80d47", + "0x7b3703275600195abb1df97fa7d3f760a0c50b626094ecfb44d577be6d6848c4", + "0xa852216be12264416d20b6bcc1c377956f822bcbc631497014c16f82e5f50b0b" + ] + }, + "0x4e8EF2e11A8056A75b0aAc2d313202Bea4016eB0": { + "index": 12, + "amount": "0x01", + "proof": [ + "0xefe65493fb235b2e1956d332e9ea62d9f2e84287f3f607c5fdaebf6a0c05bd1a", + "0x8d5cc0fdebd0fe1d9e2218da61a1868ab3dad40df220befba84b21bf3693a3d9", + "0x70173e061dcfdc96ea7b2d0547896bd7c88c6a898e0507d3628552c3a26b598d", + "0x248e22c2e24d9e1dad91dabc8cc375f7bc1b7fbc88426acc43226c20922f7521", + "0x7d43255ea593649053ec7a75c92dfda694ce4f9986bb8e36e10aee02a67fa449" + ] + }, + "0x5A9BD3E84376D2961D64e7088d0AA60CAB148100": { + "index": 13, + "amount": "0x01", + "proof": [ + "0x5ec2d396402824efd4ecd888828f6c83d2943c56a7fd580781ce92be57fce371", + "0x71240b891a3257c7e30c2eecce5f7f4b1fd27e955082b35b7f8912189c45ea0d", + "0xd1c0979b63f0c371b449bc7f898188809c740baccfc47590dc86a7fc9be80d47", + "0x7b3703275600195abb1df97fa7d3f760a0c50b626094ecfb44d577be6d6848c4", + "0xa852216be12264416d20b6bcc1c377956f822bcbc631497014c16f82e5f50b0b" + ] + }, + "0x6B853955F54BEcaECDBeabAaAA96Dcd35E4A1577": { + "index": 14, + "amount": "0x01", + "proof": [ + "0xd3fed6025e9027dcd1bfcaf591cf9a37e1f201f68c1c8f55200a46747fd88c7c", + "0xe57ccb6f928911451734000546f1017a7086debb0cc5dbc2b6bc663c0fa8f20e", + "0x56e244ce77ba5877482dea41c0f070d32ff2a51169055d7528031187a9243591", + "0x248e22c2e24d9e1dad91dabc8cc375f7bc1b7fbc88426acc43226c20922f7521", + "0x7d43255ea593649053ec7a75c92dfda694ce4f9986bb8e36e10aee02a67fa449" + ] + }, + "0x71535AAe1B6C0c51Db317B54d5eEe72d1ab843c1": { + "index": 15, + "amount": "0x01", + "proof": [ + "0x862c66d47f2f4bdc6b123d5b98272124fa9e1111bf47541eb60e45e49dc0ff98", + "0x22696a99a05df74dfcd881ba2504e3bf458d070b1b40641d18671edb3de100e5", + "0x70ef6fad82be08cf80a938e4493306da3c2993b0c4b9dfbb9514012aa20b41a0", + "0xbf4ff3fb344f4e24a6aed2d70676441bbf9ffedec0dc08e1ea9471948e8ad60b", + "0x7d43255ea593649053ec7a75c92dfda694ce4f9986bb8e36e10aee02a67fa449" + ] + }, + "0x7553fa99AB1f429551eeC660708C08E14E30584F": { + "index": 16, + "amount": "0x01", + "proof": [ + "0xf8403aa9f3f1e4ae1d030843b1a517e8bb9ffe686828ca54782ba73516e85680", + "0x8d5cc0fdebd0fe1d9e2218da61a1868ab3dad40df220befba84b21bf3693a3d9", + "0x70173e061dcfdc96ea7b2d0547896bd7c88c6a898e0507d3628552c3a26b598d", + "0x248e22c2e24d9e1dad91dabc8cc375f7bc1b7fbc88426acc43226c20922f7521", + "0x7d43255ea593649053ec7a75c92dfda694ce4f9986bb8e36e10aee02a67fa449" + ] + }, + "0x7c74F84ab9d211b0aD306fd793c593B744135c49": { + "index": 17, + "amount": "0x01", + "proof": [ + "0xa5b4bd064950b9c41df4ff22b1b8d8072d4bd0f6d0070daba124988f2fb4ba4a", + "0xa05df577409e13730671f2732136c1420352f16dcb8b52152130dfa443805d0e", + "0xd83e152f95abaf9144eaed16f070bfdc90d7253413a530fc2871346adb7a3f23", + "0xbf4ff3fb344f4e24a6aed2d70676441bbf9ffedec0dc08e1ea9471948e8ad60b", + "0x7d43255ea593649053ec7a75c92dfda694ce4f9986bb8e36e10aee02a67fa449" + ] + }, + "0x8e4933D9d82c1486F47808a761B2C21D1A0C3328": { + "index": 18, + "amount": "0x01", + "proof": [ + "0x0d84c3c5a8bdf5b63cd74ca537630bab3508f66aac542714146b6bfbf7839642", + "0x2da9a976a0554ea7b5c7daee8262ca2895fe85b239c0e975eeefc87590234230", + "0xb6eaf71d51f23cb43c696360250edbbb1b50e1f1fb4b9612f0c318cca18e3f90", + "0x2bd0e98e3ff78f61fa91d9fad8b6b769a7132a5ebe9e7f2b60f06fd82bc7c874", + "0xa852216be12264416d20b6bcc1c377956f822bcbc631497014c16f82e5f50b0b" + ] + }, + "0xA14964479Ebf9cD336011ad80652b08CD83dFE3A": { + "index": 19, + "amount": "0x01", + "proof": [ + "0x1906235857efce835af797286d01a86770f4c08f8aa3d214349308ced25a0bec", + "0x13198896dbe8e4808428b1b8e0a9e79f4f2c031a9be317b9d25974529fba6080", + "0xb6eaf71d51f23cb43c696360250edbbb1b50e1f1fb4b9612f0c318cca18e3f90", + "0x2bd0e98e3ff78f61fa91d9fad8b6b769a7132a5ebe9e7f2b60f06fd82bc7c874", + "0xa852216be12264416d20b6bcc1c377956f822bcbc631497014c16f82e5f50b0b" + ] + }, + "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5": { + "index": 20, + "amount": "0x01", + "proof": [ + "0x3f6e4864db9d1605b1a033da7c580892d45c1e1345911ffc9fed64b2a3e5d9ed", + "0x4662bcf9399c9b4a9abadd8cef50d1012ac466f85983cf11099608205f15d16f", + "0x2e7a05c02cfaa94ae26ab3d2ccb2004d3aa4507f57803e5a10ffdad4a1e7e8a4", + "0x7b3703275600195abb1df97fa7d3f760a0c50b626094ecfb44d577be6d6848c4", + "0xa852216be12264416d20b6bcc1c377956f822bcbc631497014c16f82e5f50b0b" + ] + }, + "0xAe6ecA6b0836e37d270722Ba81bB2EcacB674b08": { + "index": 21, + "amount": "0x01", + "proof": [ + "0xb5ae9a04f62c9040b50695674e6fdf569d17720011de467c54802ac481612cba", + "0xa05df577409e13730671f2732136c1420352f16dcb8b52152130dfa443805d0e", + "0xd83e152f95abaf9144eaed16f070bfdc90d7253413a530fc2871346adb7a3f23", + "0xbf4ff3fb344f4e24a6aed2d70676441bbf9ffedec0dc08e1ea9471948e8ad60b", + "0x7d43255ea593649053ec7a75c92dfda694ce4f9986bb8e36e10aee02a67fa449" + ] + }, + "0xBadAb2F42f87378A05DE7FaF5e2bACe4AeB5fe59": { + "index": 22, + "amount": "0x01", + "proof": [ + "0x36bcad1cf39370d4337eab767025ea2f2c16d346634b94e9501d52e1da2380f4", + "0x509ec6ddcf72ffa300ed55fe1d5e4de172f44bb8b39db76d8f7993b41bf06f3b", + "0x792f99d6ada6ea52d5e2b596c8b3292ca0b3c7aba4377502ab2225cb2f993a01", + "0x2bd0e98e3ff78f61fa91d9fad8b6b769a7132a5ebe9e7f2b60f06fd82bc7c874", + "0xa852216be12264416d20b6bcc1c377956f822bcbc631497014c16f82e5f50b0b" + ] + }, + "0xF9b45a3c3Ade1d975566Da21b262d3afaf611833": { + "index": 23, + "amount": "0x01", + "proof": [ + "0x518c2322e5db5847e79d70b1bbf2ebaaf9b7dd84c3172f61d2a87e89ebb038d0", + "0x71240b891a3257c7e30c2eecce5f7f4b1fd27e955082b35b7f8912189c45ea0d", + "0xd1c0979b63f0c371b449bc7f898188809c740baccfc47590dc86a7fc9be80d47", + "0x7b3703275600195abb1df97fa7d3f760a0c50b626094ecfb44d577be6d6848c4", + "0xa852216be12264416d20b6bcc1c377956f822bcbc631497014c16f82e5f50b0b" + ] + }, + "0xa243A7b4e9AF8D7e87a5443Aa7E21AB27624eaaA": { + "index": 24, + "amount": "0x01", + "proof": [ + "0xe915eadeeeba1802d4b942e54ba3b74a39817e542ec37b331cf289f6ebf9559a", + "0x302d6f3e5e889856f308d0149b30439b44c7c63cd889adb569c544b03fd7fcfc", + "0x70173e061dcfdc96ea7b2d0547896bd7c88c6a898e0507d3628552c3a26b598d", + "0x248e22c2e24d9e1dad91dabc8cc375f7bc1b7fbc88426acc43226c20922f7521", + "0x7d43255ea593649053ec7a75c92dfda694ce4f9986bb8e36e10aee02a67fa449" + ] + }, + "0xa2e3BdaE9569c89B13cD4407a87FD063253b84F8": { + "index": 25, + "amount": "0x01", + "proof": [ + "0x4637064b5c4c8ec91e7e3cb7cf0842141c9489d4bcf01e15701c464dc5c90ef7", + "0x60edd37fdf9609b53f92b02184e846cbbace11bd8ec8c3fd04122f164d9f0c63", + "0x2e7a05c02cfaa94ae26ab3d2ccb2004d3aa4507f57803e5a10ffdad4a1e7e8a4", + "0x7b3703275600195abb1df97fa7d3f760a0c50b626094ecfb44d577be6d6848c4", + "0xa852216be12264416d20b6bcc1c377956f822bcbc631497014c16f82e5f50b0b" + ] + }, + "0xb6A6A6FbAfCFB120D5DE6535C27dB98432E8bCb0": { + "index": 26, + "amount": "0x01", + "proof": [ + "0x3f14ac9e17156eef5639c86f6465fdc027b2df90ba12cc6de9cfa3f07fcebf28", + "0x4662bcf9399c9b4a9abadd8cef50d1012ac466f85983cf11099608205f15d16f", + "0x2e7a05c02cfaa94ae26ab3d2ccb2004d3aa4507f57803e5a10ffdad4a1e7e8a4", + "0x7b3703275600195abb1df97fa7d3f760a0c50b626094ecfb44d577be6d6848c4", + "0xa852216be12264416d20b6bcc1c377956f822bcbc631497014c16f82e5f50b0b" + ] + }, + "0xbCAFD7a10F18B873653f18f0021Ac0bd64B122bc": { + "index": 27, + "amount": "0x01", + "proof": [ + "0x45714207b3727484f1c126c1c3fa36e0d65d1a092ea4c0c8012085db00ced4b1", + "0x60edd37fdf9609b53f92b02184e846cbbace11bd8ec8c3fd04122f164d9f0c63", + "0x2e7a05c02cfaa94ae26ab3d2ccb2004d3aa4507f57803e5a10ffdad4a1e7e8a4", + "0x7b3703275600195abb1df97fa7d3f760a0c50b626094ecfb44d577be6d6848c4", + "0xa852216be12264416d20b6bcc1c377956f822bcbc631497014c16f82e5f50b0b" + ] + }, + "0xe33f1860Eb6B335F0F961c95952e29941D09b5f7": { + "index": 28, + "amount": "0x01", + "proof": [ + "0x822847538d5f203f3e86cda5c6a1824d38173fe84ea9d57edc404ee8db15c77e", + "0x22696a99a05df74dfcd881ba2504e3bf458d070b1b40641d18671edb3de100e5", + "0x70ef6fad82be08cf80a938e4493306da3c2993b0c4b9dfbb9514012aa20b41a0", + "0xbf4ff3fb344f4e24a6aed2d70676441bbf9ffedec0dc08e1ea9471948e8ad60b", + "0x7d43255ea593649053ec7a75c92dfda694ce4f9986bb8e36e10aee02a67fa449" + ] + }, + "0xe5A3F1e72D1dFa5C361516AC2779E9602106fEa6": { + "index": 29, + "amount": "0x01", + "proof": [ + "0x14cb2ca15411ecdb184d947529f688f8c7aa358d92d404d08a0b1f5e0d93d938", + "0x13198896dbe8e4808428b1b8e0a9e79f4f2c031a9be317b9d25974529fba6080", + "0xb6eaf71d51f23cb43c696360250edbbb1b50e1f1fb4b9612f0c318cca18e3f90", + "0x2bd0e98e3ff78f61fa91d9fad8b6b769a7132a5ebe9e7f2b60f06fd82bc7c874", + "0xa852216be12264416d20b6bcc1c377956f822bcbc631497014c16f82e5f50b0b" + ] + }, + "0xeA459a5aA7e52F0493eDa1fAaE0B862C51bf40B9": { + "index": 30, + "amount": "0x01", + "proof": [ + "0xbaee7dc22c778481462359bd504c4746758721831a9ec59560988ab0fef70960", + "0x6d51d6d3d0f80d6a41aa55b05b1ef894e4524fdd3d6da82c74c304c033028804", + "0xd83e152f95abaf9144eaed16f070bfdc90d7253413a530fc2871346adb7a3f23", + "0xbf4ff3fb344f4e24a6aed2d70676441bbf9ffedec0dc08e1ea9471948e8ad60b", + "0x7d43255ea593649053ec7a75c92dfda694ce4f9986bb8e36e10aee02a67fa449" + ] + }, + "0xeFFF9f68c79088D1efeEA73b03c84Ee422F09af2": { + "index": 31, + "amount": "0x01", + "proof": [ + "0xcbccf1f4b1bed550be4384ff8e46bfe88dbedb4da14dbcbcfdeabc6c9c31901f", + "0xe57ccb6f928911451734000546f1017a7086debb0cc5dbc2b6bc663c0fa8f20e", + "0x56e244ce77ba5877482dea41c0f070d32ff2a51169055d7528031187a9243591", + "0x248e22c2e24d9e1dad91dabc8cc375f7bc1b7fbc88426acc43226c20922f7521", + "0x7d43255ea593649053ec7a75c92dfda694ce4f9986bb8e36e10aee02a67fa449" + ] + } + } + }, + { + "merkleRoot": "0x3aee3e360de43a390c122b72a547cff4fac35583b10bf13313035af881db5ef5", + "tierIndex": 4, + "tokenTotal": "0x1f", + "claims": { + "0x06940cfBc097ed8A3F535715E500Ffbe1E685fDc": { + "index": 0, + "amount": "0x0a", + "proof": [ + "0x972e2bb30574f2a6b6bb578a997af2dba023b86e3b30f79c9f8f7b03e6a9dd4f", + "0x20785773776b14a3fe047cf5889130b7aae1611c1e20c8dc08b147c7ff79732f" + ] + }, + "0x941653d6e49399D85639C7d486410c0A29185118": { + "index": 1, + "amount": "0x01", + "proof": [ + "0xe4a48e7807c9419ae1ee11bf58a3157b08973944d6b0c399ea37f191fea51899", + "0x16ad3d7cab7fd1ab84ba29550471d0ce319bda84b279250cc3e58dd5c5f5007f" + ] + }, + "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5": { + "index": 2, + "amount": "0x0a", + "proof": [ + "0xe061645b6a481a83ba42c7ee3335756deeb79687485cf98d054d5bea15dd6295", + "0x16ad3d7cab7fd1ab84ba29550471d0ce319bda84b279250cc3e58dd5c5f5007f" + ] + }, + "0xd59e99927018b995ee9Ad6b9003677f1e7393F8A": { + "index": 3, + "amount": "0x0a", + "proof": [ + "0x7174f9c7ab2f9b8aaf5a7112c16d3be8bdd89300d827cce72f21b26c28c41e63", + "0x20785773776b14a3fe047cf5889130b7aae1611c1e20c8dc08b147c7ff79732f" + ] + } + } + }, + { + "merkleRoot": "0xd794edcab92455dbd5b20391c0c463f9153910b6a72fad367a7a0ce3f863910b", + "tierIndex": 5, + "tokenTotal": "0x2f", + "claims": { + "0x06940cfBc097ed8A3F535715E500Ffbe1E685fDc": { + "index": 0, + "amount": "0x0a", + "proof": [ + "0x58de31c3dddf093beb42f0ba6ca1b58ee2390c4525412631244d4e14df8c0d3d", + "0x2947627ca501d1882bdd8a291f98c6e04f11d6a83e399cc71d8fccb18e4b0740", + "0xf46a88d755c6a104bfe742c549cae3d6591386b0ddc63475ac9e547aae757067", + "0x4665e5c37931f15ee1a46930d5e1bfd1c6baf372754540637d63fba12625a982", + "0x778769b74074124d5dfc11f26a0c4226ad4c943b0abb7e2c9bcee8da1b2e39f4" + ] + }, + "0x0Eb96D5ec478B68fF0d48628Ab4DF6A63c21ddAa": { + "index": 1, + "amount": "0x01", + "proof": [ + "0xe557de7f6ab817e4319b257edbed579bf8dd88129d86db4ece0e5088dea7bbf5", + "0x2b3df31db40462a7ad5b460320e4eb93b35416e53f85a6911e30865608d33437", + "0xb57ab807fdede8f98ae42798d281dc3022b4df8cb89fa2f7e8827f672eab0da1" + ] + }, + "0x2f43e98067B488f2Fbb8465cE5f6dA1552d339C1": { + "index": 2, + "amount": "0x01", + "proof": [ + "0xae065bbc4b16dfa999f182b8c5c1c521af8a8b025efa6e995facae6d1cb7b265", + "0x5ee1431b049046c74c17dc8059e721e687ed91a208a0a898565be921580b563c", + "0x961145d92e8bbe3cb9c555d7dc9bbef09c6d13aff97254090f0d199ea39bb65e", + "0x6619ef6cd30a4240fd5a65b9e59c7e808edf89929f1966c81ba916004f5a227d", + "0x778769b74074124d5dfc11f26a0c4226ad4c943b0abb7e2c9bcee8da1b2e39f4" + ] + }, + "0x3AF30b956F1737005B6e3146dBbd35B70F30Df91": { + "index": 3, + "amount": "0x01", + "proof": [ + "0xc3fd6552c220e64539dd94592235140dd4c8bf6d7a131fda21c8ae5e1473bbf2", + "0xef6edd98a559145af19fc4f5ca95c48bb9d4cf1570255d7db0030e6129d8a6e0", + "0x961145d92e8bbe3cb9c555d7dc9bbef09c6d13aff97254090f0d199ea39bb65e", + "0x6619ef6cd30a4240fd5a65b9e59c7e808edf89929f1966c81ba916004f5a227d", + "0x778769b74074124d5dfc11f26a0c4226ad4c943b0abb7e2c9bcee8da1b2e39f4" + ] + }, + "0x3DAc271d1B36A434880C527A678B6487AC9C1F8c": { + "index": 4, + "amount": "0x01", + "proof": [ + "0xe7a569c58ca267fcedfec40eed9c56e6aa99c922e40687d82fdba50b73448cf0", + "0x12300a259ebcc41bd307d44b534dfc168b9260c5bf3d72cd1de05a2f9164290c", + "0xb57ab807fdede8f98ae42798d281dc3022b4df8cb89fa2f7e8827f672eab0da1" + ] + }, + "0x5477729b43A0A9beA8c41367C62e7864123B57d8": { + "index": 5, + "amount": "0x01", + "proof": [ + "0x3e08593d75b12985ee151b2f51e7a141ff73d037b51a2de2023fc6da7d182cd4", + "0xf585cc16e9ea2014002deadc4abfb484aaa9f3752a4a801e51aba4ad4cbf7340", + "0xedff648bb8fdfc9006e0a43b6ac58b3a8aab2b6463752bf24bbe39c5fbe9b541", + "0x4665e5c37931f15ee1a46930d5e1bfd1c6baf372754540637d63fba12625a982", + "0x778769b74074124d5dfc11f26a0c4226ad4c943b0abb7e2c9bcee8da1b2e39f4" + ] + }, + "0x5F813f7135a73B4360527F6428D5D8DbcD48a39E": { + "index": 6, + "amount": "0x01", + "proof": [ + "0x92e6eb19b587254f10748c1f172929ecc037e0094251687e8ada71c840e79bd6", + "0x0d6239189cf4c6f5535636bbe563512604c056c7408b44de947d7d256142425e", + "0xdca6f8a719131717f82e31f73eba93cd344cf7c398c79a928a2fee5e109dc1da", + "0x6619ef6cd30a4240fd5a65b9e59c7e808edf89929f1966c81ba916004f5a227d", + "0x778769b74074124d5dfc11f26a0c4226ad4c943b0abb7e2c9bcee8da1b2e39f4" + ] + }, + "0x70bE2bFE60d875FAAd5922F2379aF1a0AFC8e754": { + "index": 7, + "amount": "0x01", + "proof": [ + "0xa214270d1c2e67dfc8f0c8ad204b71f6d87f3d6b6dacc5403fed9596d20a08b9", + "0x5ee1431b049046c74c17dc8059e721e687ed91a208a0a898565be921580b563c", + "0x961145d92e8bbe3cb9c555d7dc9bbef09c6d13aff97254090f0d199ea39bb65e", + "0x6619ef6cd30a4240fd5a65b9e59c7e808edf89929f1966c81ba916004f5a227d", + "0x778769b74074124d5dfc11f26a0c4226ad4c943b0abb7e2c9bcee8da1b2e39f4" + ] + }, + "0x7a22E7a4d912231f9c0FB6760c59Ab560188360b": { + "index": 8, + "amount": "0x01", + "proof": [ + "0xeca1b23fb1fc3ce256d42883366c7cdfbb54a1dfc3fbc8e96faa64ac337e2c86", + "0x12300a259ebcc41bd307d44b534dfc168b9260c5bf3d72cd1de05a2f9164290c", + "0xb57ab807fdede8f98ae42798d281dc3022b4df8cb89fa2f7e8827f672eab0da1" + ] + }, + "0x9E7943cEAc1f02B00E5f9d6E182F257efaA4653e": { + "index": 9, + "amount": "0x01", + "proof": [ + "0xbe4ca1d883f8fec1b041634c204f7cdc7460a7183fbcf2a76d9c5b039787933f", + "0xef6edd98a559145af19fc4f5ca95c48bb9d4cf1570255d7db0030e6129d8a6e0", + "0x961145d92e8bbe3cb9c555d7dc9bbef09c6d13aff97254090f0d199ea39bb65e", + "0x6619ef6cd30a4240fd5a65b9e59c7e808edf89929f1966c81ba916004f5a227d", + "0x778769b74074124d5dfc11f26a0c4226ad4c943b0abb7e2c9bcee8da1b2e39f4" + ] + }, + "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5": { + "index": 10, + "amount": "0x0a", + "proof": [ + "0x18214c157350d16042a5a7b79ee22789776272f5ee18946d69788d29aec6d2bb", + "0x589516249ea093315077f8fccd363378b3511e2fd8891b5214f23d4824fd15e3", + "0xedff648bb8fdfc9006e0a43b6ac58b3a8aab2b6463752bf24bbe39c5fbe9b541", + "0x4665e5c37931f15ee1a46930d5e1bfd1c6baf372754540637d63fba12625a982", + "0x778769b74074124d5dfc11f26a0c4226ad4c943b0abb7e2c9bcee8da1b2e39f4" + ] + }, + "0xC579Ef8B14774BD15c021D2C0aaFd04bDd7dd137": { + "index": 11, + "amount": "0x01", + "proof": [ + "0x1a336c338ce5080f72b4f28afecfc48d92cac1af86d4e11661dd7133d218205e", + "0xf585cc16e9ea2014002deadc4abfb484aaa9f3752a4a801e51aba4ad4cbf7340", + "0xedff648bb8fdfc9006e0a43b6ac58b3a8aab2b6463752bf24bbe39c5fbe9b541", + "0x4665e5c37931f15ee1a46930d5e1bfd1c6baf372754540637d63fba12625a982", + "0x778769b74074124d5dfc11f26a0c4226ad4c943b0abb7e2c9bcee8da1b2e39f4" + ] + }, + "0xD8b896B3f6Cb4eDFA3353EfC5ac59443aB50c596": { + "index": 12, + "amount": "0x01", + "proof": [ + "0x018e998b92b8878d99019134d6a3c3d6a2c5e4674ac845e5eae81f4eede00e3c", + "0x589516249ea093315077f8fccd363378b3511e2fd8891b5214f23d4824fd15e3", + "0xedff648bb8fdfc9006e0a43b6ac58b3a8aab2b6463752bf24bbe39c5fbe9b541", + "0x4665e5c37931f15ee1a46930d5e1bfd1c6baf372754540637d63fba12625a982", + "0x778769b74074124d5dfc11f26a0c4226ad4c943b0abb7e2c9bcee8da1b2e39f4" + ] + }, + "0xEFde6a97AF618AD407211C3D5d494BC257948208": { + "index": 13, + "amount": "0x01", + "proof": [ + "0x3f38f653a00255d850971505e61878bc56fdc1378d67f582edd3b66a5af018cf", + "0x3e98eded60dbbb9273763d6855bceb3b2bd1cec1beb6fcb4535c525fa534d99f", + "0xf46a88d755c6a104bfe742c549cae3d6591386b0ddc63475ac9e547aae757067", + "0x4665e5c37931f15ee1a46930d5e1bfd1c6baf372754540637d63fba12625a982", + "0x778769b74074124d5dfc11f26a0c4226ad4c943b0abb7e2c9bcee8da1b2e39f4" + ] + }, + "0xbe15D15bb99CaCBd87530F4B40BC706BAF35972E": { + "index": 14, + "amount": "0x01", + "proof": [ + "0x56856082739b8a08a744be567e8cec50077f1aa83e718b4df21938577afe3c94", + "0x3e98eded60dbbb9273763d6855bceb3b2bd1cec1beb6fcb4535c525fa534d99f", + "0xf46a88d755c6a104bfe742c549cae3d6591386b0ddc63475ac9e547aae757067", + "0x4665e5c37931f15ee1a46930d5e1bfd1c6baf372754540637d63fba12625a982", + "0x778769b74074124d5dfc11f26a0c4226ad4c943b0abb7e2c9bcee8da1b2e39f4" + ] + }, + "0xc821477E0310001dd4DBD978425002eE890bd975": { + "index": 15, + "amount": "0x01", + "proof": [ + "0xc83b0cfed3fdd65f488a1251687235d0db7b75e32f2a10910877c9fa8ca1d0e7", + "0x2b3df31db40462a7ad5b460320e4eb93b35416e53f85a6911e30865608d33437", + "0xb57ab807fdede8f98ae42798d281dc3022b4df8cb89fa2f7e8827f672eab0da1" + ] + }, + "0xd59e99927018b995ee9Ad6b9003677f1e7393F8A": { + "index": 16, + "amount": "0x0a", + "proof": [ + "0x974a895c8488ff7c86e31b2f839cff77f3e2b2ff04dfa284e2584b1753a97f14", + "0x23774364cde5eab06ec48c05a25666cb5ddb0d6d18437156b6e96bccb2431e20", + "0xdca6f8a719131717f82e31f73eba93cd344cf7c398c79a928a2fee5e109dc1da", + "0x6619ef6cd30a4240fd5a65b9e59c7e808edf89929f1966c81ba916004f5a227d", + "0x778769b74074124d5dfc11f26a0c4226ad4c943b0abb7e2c9bcee8da1b2e39f4" + ] + }, + "0xd7Ddf70125342f44E65ccbafAe5135F2bB6526bB": { + "index": 17, + "amount": "0x01", + "proof": [ + "0x91211e937ab02a31afb51578b136bd4001dbbad3d54a36040cd1e2a033d6e15a", + "0x0d6239189cf4c6f5535636bbe563512604c056c7408b44de947d7d256142425e", + "0xdca6f8a719131717f82e31f73eba93cd344cf7c398c79a928a2fee5e109dc1da", + "0x6619ef6cd30a4240fd5a65b9e59c7e808edf89929f1966c81ba916004f5a227d", + "0x778769b74074124d5dfc11f26a0c4226ad4c943b0abb7e2c9bcee8da1b2e39f4" + ] + }, + "0xe88663F5878Dd0967C905EC8c7Cc65d6d8e091E6": { + "index": 18, + "amount": "0x01", + "proof": [ + "0x7174f9c7ab2f9b8aaf5a7112c16d3be8bdd89300d827cce72f21b26c28c41e63", + "0x2947627ca501d1882bdd8a291f98c6e04f11d6a83e399cc71d8fccb18e4b0740", + "0xf46a88d755c6a104bfe742c549cae3d6591386b0ddc63475ac9e547aae757067", + "0x4665e5c37931f15ee1a46930d5e1bfd1c6baf372754540637d63fba12625a982", + "0x778769b74074124d5dfc11f26a0c4226ad4c943b0abb7e2c9bcee8da1b2e39f4" + ] + }, + "0xf69EA6646cf682262E84cd7c67133eac59cef07b": { + "index": 19, + "amount": "0x01", + "proof": [ + "0x97a22591e60ab6da1207d472006cd4123e1c26943ac59a763ab0289981f49bf7", + "0x23774364cde5eab06ec48c05a25666cb5ddb0d6d18437156b6e96bccb2431e20", + "0xdca6f8a719131717f82e31f73eba93cd344cf7c398c79a928a2fee5e109dc1da", + "0x6619ef6cd30a4240fd5a65b9e59c7e808edf89929f1966c81ba916004f5a227d", + "0x778769b74074124d5dfc11f26a0c4226ad4c943b0abb7e2c9bcee8da1b2e39f4" + ] + } + } + }, + { + "merkleRoot": "0xba6bb7e9a66bef5ccb095988f8dcb231fe9e754bd5f450aa16b5a30461327373", + "tierIndex": 6, + "tokenTotal": "0x02", + "claims": { + "0x433663f1258376f0C7aec8fbC5CC81292e921527": { + "index": 0, + "amount": "0x01", + "proof": [ + "0xd210fb724028375be984b3cc89d5b6a813a3a2556d42c7d5ebaafd9f91c06edc" + ] + }, + "0x84803775437A51BCD484Cf4Aa6beea1E50426eaB": { + "index": 1, + "amount": "0x01", + "proof": [ + "0x492f67ab9bffcc6e98019f8dc0f2883e08a0ad74263cfb60c568291a367ed006" + ] + } + } + }, + { + "merkleRoot": "0x2a34c36c39f7ef923ff0ec73062d6ef4e680ad24f1a860f974db404a8000804c", + "tierIndex": 7, + "tokenTotal": "0x02", + "claims": { + "0x3c229864378b3B0adF98aE247Ca33986AED8EC1E": { + "index": 0, + "amount": "0x01", + "proof": [ + "0xd8d9512cb7094e22c010ab6d0a657e566875491a900fef98bf63e07093fbb964" + ] + }, + "0x78d58Cc37cDAaBFde72c9a45B57Acbc3aBc3D7C9": { + "index": 1, + "amount": "0x01", + "proof": [ + "0x6f32b9c4e08cc3ed1c16406eb07eacc2684248f6ec4d7ab4ef60f600fa83b1e2" + ] + } + } + }, + { + "merkleRoot": "0x5f3f9452707c93a22cda2557207ddef9af0ca68a67b6978580ddc0b62505b6ce", + "tierIndex": 2, + "tokenTotal": "0x14", + "claims": { + "0x592000b2c8c590531d490893C16AfC4b9cbbe6B9": { + "index": 0, + "amount": "0x0a", + "proof": [ + "0xf1151262562a2b79a243e55a1d9176e04161c11e0a2d75989b59437654a7daa7" + ] + }, + "0x70B9997F00fE9D046c49f3d88dC63314d47cbF8F": { + "index": 1, + "amount": "0x0a", + "proof": [ + "0xe14ded7d43ca5e4b79fff8a3e4c8aaac1c9b14a50819d1337da7d572a7997c94" + ] + } + } + }, + { + "merkleRoot": "0xd541ba87b428007c4fdbfb862dddd74a417824a744ad1a8d8734b4c2b295d634", + "tierIndex": 2, + "tokenTotal": "0x46", + "claims": { + "0x592000b2c8c590531d490893C16AfC4b9cbbe6B9": { + "index": 0, + "amount": "0x0a", + "proof": [ + "0xed141d7a7f2528af1e7a3b74a74c5436aa2264e512a739caac5c1c42771181d4", + "0xc4e591b0f3e121804e753de4bfb69801b623e97179cab240c3a2e89392034eac" + ] + }, + "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5": { + "index": 1, + "amount": "0x0a", + "proof": [ + "0xc57d9441f8ac3c93eee5b1bc2fb228d0bd6ba6aede422695a956e35a1af6e3cc", + "0xe14ded7d43ca5e4b79fff8a3e4c8aaac1c9b14a50819d1337da7d572a7997c94", + "0xc4e591b0f3e121804e753de4bfb69801b623e97179cab240c3a2e89392034eac" + ] + }, + "0xa243A7b4e9AF8D7e87a5443Aa7E21AB27624eaaA": { + "index": 2, + "amount": "0x0a", + "proof": [ + "0xa13b2acef885161647efba9bbf10166022b509383db22ac92d2f452bc06f5fb3", + "0x2ffaa85f3de3e267b156511367f416d414b9132690e062d317adb970e12507d0", + "0xb59220061a4b4f07d4b0505a4c6186c1661dab41bd825076d2b05012fafcb67b" + ] + }, + "0xb8fAF03a268F259dDD9adfAf8E1148Fc81021e54": { + "index": 3, + "amount": "0x0a", + "proof": [ + "0x19cf027b29cb053b5ff9ef5245dface052ff34c6560aee77f41891d26eb9e8d0", + "0x3887c9ef5a85572fbbe219dcdde319c2de20ad130ce68123de0612bec7cf11c6", + "0xb59220061a4b4f07d4b0505a4c6186c1661dab41bd825076d2b05012fafcb67b" + ] + }, + "0xc756Be144729EcDBE51f49073D295ABd318f0048": { + "index": 4, + "amount": "0x0a", + "proof": [ + "0x69b0e6715bffa3d235c18d1630d57097c7f2b5cb0aedb0bd7803e01585de4764", + "0x3887c9ef5a85572fbbe219dcdde319c2de20ad130ce68123de0612bec7cf11c6", + "0xb59220061a4b4f07d4b0505a4c6186c1661dab41bd825076d2b05012fafcb67b" + ] + }, + "0xd59e99927018b995ee9Ad6b9003677f1e7393F8A": { + "index": 5, + "amount": "0x0a", + "proof": [ + "0xdc6f1cf1a50f5ee90381124aa8b94cb6fcd6ba80cfae032cc836c8ec3e3757e8", + "0xe14ded7d43ca5e4b79fff8a3e4c8aaac1c9b14a50819d1337da7d572a7997c94", + "0xc4e591b0f3e121804e753de4bfb69801b623e97179cab240c3a2e89392034eac" + ] + }, + "0xd965Cd540d2B80e7ef2840Ff097016B3A0e930fC": { + "index": 6, + "amount": "0x0a", + "proof": [ + "0x972768dc042a507798f6be5e38f6f3ad4a91966d1967954bdc2aac3ff6bb4fbb", + "0x2ffaa85f3de3e267b156511367f416d414b9132690e062d317adb970e12507d0", + "0xb59220061a4b4f07d4b0505a4c6186c1661dab41bd825076d2b05012fafcb67b" + ] + } + } + }, + { + "merkleRoot": "0xa44bc2a15a92c48a40ba640f36f28f0ad68c75944a3f7742673ead385854d664", + "tierIndex": 2, + "tokenTotal": "0x18", + "claims": { + "0x049808d5EAA90a2665b9703d2246DDed34F1EB73": { + "index": 0, + "amount": "0x01", + "proof": [ + "0xe66a5082dbd2edf6da63e51734fd0718e6ef782fbc7498faa1c01a90ca3812ae", + "0x8d6ee81df6ad4222d58ab28cadd8d71b3801bedb64073390a3079e01d84e2696", + "0x8dde402fa6b95076b06a216ea6d59848a48a37ddd4b5b917c1a8e14ff090df96", + "0xf3804b5bf47fbfdb6dd791b00fa5ffe7c067dc4e6ec59931ffaaa0672b62b4b4" + ] + }, + "0x09f258F399c421aFFf697FF75CAca4bA3C73f02b": { + "index": 1, + "amount": "0x01", + "proof": [ + "0x18df3d21dbe24b0040130ff63f5c4712325c10f10243f6757e3d31a8695c0c56", + "0xfaadc6deda96d89f248feaeac181054ee1ee49718183c90516b84d83a5d37f2b", + "0x264fd334482cd991fe9fdb7623cad50180d0b06de6729e192fb32f4e2f57cc87", + "0x59b679102df67de9cb66e5b918f900a75f47f81b0f3f1d9bb51e020ff77b2648", + "0xb393f7da6d1cd46c667a6fca3e8ce94fc096b6a7d3c16272cfa8a67e66b42abe" + ] + }, + "0x11b67a503B3B702104EeeF69a4eA1365D0F2c658": { + "index": 2, + "amount": "0x01", + "proof": [ + "0xf5dad8eeaa3e34c78d523b9c07995c7e3fa6db97404cd9cc653eaab3e7797cbb", + "0x367d8f3600a12849c4a1d5a3197b1a888cdb56e55d91ca11bcb1bfc767178f9d", + "0x8dde402fa6b95076b06a216ea6d59848a48a37ddd4b5b917c1a8e14ff090df96", + "0xf3804b5bf47fbfdb6dd791b00fa5ffe7c067dc4e6ec59931ffaaa0672b62b4b4" + ] + }, + "0x32B21cf35Bb38b2304914bB256dA77f12B9AE825": { + "index": 3, + "amount": "0x01", + "proof": [ + "0xb31fa8aeb95d7be21da9fc207aebc905e7ff38e164df9992f1ad8f30d2de7f45", + "0xc3f9651a7e4c385ba27eac519459f831f4ac3efb102eb5f7b972baf3ad908c02", + "0x9431984ab2ba4812a5f27f97b5bb5610c3af9c782b425ed0b1f8e256a827f5d1", + "0xfcbe889b70ee6a946a2361c0699670e5cb143a2a69027434bc08302dc9705ced", + "0xb393f7da6d1cd46c667a6fca3e8ce94fc096b6a7d3c16272cfa8a67e66b42abe" + ] + }, + "0x38148eCC2078dA7f65E6233DDA28eFaf4C51E96F": { + "index": 4, + "amount": "0x01", + "proof": [ + "0x7e0463c64522e62695d89b8a74e47abd6299297c94cb4f9c89c1f0e39cad09a5", + "0x23d430bbac9827582d0d6311751e6b3b1873d3536e0718018f0321a3d67f7f4e", + "0x98ef0af2093d8e79278c9e1410604ec213411fbace18bbdd652283cdea0ef422", + "0xfcbe889b70ee6a946a2361c0699670e5cb143a2a69027434bc08302dc9705ced", + "0xb393f7da6d1cd46c667a6fca3e8ce94fc096b6a7d3c16272cfa8a67e66b42abe" + ] + }, + "0x42D2184dac8580e6224b361A36CA3a917F7EA67b": { + "index": 5, + "amount": "0x01", + "proof": [ + "0xbb4067dc1509ccc1cd2df0ad7caa267fd67367bd23eef013947343bf1d89a1e9", + "0x37f1a4df800340782460361a1d1d92bf4c401025d7d2c5a6f0aec10af52700ca", + "0xce32dd594dc9e5662bb8622ab3a1072050ada4ea24446c1444d1f2c8dd955b0d", + "0xf3804b5bf47fbfdb6dd791b00fa5ffe7c067dc4e6ec59931ffaaa0672b62b4b4" + ] + }, + "0x4c0DC41E82a9da9162bE29B379687C648AEe4388": { + "index": 6, + "amount": "0x01", + "proof": [ + "0xb9dad4ad016c503675cfad61b1f11d08e5c80300e7a2cf872d0672d1eb135ae5", + "0x37f1a4df800340782460361a1d1d92bf4c401025d7d2c5a6f0aec10af52700ca", + "0xce32dd594dc9e5662bb8622ab3a1072050ada4ea24446c1444d1f2c8dd955b0d", + "0xf3804b5bf47fbfdb6dd791b00fa5ffe7c067dc4e6ec59931ffaaa0672b62b4b4" + ] + }, + "0x4e8EF2e11A8056A75b0aAc2d313202Bea4016eB0": { + "index": 7, + "amount": "0x01", + "proof": [ + "0x1b99ad64d6f81a2e130909ae89a9c8c85e8c2d2accff481292aba03533b8f35f", + "0xfaadc6deda96d89f248feaeac181054ee1ee49718183c90516b84d83a5d37f2b", + "0x264fd334482cd991fe9fdb7623cad50180d0b06de6729e192fb32f4e2f57cc87", + "0x59b679102df67de9cb66e5b918f900a75f47f81b0f3f1d9bb51e020ff77b2648", + "0xb393f7da6d1cd46c667a6fca3e8ce94fc096b6a7d3c16272cfa8a67e66b42abe" + ] + }, + "0x5A9BD3E84376D2961D64e7088d0AA60CAB148100": { + "index": 8, + "amount": "0x01", + "proof": [ + "0x4b8ddec5ff559f0484e3ee458fbde1186e5c5e6f477c3283f600bc20e504af43", + "0x86c3ab8459da8969909ca24b42a847145630f6f957b6667f7d2b6f8b4b5f19f8", + "0x98ef0af2093d8e79278c9e1410604ec213411fbace18bbdd652283cdea0ef422", + "0xfcbe889b70ee6a946a2361c0699670e5cb143a2a69027434bc08302dc9705ced", + "0xb393f7da6d1cd46c667a6fca3e8ce94fc096b6a7d3c16272cfa8a67e66b42abe" + ] + }, + "0x6B853955F54BEcaECDBeabAaAA96Dcd35E4A1577": { + "index": 9, + "amount": "0x01", + "proof": [ + "0x2b3597f7cfb817eae62091939b067a515a4f529e1d22f35f77db99d6a19f1f8f", + "0xe3782de346656d51a87c4f2da5f63443c4189a2cab41824f0a347bb797e51128", + "0x1f436ad7118f4f159680d84bdc6f0b371601e414e84d41056c04d8a132371be2", + "0x59b679102df67de9cb66e5b918f900a75f47f81b0f3f1d9bb51e020ff77b2648", + "0xb393f7da6d1cd46c667a6fca3e8ce94fc096b6a7d3c16272cfa8a67e66b42abe" + ] + }, + "0x71535AAe1B6C0c51Db317B54d5eEe72d1ab843c1": { + "index": 10, + "amount": "0x01", + "proof": [ + "0xcb1ba9ae8b2af60b37ee76077f0d979c7f00d8e5c8a11cd5f73c16dafb457344", + "0xcf93298d6e00bd440cf0c2b230c78d934c47f324ced4a270555eb110a0fb8c69", + "0xce32dd594dc9e5662bb8622ab3a1072050ada4ea24446c1444d1f2c8dd955b0d", + "0xf3804b5bf47fbfdb6dd791b00fa5ffe7c067dc4e6ec59931ffaaa0672b62b4b4" + ] + }, + "0x7553fa99AB1f429551eeC660708C08E14E30584F": { + "index": 11, + "amount": "0x01", + "proof": [ + "0x834d586cfdc3fa00574db951387a5622518bfdd808c3f014311b9d7fecaaf70e", + "0x9dac16cf671d42e1e03ff31e53b8c619d96cc5e56986426e8eb895e6fcfe05c4", + "0x9431984ab2ba4812a5f27f97b5bb5610c3af9c782b425ed0b1f8e256a827f5d1", + "0xfcbe889b70ee6a946a2361c0699670e5cb143a2a69027434bc08302dc9705ced", + "0xb393f7da6d1cd46c667a6fca3e8ce94fc096b6a7d3c16272cfa8a67e66b42abe" + ] + }, + "0x7c74F84ab9d211b0aD306fd793c593B744135c49": { + "index": 12, + "amount": "0x01", + "proof": [ + "0x215b4bd08b5db96c01b60a02e07087715bc6564364196033eaa5dab93eb1ff2d", + "0xe4e56ca0bf77730799e5cf31f9b07beb5c680c579b5faf6e85b416dd1630d6ca", + "0x264fd334482cd991fe9fdb7623cad50180d0b06de6729e192fb32f4e2f57cc87", + "0x59b679102df67de9cb66e5b918f900a75f47f81b0f3f1d9bb51e020ff77b2648", + "0xb393f7da6d1cd46c667a6fca3e8ce94fc096b6a7d3c16272cfa8a67e66b42abe" + ] + }, + "0x8e4933D9d82c1486F47808a761B2C21D1A0C3328": { + "index": 13, + "amount": "0x01", + "proof": [ + "0x4a251f65d356e81ea6df38755cffb496715f6dacc2cfbd4c8ee3ba96866b5145", + "0x4df0dc8a124513623569f3c7bb925ca6bb4ecb011f8b1322ee43f5b0949f9c7e", + "0x1f436ad7118f4f159680d84bdc6f0b371601e414e84d41056c04d8a132371be2", + "0x59b679102df67de9cb66e5b918f900a75f47f81b0f3f1d9bb51e020ff77b2648", + "0xb393f7da6d1cd46c667a6fca3e8ce94fc096b6a7d3c16272cfa8a67e66b42abe" + ] + }, + "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5": { + "index": 14, + "amount": "0x01", + "proof": [ + "0x3446d86d45c500dca1c1c0077bb6775955186e6944a19aeb90a96433e4db5091", + "0x4df0dc8a124513623569f3c7bb925ca6bb4ecb011f8b1322ee43f5b0949f9c7e", + "0x1f436ad7118f4f159680d84bdc6f0b371601e414e84d41056c04d8a132371be2", + "0x59b679102df67de9cb66e5b918f900a75f47f81b0f3f1d9bb51e020ff77b2648", + "0xb393f7da6d1cd46c667a6fca3e8ce94fc096b6a7d3c16272cfa8a67e66b42abe" + ] + }, + "0xAe6ecA6b0836e37d270722Ba81bB2EcacB674b08": { + "index": 15, + "amount": "0x01", + "proof": [ + "0x3300146976bbb79f3a07e230b887dd9db71c0f7c431d67d135db708968a20684", + "0xe3782de346656d51a87c4f2da5f63443c4189a2cab41824f0a347bb797e51128", + "0x1f436ad7118f4f159680d84bdc6f0b371601e414e84d41056c04d8a132371be2", + "0x59b679102df67de9cb66e5b918f900a75f47f81b0f3f1d9bb51e020ff77b2648", + "0xb393f7da6d1cd46c667a6fca3e8ce94fc096b6a7d3c16272cfa8a67e66b42abe" + ] + }, + "0xBadAb2F42f87378A05DE7FaF5e2bACe4AeB5fe59": { + "index": 16, + "amount": "0x01", + "proof": [ + "0x5e292d60be068ccd93a1bdeaeb5ca10e7542f54ee82d0bd84050f97c226f0d5c", + "0x23d430bbac9827582d0d6311751e6b3b1873d3536e0718018f0321a3d67f7f4e", + "0x98ef0af2093d8e79278c9e1410604ec213411fbace18bbdd652283cdea0ef422", + "0xfcbe889b70ee6a946a2361c0699670e5cb143a2a69027434bc08302dc9705ced", + "0xb393f7da6d1cd46c667a6fca3e8ce94fc096b6a7d3c16272cfa8a67e66b42abe" + ] + }, + "0xF9b45a3c3Ade1d975566Da21b262d3afaf611833": { + "index": 17, + "amount": "0x01", + "proof": [ + "0x8a38984c76d330ead32e2ab5d724f956274136ceca27d5c0505b423cab3b211f", + "0x9dac16cf671d42e1e03ff31e53b8c619d96cc5e56986426e8eb895e6fcfe05c4", + "0x9431984ab2ba4812a5f27f97b5bb5610c3af9c782b425ed0b1f8e256a827f5d1", + "0xfcbe889b70ee6a946a2361c0699670e5cb143a2a69027434bc08302dc9705ced", + "0xb393f7da6d1cd46c667a6fca3e8ce94fc096b6a7d3c16272cfa8a67e66b42abe" + ] + }, + "0xa243A7b4e9AF8D7e87a5443Aa7E21AB27624eaaA": { + "index": 18, + "amount": "0x01", + "proof": [ + "0xea080a43995d9bafd1f321196474f27acc2c2af34dce16da465a03a597017da8", + "0x367d8f3600a12849c4a1d5a3197b1a888cdb56e55d91ca11bcb1bfc767178f9d", + "0x8dde402fa6b95076b06a216ea6d59848a48a37ddd4b5b917c1a8e14ff090df96", + "0xf3804b5bf47fbfdb6dd791b00fa5ffe7c067dc4e6ec59931ffaaa0672b62b4b4" + ] + }, + "0xa2e3BdaE9569c89B13cD4407a87FD063253b84F8": { + "index": 19, + "amount": "0x01", + "proof": [ + "0x50208037ed3182f539890e429a3f3864204746b6edafd431c711895673cecf7d", + "0x86c3ab8459da8969909ca24b42a847145630f6f957b6667f7d2b6f8b4b5f19f8", + "0x98ef0af2093d8e79278c9e1410604ec213411fbace18bbdd652283cdea0ef422", + "0xfcbe889b70ee6a946a2361c0699670e5cb143a2a69027434bc08302dc9705ced", + "0xb393f7da6d1cd46c667a6fca3e8ce94fc096b6a7d3c16272cfa8a67e66b42abe" + ] + }, + "0xbCAFD7a10F18B873653f18f0021Ac0bd64B122bc": { + "index": 20, + "amount": "0x01", + "proof": [ + "0x9db57ac10058f0a2ed3f5598253fc5e1eda18e2cc3f6afbeade8fd4cddb02453", + "0xc3f9651a7e4c385ba27eac519459f831f4ac3efb102eb5f7b972baf3ad908c02", + "0x9431984ab2ba4812a5f27f97b5bb5610c3af9c782b425ed0b1f8e256a827f5d1", + "0xfcbe889b70ee6a946a2361c0699670e5cb143a2a69027434bc08302dc9705ced", + "0xb393f7da6d1cd46c667a6fca3e8ce94fc096b6a7d3c16272cfa8a67e66b42abe" + ] + }, + "0xe5A3F1e72D1dFa5C361516AC2779E9602106fEa6": { + "index": 21, + "amount": "0x01", + "proof": [ + "0xd82a6e9a12003fc735e9211923e0471c8e2c9095f8184af6c657563a0363957c", + "0xcf93298d6e00bd440cf0c2b230c78d934c47f324ced4a270555eb110a0fb8c69", + "0xce32dd594dc9e5662bb8622ab3a1072050ada4ea24446c1444d1f2c8dd955b0d", + "0xf3804b5bf47fbfdb6dd791b00fa5ffe7c067dc4e6ec59931ffaaa0672b62b4b4" + ] + }, + "0xeA459a5aA7e52F0493eDa1fAaE0B862C51bf40B9": { + "index": 22, + "amount": "0x01", + "proof": [ + "0xdf926f4666048d2ce60d7d8948114dd45f09e30e10d0ed3e49b8fb4ec916669c", + "0x8d6ee81df6ad4222d58ab28cadd8d71b3801bedb64073390a3079e01d84e2696", + "0x8dde402fa6b95076b06a216ea6d59848a48a37ddd4b5b917c1a8e14ff090df96", + "0xf3804b5bf47fbfdb6dd791b00fa5ffe7c067dc4e6ec59931ffaaa0672b62b4b4" + ] + }, + "0xeFFF9f68c79088D1efeEA73b03c84Ee422F09af2": { + "index": 23, + "amount": "0x01", + "proof": [ + "0x239403e2932af018a481186b9fdc77793c62314205e5b403d49d8a0f442171fc", + "0xe4e56ca0bf77730799e5cf31f9b07beb5c680c579b5faf6e85b416dd1630d6ca", + "0x264fd334482cd991fe9fdb7623cad50180d0b06de6729e192fb32f4e2f57cc87", + "0x59b679102df67de9cb66e5b918f900a75f47f81b0f3f1d9bb51e020ff77b2648", + "0xb393f7da6d1cd46c667a6fca3e8ce94fc096b6a7d3c16272cfa8a67e66b42abe" + ] + } + } + }, + { + "merkleRoot": "0xe849200cab05bce1504135caa830b2fbbaff3b2f8cf7160f43fc5eecdb49eb5c", + "tierIndex": 2, + "tokenTotal": "0x0a", + "claims": { + "0x56EE5F76aC69eC57c3cc927C9fE6F55156E09689": { + "index": 0, + "amount": "0x02", + "proof": [ + "0x8961144eff61900a087c1561beee4d166887248c56f50bc9aa217a480cc8b52a", + "0x5b6d68867fdba34a0a9c9bf46a46afebf9572dd6bc6ca30f47fb579d698cffd5", + "0xff5d17a2685cf715e297216a30b32fa43f0e65d16e13ff375c4666555b80d015" + ] + }, + "0xE1534865F30cE4829DC4A365B7006E5bb30488ea": { + "index": 1, + "amount": "0x02", + "proof": [ + "0x8aa57ad4a136ef3c0031ad8c43b3bc88aea30f586626c2199d9fa62593d89f47", + "0x084613a474deb889ad7c484ff3ab40e073186d0fd4acd3c34904af3aaa473dde", + "0xff5d17a2685cf715e297216a30b32fa43f0e65d16e13ff375c4666555b80d015" + ] + }, + "0xE4369C93E3E02529a11FC3F2d92b33D1c8efF2fc": { + "index": 2, + "amount": "0x02", + "proof": [ + "0x594c45f887c0942eb239b9b09d969b66a0afd2d5462858c27b10ae162add526c" + ] + }, + "0xb2986Fd5aC1B4F82C51A05cb07250D4D4a8f9F7F": { + "index": 3, + "amount": "0x02", + "proof": [ + "0xe54e396c7e710ebe02732916db0ea991714cf257e96787865a3d6137f6caee91", + "0x084613a474deb889ad7c484ff3ab40e073186d0fd4acd3c34904af3aaa473dde", + "0xff5d17a2685cf715e297216a30b32fa43f0e65d16e13ff375c4666555b80d015" + ] + }, + "0xdce59E0a0F6a1546bB6df4c124D81E37C7E7DC8A": { + "index": 4, + "amount": "0x02", + "proof": [ + "0x365d624a741929273cc5607e898d05f3b7940b1f40c84788dac1a3c777537f1f", + "0x5b6d68867fdba34a0a9c9bf46a46afebf9572dd6bc6ca30f47fb579d698cffd5", + "0xff5d17a2685cf715e297216a30b32fa43f0e65d16e13ff375c4666555b80d015" + ] + } + } + }, + { + "merkleRoot": "0x15f15b67ee274be77a7f349dbf10a30f1556277dd434e53075c6abf9e15d67a9", + "tierIndex": 10, + "tokenTotal": "0x0a", + "claims": { + "0x1aF9c1492A27e504CECaBA6A056cFF546ed6BAA4": { + "index": 0, + "amount": "0x02", + "proof": [ + "0xc14d8608f03e34803a59a777faa12b63638ba2751da171e6329fd50bcda8b7c6", + "0xf2b8bcf9f4639f61e3d97e4461d16fbfdcb9a37b09c88c0c67103ed57026b643", + "0xe5798f9d34702375b744d906d03c15953d193439f163b9a4fc1b634a01666cd5" + ] + }, + "0x580c2e2D85BCF99DD25517F181D22D00c2977960": { + "index": 1, + "amount": "0x02", + "proof": [ + "0x9fedf42fcb4902c62bef6817113538739b7d13e35583e2966b3b01783f197672", + "0x3f30afbf28b259d5a228f92f61c8c79cb3e6780afe9464fc04411244a52e7942", + "0xe5798f9d34702375b744d906d03c15953d193439f163b9a4fc1b634a01666cd5" + ] + }, + "0x8905469bFc17b82c7DE1B04d3AfeAdf4becB4dA0": { + "index": 2, + "amount": "0x02", + "proof": [ + "0x3bdc9d7313aa4788797763913ee181b16406919335f26eabc340e4dc0407f57b" + ] + }, + "0xB732ee8358661E2C38505D0dA6E60990cC18FFac": { + "index": 3, + "amount": "0x02", + "proof": [ + "0x841368c388d8402a011ee9fbff020b391e560c76602a55dfee9f24af645714bb", + "0x3f30afbf28b259d5a228f92f61c8c79cb3e6780afe9464fc04411244a52e7942", + "0xe5798f9d34702375b744d906d03c15953d193439f163b9a4fc1b634a01666cd5" + ] + }, + "0xDA3cf4d66FCe5B0e454CF176985b49E9441Eb853": { + "index": 4, + "amount": "0x02", + "proof": [ + "0xd14dd57b0f1ecbffc04af16525e894622e1fb85c9ed1a8c36a025c12442ac1c4", + "0xf2b8bcf9f4639f61e3d97e4461d16fbfdcb9a37b09c88c0c67103ed57026b643", + "0xe5798f9d34702375b744d906d03c15953d193439f163b9a4fc1b634a01666cd5" + ] + } + } + }, + { + "merkleRoot": "0xf8435aaa933ed93a77be913d52e58df560d40b849f6d1523494686ddb4aefce4", + "tierIndex": 2, + "tokenTotal": "0x0e", + "claims": { + "0x1BbbcA5ec8754991dBBC782b906D460e121DfC8a": { + "index": 0, + "amount": "0x02", + "proof": [ + "0x5553d261ffb8e39a320847ccb4a0d20dba3f34dcfb80179f7d3bf3968b73dc42", + "0x2d74a729aac74451cd8d71ffe0c7642804109c1690485032be58673af96d13ad", + "0xffa1bc08aac0baed2936d46bf65b535a19b26c959e538e66f1f827330fda8959" + ] + }, + "0x45b2466EF8ED0EB95CC6f68913e305e5c8b3F619": { + "index": 1, + "amount": "0x02", + "proof": [ + "0x0d3139621699d01f5258937678be3d22a5b0b48cf9990a3b806551738ae4acb3", + "0xafd7f3501f3939a543606cccb2d0aa80acb30c2c225249ec338f92307aa04283" + ] + }, + "0x5BC675Bb420b36848fA497dEc37d23dC1213Ae1e": { + "index": 2, + "amount": "0x02", + "proof": [ + "0x779620121960f3b85b597701ff1d2b9b0730ea613629fe0db43ae6fdb4f57789", + "0xaddbd7150b0cd5a1ac7c893eb2b727955633861d2e05ae0d2d3949dd60582313", + "0xafd7f3501f3939a543606cccb2d0aa80acb30c2c225249ec338f92307aa04283" + ] + }, + "0x5bDfb7C2Ab54C39665d54a1CB255B0dA5F5CcEbd": { + "index": 3, + "amount": "0x02", + "proof": [ + "0x2c623e95d5146797932653dd4ee0ceec2c658b71dbdf0ba529f6fb822d128e9d", + "0x04660f2d883fdcb9695e513d31bfc3a1dd5049bbae26a9362869ef0062974879", + "0xffa1bc08aac0baed2936d46bf65b535a19b26c959e538e66f1f827330fda8959" + ] + }, + "0x73FBb872BbfE6a2ece48aFb9cD4A07Aa2e30Bc91": { + "index": 4, + "amount": "0x02", + "proof": [ + "0xaa0a9905b784fc99e6198e37c8decfb6acb7f3a9033097de131abe3eee78c8e3", + "0xaddbd7150b0cd5a1ac7c893eb2b727955633861d2e05ae0d2d3949dd60582313", + "0xafd7f3501f3939a543606cccb2d0aa80acb30c2c225249ec338f92307aa04283" + ] + }, + "0xA6c35B68B53AC162926a0b3C1d283bdb286C6313": { + "index": 5, + "amount": "0x02", + "proof": [ + "0x0c133129ad2ac83a7e8403d313816b6778f649cdf42617cc48a4d2c10d826ad2", + "0x04660f2d883fdcb9695e513d31bfc3a1dd5049bbae26a9362869ef0062974879", + "0xffa1bc08aac0baed2936d46bf65b535a19b26c959e538e66f1f827330fda8959" + ] + }, + "0xDEB8bFd019e84C141A01e192A73701B9BCa9059C": { + "index": 6, + "amount": "0x02", + "proof": [ + "0x3122e0e5504e584797fb6434fa2a17254fe7d87187d344833888de61747e0fc8", + "0x2d74a729aac74451cd8d71ffe0c7642804109c1690485032be58673af96d13ad", + "0xffa1bc08aac0baed2936d46bf65b535a19b26c959e538e66f1f827330fda8959" + ] + } + } + }, + { + "merkleRoot": "0x9537daf3b2e454f886f8b94e492301b7efaff879b6eab21b5fc566f36311387e", + "tierIndex": 10, + "tokenTotal": "0x0e", + "claims": { + "0x0b48b16F3596C467fB79c8Ff3336Cab6d59a7a43": { + "index": 0, + "amount": "0x02", + "proof": [ + "0x87ef290bf1251a255f699819bfcfa69fd7d10bc0e6197b83754be3dd82bd799b", + "0xe5052f333b6208cba889470854b58e3f001b0e36f6e8aa3dc1927977fa51f257", + "0x456af114e2bcbfb55e78dac005888f4527017026b8602d40ead2541b136ef526" + ] + }, + "0x3A8b8dEE36009D41c916F0Fb1795A3bAcc956Aa6": { + "index": 1, + "amount": "0x02", + "proof": [ + "0x40e5ebd9e792d5fe7cb3074e2e0b27696cc56bfe15d8dcd311d03da9f9b94662", + "0x7e62aafa8927f05cbfdb3cbcb199d287bf50be0704a1bdfcaf345748a93897a9", + "0x65cbdfdb67d7a8f6c00d6f824376d0f5b8850b004c052bb9b004ab650016126f" + ] + }, + "0x4CefA0c65153A30fDAe1efb420D948D11117B997": { + "index": 2, + "amount": "0x02", + "proof": [ + "0x227d57a314e49f821125d464080c196fcf3a370af255cc358c33d959fa8a6fab", + "0x456af114e2bcbfb55e78dac005888f4527017026b8602d40ead2541b136ef526" + ] + }, + "0x520531a6AEe34468a3503d3d3E03e245FbfAaC73": { + "index": 3, + "amount": "0x02", + "proof": [ + "0xe4893ea6cbcba5525526d0d694093eaffe3f35d8ce38d9c15acf13fcefa6d0d0", + "0xe5052f333b6208cba889470854b58e3f001b0e36f6e8aa3dc1927977fa51f257", + "0x456af114e2bcbfb55e78dac005888f4527017026b8602d40ead2541b136ef526" + ] + }, + "0x9F17aB623bcdb937FfC13Ea01F1FD8939e72Bbdd": { + "index": 4, + "amount": "0x02", + "proof": [ + "0x733029015e3e1b4679d8e5038a252f888ae43110668111dba97d708607b00b6d", + "0x41c2ade7e4175d4e4ba92f9d5dc2f64371291975fbb720ea88ebe2b9ca1d70c0", + "0x65cbdfdb67d7a8f6c00d6f824376d0f5b8850b004c052bb9b004ab650016126f" + ] + }, + "0xB8542E6e91B417AE0fe8B3bf9Aa930181DafEDb1": { + "index": 5, + "amount": "0x02", + "proof": [ + "0x7b314e840a61884cba4506c7f992c000bb1e9d934e27524ce94bbb9d2a861806", + "0x41c2ade7e4175d4e4ba92f9d5dc2f64371291975fbb720ea88ebe2b9ca1d70c0", + "0x65cbdfdb67d7a8f6c00d6f824376d0f5b8850b004c052bb9b004ab650016126f" + ] + }, + "0xE8dFfeB0b0aDC10180ef032889e9b33191D6392D": { + "index": 6, + "amount": "0x02", + "proof": [ + "0x4b198de4204fd4d8cd95beef79d75cea0487a7804690330f4dda1d3f08de4322", + "0x7e62aafa8927f05cbfdb3cbcb199d287bf50be0704a1bdfcaf345748a93897a9", + "0x65cbdfdb67d7a8f6c00d6f824376d0f5b8850b004c052bb9b004ab650016126f" + ] + } + } + }, + { + "merkleRoot": "0x6a2f48dca231570185c3262514f786aecc82ec0ad96287c79035159cb98d059e", + "tierIndex": 10, + "tokenTotal": "0x05", + "claims": { + "0xc756Be144729EcDBE51f49073D295ABd318f0048": { + "index": 0, + "amount": "0x05", + "proof": [] + } + } + } +] diff --git a/deployments/polygon_mumbai/AaveFacet.json b/deployments/polygon_mumbai/AaveFacet.json new file mode 100644 index 000000000..d061469b8 --- /dev/null +++ b/deployments/polygon_mumbai/AaveFacet.json @@ -0,0 +1,254 @@ +{ + "address": "0x61504A238e2DD5f6a6D027384816d8C944fe78b0", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "AaveFacet", + "transactionHash": "0x6e10eeea080c76b699951223e3ada2bfffca72e926c58f313f5e294bc4bad048", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x61504A238e2DD5f6a6D027384816d8C944fe78b0", + "transactionIndex": 0, + "gasUsed": "1134361", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000002000000000000000000000000000000000000000000000000000800100000000000000040100000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000040000000004000000000000100000001000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0xb2bd5dae6713cfa4a54722f926d734f5c34ca8adb15a038117339cd7a41e026a", + "transactionHash": "0x6e10eeea080c76b699951223e3ada2bfffca72e926c58f313f5e294bc4bad048", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692489, + "transactionHash": "0x6e10eeea080c76b699951223e3ada2bfffca72e926c58f313f5e294bc4bad048", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000c275dc8be39f50d12f66b6a63629c39da5bae5bd" + ], + "data": "0x0000000000000000000000000000000000000000000000000078e6dc0d8fcc000000000000000000000000000000000000000000000000003ad2626f6be32c000000000000000000000000000000000000000000000000b4171b6f9b9a6a8dd50000000000000000000000000000000000000000000000003a597b935e5360000000000000000000000000000000000000000000000000b417945677a7fa59d5", + "logIndex": 0, + "blockHash": "0xb2bd5dae6713cfa4a54722f926d734f5c34ca8adb15a038117339cd7a41e026a" + } + ], + "blockNumber": 15692489, + "cumulativeGasUsed": "1134361", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"aTokenAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"aTokenBalanceBeforeDeposit\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"aTokenBalanceAfterDeposit\",\"type\":\"uint256\"}],\"name\":\"AaveDeposited\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"aTokenAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"aTokenBalanceBeforeDeposit\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"aTokenBalanceAfterWithdrawal\",\"type\":\"uint256\"}],\"name\":\"AaveWithdrawn\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"aaveDeposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"aaveWithdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"}],\"name\":\"aaveWithdrawAll\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"AaveDeposited(address,address,uint256,uint256,uint256)\":{\"params\":{\"aTokenAddress\":\"aave token address.\",\"aTokenBalanceAfterDeposit\":\"aTokens balance after Deposit.\",\"aTokenBalanceBeforeDeposit\":\"aTokens balance after Deposit.\",\"amount\":\"amount of tokens to Deposit.\",\"tokenAddress\":\"address of the underlying token.\"}},\"AaveWithdrawn(address,address,uint256,uint256,uint256)\":{\"params\":{\"aTokenAddress\":\"aave token address.\",\"aTokenBalanceAfterWithdrawal\":\"aTokens balance after Withdrawal.\",\"aTokenBalanceBeforeDeposit\":\"aTokens balance after Withdrawal.\",\"amount\":\"amount of tokens to Withdrawal.\",\"tokenAddress\":\"address of the underlying token.\"}}},\"kind\":\"dev\",\"methods\":{\"aaveDeposit(uint256,address,uint256)\":{\"params\":{\"amount\":\"amount of tokens to deposit\",\"loanID\":\"id of the loan being used in the dapp\",\"tokenAddress\":\"address of the token\"}},\"aaveWithdraw(uint256,address,uint256)\":{\"params\":{\"amount\":\"amount of the underlying tokens to withdraw\",\"loanID\":\"id of the loan being used in the dapp\",\"tokenAddress\":\"address of the token\"}},\"aaveWithdrawAll(uint256,address)\":{\"params\":{\"loanID\":\"id of the loan being used in the dapp\",\"tokenAddress\":\"address of the token\"}}},\"version\":1},\"userdoc\":{\"events\":{\"AaveDeposited(address,address,uint256,uint256,uint256)\":{\"notice\":\"This event is emitted every time Aave deposit is invoked successfully.\"},\"AaveWithdrawn(address,address,uint256,uint256,uint256)\":{\"notice\":\"This event is emitted every time Aave redeem is invoked successfully.\"}},\"kind\":\"user\",\"methods\":{\"aaveDeposit(uint256,address,uint256)\":{\"notice\":\"The deposit, the aToken needs to be approved to have access to the token balance\"},\"aaveWithdraw(uint256,address,uint256)\":{\"notice\":\"This function withdraws the user's aTokens for a specific amount\"},\"aaveWithdrawAll(uint256,address)\":{\"notice\":\"This function withdraws all the user's aTokens from previous deposits\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/escrow/dapps/AaveFacet.sol\":\"AaveFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/dapps/AaveFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Storage\\nimport { DappMods } from \\\"./DappMods.sol\\\";\\nimport { PausableMods } from \\\"../../settings/pausable/PausableMods.sol\\\";\\nimport { LibDapps } from \\\"./libraries/LibDapps.sol\\\";\\nimport { LibEscrow, ILoansEscrow } from \\\"../libraries/LibEscrow.sol\\\";\\nimport { IAToken } from \\\"../../shared/interfaces/IAToken.sol\\\";\\nimport { IAaveLendingPool } from \\\"../../shared/interfaces/IAaveLendingPool.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\ncontract AaveFacet is PausableMods, DappMods {\\n using SafeERC20 for IERC20;\\n /**\\n @notice This event is emitted every time Aave deposit is invoked successfully.\\n @param tokenAddress address of the underlying token.\\n @param aTokenAddress aave token address.\\n @param amount amount of tokens to Deposit.\\n @param aTokenBalanceBeforeDeposit aTokens balance after Deposit.\\n @param aTokenBalanceAfterDeposit aTokens balance after Deposit.\\n */\\n event AaveDeposited(\\n address indexed tokenAddress,\\n address indexed aTokenAddress,\\n uint256 amount,\\n uint256 aTokenBalanceBeforeDeposit,\\n uint256 aTokenBalanceAfterDeposit\\n );\\n\\n /**\\n @notice This event is emitted every time Aave redeem is invoked successfully.\\n @param tokenAddress address of the underlying token.\\n @param aTokenAddress aave token address.\\n @param amount amount of tokens to Withdrawal.\\n @param aTokenBalanceBeforeDeposit aTokens balance after Withdrawal.\\n @param aTokenBalanceAfterWithdrawal aTokens balance after Withdrawal.\\n */\\n event AaveWithdrawn(\\n address indexed tokenAddress,\\n address indexed aTokenAddress,\\n uint256 amount,\\n uint256 aTokenBalanceBeforeDeposit,\\n uint256 aTokenBalanceAfterWithdrawal\\n );\\n\\n /**\\n @notice The deposit, the aToken needs to be approved to have access to the token balance\\n @param loanID id of the loan being used in the dapp\\n @param tokenAddress address of the token\\n @param amount amount of tokens to deposit\\n */\\n function aaveDeposit(\\n uint256 loanID,\\n address tokenAddress,\\n uint256 amount\\n ) public paused(\\\"\\\", false) onlyBorrower(loanID) {\\n ILoansEscrow escrow = LibEscrow.e(loanID);\\n\\n IAaveLendingPool aaveLendingPool = LibDapps.getAaveLendingPool();\\n escrow.setTokenAllowance(tokenAddress, address(aaveLendingPool));\\n IAToken aToken = LibDapps.getAToken(tokenAddress);\\n uint256 aTokenBalanceBeforeDeposit = aToken.balanceOf(address(escrow));\\n\\n bytes memory callData = abi.encodeWithSelector(\\n aaveLendingPool.deposit.selector,\\n tokenAddress,\\n amount,\\n address(escrow),\\n 0\\n );\\n escrow.callDapp(address(aaveLendingPool), callData);\\n\\n uint256 aTokenBalanceAfterDeposit = aToken.balanceOf(address(escrow));\\n require(\\n aTokenBalanceAfterDeposit > aTokenBalanceBeforeDeposit,\\n \\\"AAVE_BALANCE_NOT_INCREASED\\\"\\n );\\n\\n LibEscrow.tokenUpdated(loanID, address(aToken));\\n LibEscrow.tokenUpdated(loanID, tokenAddress);\\n\\n emit AaveDeposited(\\n tokenAddress,\\n address(aToken),\\n amount,\\n aTokenBalanceBeforeDeposit,\\n aTokenBalanceAfterDeposit\\n );\\n }\\n\\n /**\\n @notice This function withdraws the user's aTokens for a specific amount\\n @param loanID id of the loan being used in the dapp\\n @param tokenAddress address of the token\\n @param amount amount of the underlying tokens to withdraw\\n */\\n function aaveWithdraw(\\n uint256 loanID,\\n address tokenAddress,\\n uint256 amount\\n ) public paused(\\\"\\\", false) onlyBorrower(loanID) {\\n ILoansEscrow escrow = LibEscrow.e(loanID);\\n\\n IAToken aToken = LibDapps.getAToken(tokenAddress);\\n IAaveLendingPool aaveLendingPool = LibDapps.getAaveLendingPool();\\n uint256 aTokenBalanceBeforeWithdraw = aToken.balanceOf(address(escrow));\\n require(\\n aTokenBalanceBeforeWithdraw >= amount,\\n \\\"NO_BALANCE_TO_WITHDRAW\\\"\\n );\\n\\n bytes memory callData = abi.encodeWithSelector(\\n aaveLendingPool.withdraw.selector,\\n tokenAddress,\\n amount,\\n address(escrow)\\n );\\n LibDapps.s().loanEscrows[loanID].callDapp(\\n address(aaveLendingPool),\\n callData\\n );\\n\\n uint256 aTokenBalanceAfterWithdraw = aToken.balanceOf(address(escrow));\\n require(\\n aTokenBalanceAfterWithdraw < aTokenBalanceBeforeWithdraw,\\n \\\"AAVE_WITHDRAWAL_ERROR\\\"\\n );\\n\\n LibEscrow.tokenUpdated(loanID, address(aToken));\\n LibEscrow.tokenUpdated(loanID, tokenAddress);\\n\\n emit AaveWithdrawn(\\n tokenAddress,\\n address(aToken),\\n amount,\\n aTokenBalanceBeforeWithdraw,\\n aTokenBalanceAfterWithdraw\\n );\\n }\\n\\n /**\\n @notice This function withdraws all the user's aTokens from previous deposits\\n @param loanID id of the loan being used in the dapp\\n @param tokenAddress address of the token\\n */\\n function aaveWithdrawAll(uint256 loanID, address tokenAddress)\\n public\\n paused(\\\"\\\", false)\\n onlyBorrower(loanID)\\n {\\n ILoansEscrow escrow = LibEscrow.e(loanID);\\n IAToken aToken = LibDapps.getAToken(tokenAddress);\\n\\n uint256 aTokenBalanceBeforeWithdraw = aToken.balanceOf(address(escrow));\\n require(aTokenBalanceBeforeWithdraw >= 0, \\\"NO_BALANCE_TO_WITHDRAW\\\");\\n\\n IAaveLendingPool aaveLendingPool = LibDapps.getAaveLendingPool();\\n\\n bytes memory callData = abi.encodeWithSelector(\\n aaveLendingPool.withdraw.selector,\\n tokenAddress,\\n aTokenBalanceBeforeWithdraw,\\n address(escrow)\\n );\\n escrow.callDapp(address(aaveLendingPool), callData);\\n\\n uint256 aTokenBalanceAfterWithdraw = aToken.balanceOf(address(escrow));\\n\\n LibEscrow.tokenUpdated(loanID, address(aToken));\\n LibEscrow.tokenUpdated(loanID, tokenAddress);\\n\\n emit AaveWithdrawn(\\n tokenAddress,\\n address(aToken),\\n aTokenBalanceBeforeWithdraw,\\n aTokenBalanceBeforeWithdraw,\\n aTokenBalanceAfterWithdraw\\n );\\n }\\n}\\n\",\"keccak256\":\"0x73f2d61910146290a223c8b8f65632c58985a276f32f8069b9391485c5c874d5\",\"license\":\"MIT\"},\"contracts/escrow/dapps/DappMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\n\\nabstract contract DappMods {\\n /**\\n * @notice it checks if the caller to a respective loan escrow is the borrower\\n * @param loanID uint256 of the respective loan escrow\\n */\\n modifier onlyBorrower(uint256 loanID) {\\n require(\\n msg.sender == LibLoans.loan(loanID).borrower,\\n \\\"Teller: dapp not loan borrower\\\"\\n );\\n _;\\n }\\n \\n /**\\n * @notice checks if the respective loan escrow is secure\\n * @param loanID uint256 of the respective loan escrow\\n */\\n modifier onlySecured(uint256 loanID) {\\n require(\\n LibLoans.loan(loanID).collateralRatio >=\\n PlatformSettingsLib.getCollateralBufferValue(),\\n \\\"Teller: dapp loan not secured\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x11be4385bca09e22c5dd9ced04e779302f3cc4f8102742abd0b5de5a6029ac85\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../../../shared/interfaces/IAToken.sol\\\";\\nimport {\\n IAaveLendingPool\\n} from \\\"../../../shared/interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../../../shared/interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xd05e3E715d945B59290df0ae8eF85c1BdB684744 // Polygon mainnet\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x4c18d46f924a3a24d596971d39857477b618dad13dee55decc271bdccf915ee5\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n /**\\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\\n * @param dappAddress address of the target contract address\\n * @param dappData encoded abi of the function in our contract we want to call\\n * @return the called data in bytes\\n */\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n /**\\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\\n * @param token address of the respective ERC20 token to approve for the spender\\n * @param spender address of the respective spender who is approved by the token contract\\n */\\n function setTokenAllowance(address token, address spender) external;\\n\\n /**\\n * @notice it allows user to claim their escrow tokens\\n * @dev only the owner (TellerDiamond) can make this call on behalf of the users\\n * @param token address of the respective token contract to claim tokens from\\n * @param to address where the tokens should be transferred to\\n * @param amount uint256 amount of tokens to be claimed\\n */\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xaf67fc4454ffaa4d2f7e46fe7101876e8ebdb1a5426c30f87b8e18cc573ac019\",\"license\":\"MIT\"},\"contracts/escrow/libraries/LibEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibDapps } from \\\"../dapps/libraries/LibDapps.sol\\\";\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibEscrow {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\\n e_ = s().loanEscrows[loanID];\\n }\\n\\n /**\\n * @notice It returns a list of tokens owned by a loan escrow\\n * @param loanID uint256 index used to return our token list\\n * @return t_ which is a list of tokens \\n */\\n function getEscrowTokens(uint256 loanID)\\n internal\\n view\\n returns (EnumerableSet.AddressSet storage t_)\\n {\\n t_ = s().escrowTokens[loanID];\\n }\\n\\n /**\\n * @notice It returns the balance of a respective token in a loan escrow\\n * @param loanID uint256 index used to point to our loan escrow\\n * @param token address of respective token to give us the balance of in our loan escrow\\n * @return uint256 balance of respective token returned in an escrow loan\\n */\\n function balanceOf(uint256 loanID, address token)\\n internal\\n view\\n returns (uint256)\\n {\\n return IERC20(token).balanceOf(address(e(loanID)));\\n }\\n\\n /**\\n * @notice Adds or removes tokens held by the Escrow contract\\n * @param loanID The loan ID to update the token list for\\n * @param tokenAddress The token address to be added or removed\\n */\\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\\n // Skip if is lending token\\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\\n\\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\\n if (balanceOf(loanID, tokenAddress) > 0) {\\n if (!contains) {\\n EnumerableSet.add(tokens, tokenAddress);\\n }\\n } else if (contains) {\\n EnumerableSet.remove(tokens, tokenAddress);\\n }\\n }\\n\\n /**\\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\\n * @param loanID The loan ID to calculate value for\\n * @return value_ Escrow total value denoted in the lending token.\\n */\\n function calculateTotalValue(uint256 loanID)\\n internal\\n view\\n returns (uint256 value_)\\n {\\n address lendingToken = LibLoans.loan(loanID).lendingToken;\\n value_ += balanceOf(loanID, lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\\n if (EnumerableSet.length(tokens) > 0) {\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n uint256 tokenBal =\\n balanceOf(loanID, EnumerableSet.at(tokens, i));\\n value_ += PriceAggLib.valueFor(\\n EnumerableSet.at(tokens, i),\\n lendingToken,\\n tokenBal\\n );\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x17a7c6b11d6f280948e320525d1e131b89c23f80216918aa070df437a851d915\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when a user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when a user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n * @return ERC20 token\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n * @return balance_ the balance of the account\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice It calculates the total supply of the underlying asset.\\n * @return totalSupply_ the total supply denoted in the underlying asset.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given market.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n \\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfill the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n * @return mintAmount_ the amount minted of the specified token\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n * @return address of the strategy contract\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n * @param state boolean value that resembles the platform's state\\n */\\n function restrict(bool state) external virtual;\\n\\n /**\\n * @notice it initializes the Teller Token\\n * @param admin address of the admin to the respective Teller Token\\n * @param underlying address of the ERC20 token\\n */\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xf30ac4ef491851477ff9a3dd04974ebe74b529c37a3ef4e05798c3f734ceeb3d\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n /**\\n * @notice it initializes an escrow\\n * @param tokenAddress the address of the collateral token to be stored\\n * @param isWETH check if it's wrapped Ethereum\\n */\\n function init(address tokenAddress, bool isWETH) external;\\n\\n /**\\n * @notice it deposits an amount of the respective collateral token into the escrow\\n * @param loanID the ID of the loan\\n * @param amount the amount of collateral tokens to be deposited\\n */\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n /**\\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\\n * @dev only the TellerDiamond can make this call on behalf of the borrower\\n * @param loanID identifier of the loan\\n * @param amount number of collateral tokens to send\\n * @param receiver payable address to transfer money to\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n /**\\n * @notice it returns the supply of the respective loan\\n * @param loanID the respective loan ID\\n * @return supply_ the amount in collateral of the respective loan\\n */\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n /**\\n * @notice it returns the total supply of the collateral token held by the contract\\n * @return supply_ the total amount of collateral\\n */\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x900fed2311f919ba1451a6583ddbf9f3bc8afa8f5189500fff51f0c049258ed3\",\"license\":\"MIT\"},\"contracts/market/libraries/LibLoans.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibEscrow } from \\\"../../escrow/libraries/LibEscrow.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus,\\n LoanDebt,\\n LoanTerms\\n} from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibLoans {\\n using NumbersLib for int256;\\n using NumbersLib for uint256;\\n\\n bytes32 internal constant ID = keccak256(\\\"LOANS\\\");\\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n * @notice it returns the loan\\n * @param loanID the ID of the respective loan\\n * @return l_ the loan\\n */\\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\\n l_ = s().loans[loanID];\\n }\\n\\n /**\\n * @notice it returns the loan debt from a respective loan\\n * @param loanID the ID of the respective loan\\n * @return d_ the loan debt from a respective loan\\n */\\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\\n d_ = s().loanDebt[loanID];\\n }\\n\\n // DEPRECATED\\n function terms(uint256 loanID)\\n internal\\n view\\n returns (LoanTerms storage t_)\\n {\\n t_ = s()._loanTerms[loanID];\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return owed_ uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID)\\n internal\\n view\\n returns (uint256 owed_)\\n {\\n if (loan(loanID).status == LoanStatus.Active) {\\n owed_ = debt(loanID).principalOwed + (debt(loanID).interestOwed);\\n }\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n internal\\n view\\n returns (uint256)\\n {\\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\\n }\\n\\n function getCollateralNeeded(uint256 loanID)\\n internal\\n view\\n returns (uint256 _needed)\\n {\\n (, _needed, ) = getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the total collateral needed in lending tokens, in collateral tokens and in escrowed loan values\\n * @param loanID the loanID to get the total collateral needed\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n internal\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\\n loanID\\n );\\n\\n // check if needed lending tokens is zero. if true, then needed collateral tokens is zero. else,\\n if (neededInLendingTokens == 0) {\\n neededInCollateralTokens = 0;\\n } else {\\n neededInCollateralTokens = PriceAggLib.valueFor(\\n loan(loanID).lendingToken,\\n loan(loanID).collateralToken,\\n neededInLendingTokens\\n );\\n }\\n }\\n\\n /**\\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\\n * @param loanID The loan ID to get needed collateral info for.\\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\\n */\\n function getCollateralNeededInTokens(uint256 loanID)\\n internal\\n view\\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\\n {\\n if (loan(loanID).collateralRatio == 0) {\\n return (0, 0);\\n }\\n\\n /*\\n The collateral to principal owed ratio is the sum of:\\n * collateral buffer percent\\n * loan interest rate\\n * liquidation reward percent\\n * X factor of additional collateral\\n */\\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n neededInLendingTokens = loan(loanID).borrowedAmount.percent(\\n loan(loanID).collateralRatio\\n );\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n uint16 requiredRatio =\\n loan(loanID).collateralRatio -\\n getInterestRatio(loanID) -\\n uint16(PlatformSettingsLib.getCollateralBufferValue());\\n\\n neededInLendingTokens =\\n debt(loanID).principalOwed +\\n debt(loanID).interestOwed;\\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\\n if (\\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\\n ) {\\n neededInLendingTokens -= escrowLoanValue;\\n }\\n neededInLendingTokens = neededInLendingTokens.percent(\\n requiredRatio\\n );\\n }\\n }\\n\\n /**\\n * @notice check if a loan can go to end of auction with a collateral ratio\\n * @return bool checking if collateralRatio is >= the over collateralized buffer value\\n */\\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\\n internal\\n view\\n returns (bool)\\n {\\n return\\n collateralRatio >=\\n PlatformSettingsLib.getOverCollateralizedBufferValue();\\n }\\n\\n /**\\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\\n * @notice There is a minimum threshold of 1%.\\n * @dev The interest rate is APY (annual percentage yield).\\n * @param loanID The loan ID to get the interest rate for.\\n */\\n function getInterestRatio(uint256 loanID)\\n internal\\n view\\n returns (uint16 ratio_)\\n {\\n ratio_ = uint16(\\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\\n SECONDS_PER_YEAR\\n );\\n\\n if (ratio_ == 0) {\\n ratio_ = 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0xaabb82718f6948669e5c984d7bdc0d0ae4806e3b17beba4dd60e771d67444c07\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x417b75f5d92be67993efc54db7d453be5b5058a9a54d8916380e0281d3299526\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param amount Amount of the source token to convert into the destination token.\\n * @param exchangeRate The calculated exchange rate between the tokens.\\n * @return uint256 Value of the source token amount given an exchange rate peg.\\n */\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n /**\\n * @notice it returns 10^{numberOfDecimals} for a token\\n * @param token the address to calculate the decimals for\\n * @return 10^number of decimals used to calculate the price and value of different token pairs\\n */\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @notice It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @notice it tries to calculate a price from Compound and Chainlink.\\n * @dev if no price is found on compound, then calculate it on chainlink\\n * @param src the token address to calculate the price for in dst\\n * @param dst the token address to retrieve the price of src\\n * @return price_ the price of src in dst\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n * @param src the address of the src token\\n * @param dst the address of the dst token\\n * @return the price of the src token in dst token\\n\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n * @param src the source token to calculate price for with chainlink\\n * @param dst the destination token to calculate price for with chainlink\\n * @param cRate the compound rate to multiply with the price of the dst token\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @notice Scales the {value} by the difference in decimal values.\\n * @param value the the value of the src in dst\\n * @param srcDecimals src token decimals\\n * @param dstDecimals dst token decimals\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @notice it tries to calculate the price of {src} in {dst}\\n * @param src address of source token\\n * @param dst address of destination token\\n * @return the price of src token in dst\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address wrappedNativeToken =\\n AppStorageLib.store().wrappedNativeToken;\\n if (dst != wrappedNativeToken) {\\n int256 price1 = _priceFor(src, wrappedNativeToken);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, wrappedNativeToken);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice it checks if a token is a cToken. If it is, then get the underlying address\\n * @param token address of the token\\n * @return isCToken boolean whether it's a cToken\\n * @return underlying the address of the cToken\\n */\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xcf6280e2d36fdedbca4c0b94e413832f4bb267202de235bfc1cf6fda26c780ec\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { PriceAggFacet } from \\\"./PriceAggFacet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\n/**\\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\\n */\\nlibrary PriceAggLib {\\n /**\\n * @notice It calculates the value of one token amount into another\\n * @param src the source token\\n * @param dst the destination token\\n * @param srcAmount the amount of source token\\n * @return value_ the returned value of src in dst\\n */\\n function valueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) internal view returns (uint256 value_) {\\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\\n }\\n\\n /**\\n * @notice It returns the price of the token pair as given from Compound.\\n * @dev if no compound price is calculated, then it checks Chainlink price Aggregator\\n * @param src the address of the source token\\n * @param dst the address of the desitnation token\\n * @return price_ gets the price of src in dst\\n */\\n function priceFor(address src, address dst)\\n internal\\n view\\n returns (int256 price_)\\n {\\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\\n }\\n}\\n\",\"keccak256\":\"0xff59eee567fa4a7f5cac432e31d918be92834f04614f49572d3984a5b030ac79\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\nabstract contract PausableMods {\\n /**\\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\\n * @param id id of the facet to check if is paused.\\n * @param state Boolean that the protocol AND facet should be in.\\n */\\n modifier paused(bytes32 id, bool state) {\\n require(\\n __isPaused(\\\"\\\") == state && __isPaused(id) == state,\\n __pausedMessage(state)\\n );\\n _;\\n }\\n\\n /**\\n * @dev Checks if the given id is paused.\\n * @param id Encoded id of the facet to check if is paused.\\n * @return the bool to tell us if the facet is paused (true) or not (false)\\n */\\n function __isPaused(bytes32 id) private view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n\\n /**\\n * @dev Gets the message that should be reverted with given a state it should be in.\\n * @param state Boolean that an id should be in.\\n * @return a message stating whether the facet is paused or not\\n */\\n function __pausedMessage(bool state) private pure returns (string memory) {\\n return state ? \\\"Pausable: not paused\\\" : \\\"Pausable: paused\\\";\\n }\\n}\\n\",\"keccak256\":\"0x2d3f848ee56ae5fa365539c2509c03c167affc89c89f98bb98cb9b83fbe8ae4c\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"NFTInterestRate\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getNFTInterestRate() internal view returns (uint16 value_) {\\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0x44294be1af9f913b2ed391a40cd4b646537a4b463b8d5ff1fac8ead3988966c1\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for loans taken out with an NFT.\\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\\n */\\nbytes32 constant NFT_INTEREST_RATE = keccak256(\\\"NFTInterestRate\\\");\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xd68a7df42b2bbba6f935d5890b7b37997c1432e25ae113827b8bde87f94fd86f\",\"license\":\"MIT\"},\"contracts/shared/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n /**\\n * @notice Checks if the account should be allowed to mint tokens in the given market\\n * @param cToken The market to verify the mint against\\n * @param minter The account which would get the minted tokens\\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates mint and reverts on rejection. May emit logs.\\n * @param cToken Asset being minted\\n * @param minter The address minting the tokens\\n * @param mintAmount The amount of the underlying asset being minted\\n * @param mintTokens The number of tokens being minted\\n */\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to redeem tokens in the given market\\n * @param cToken The market to verify the redeem against\\n * @param redeemer The account which would redeem the tokens\\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates redeem and reverts on rejection. May emit logs.\\n * @param cToken Asset being redeemed\\n * @param redeemer The address redeeming the tokens\\n * @param redeemAmount The amount of the underlying asset being redeemed\\n * @param redeemTokens The number of tokens being redeemed\\n */\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\\n * @param cToken The market to verify the borrow against\\n * @param borrower The account which would borrow the asset\\n * @param borrowAmount The amount of underlying the account would borrow\\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates borrow and reverts on rejection. May emit logs.\\n * @param cToken Asset whose underlying is being borrowed\\n * @param borrower The address borrowing the underlying\\n * @param borrowAmount The amount of the underlying asset requested to borrow\\n */\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to repay a borrow in the given market\\n * @param cToken The market to verify the repay against\\n * @param payer The account which would repay the asset\\n * @param borrower The account which would borrowed the asset\\n * @param repayAmount The amount of the underlying asset the account would repay\\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\\n * @param cToken Asset being repaid\\n * @param payer The address repaying the borrow\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param borrowerIndex the index of the borrower\\n */\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n /**\\n * @notice Checks if the liquidation should be allowed to occur\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n */\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the seizing of assets should be allowed to occur\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates seize and reverts on rejection. May emit logs.\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to transfer tokens in the given market\\n * @param cToken The market to verify the transfer against\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates transfer and reverts on rejection. May emit logs.\\n * @param cToken Asset being transferred\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n */\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in all markets\\n * @param holder The address to claim COMP for\\n */\\n function claimComp(address holder) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in the specified markets\\n * @param holder The address to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n */\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n /**\\n * @notice Claim all comp accrued by the holders\\n * @param holders The addresses to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n * @param borrowers Whether or not to claim COMP earned by borrowing\\n * @param suppliers Whether or not to claim COMP earned by supplying\\n */\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n /**\\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\\n * @param cTokenBorrowed The address of the borrowed cToken\\n * @param cTokenCollateral The address of the collateral cToken\\n * @param repayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\\n */\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n /**\\n * @notice Return the address of the COMP token\\n * @return The address of COMP\\n */\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x38a824a4a21ce9370fa581a616d1bb9d311f27d8982a6b96ebeba90bd5fd0adb\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n\\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x208769886b3db8f03ef1fa26f1caee189038dfc744b9a499402fc4e4c0090c38\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @dev CETH is the only Compound token that does not support the {underlying} function.\\n * @param cToken address of the compound token\\n * @return address of the underlying cToken\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x99206384c27b0e68b1ec7b82260f6a47965f611875c018bc076ff8a688a6c6d7\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n /**\\n * @notice it returns the absolute number of a specified parameter\\n * @param self the number to be returned in it's absolute\\n * @return the absolute number\\n */\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0x4f750cde25d4b1db919abf3192d58ed6aef617d03637e1e9e2dc31b70dcc32a3\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n address wrappedNativeToken;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4504c5c460972a25cd1f0e6eb1d8dd84a668be75a3aeb89a47a49c2327c12923\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\n// DEPRECATED\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\nstruct LoanRequest {\\n LoanUserRequest request;\\n LoanConsensusResponse[] responses;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanUserRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanConsensusResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) _loanTerms; // DEPRECATED: DO NOT REMOVE\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb7e05aeec806b5621512def93f4a389b4ef88c50ef9fe7115a33f57db2f2304b\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "events": { + "AaveDeposited(address,address,uint256,uint256,uint256)": { + "params": { + "aTokenAddress": "aave token address.", + "aTokenBalanceAfterDeposit": "aTokens balance after Deposit.", + "aTokenBalanceBeforeDeposit": "aTokens balance after Deposit.", + "amount": "amount of tokens to Deposit.", + "tokenAddress": "address of the underlying token." + } + }, + "AaveWithdrawn(address,address,uint256,uint256,uint256)": { + "params": { + "aTokenAddress": "aave token address.", + "aTokenBalanceAfterWithdrawal": "aTokens balance after Withdrawal.", + "aTokenBalanceBeforeDeposit": "aTokens balance after Withdrawal.", + "amount": "amount of tokens to Withdrawal.", + "tokenAddress": "address of the underlying token." + } + } + }, + "kind": "dev", + "methods": { + "aaveDeposit(uint256,address,uint256)": { + "params": { + "amount": "amount of tokens to deposit", + "loanID": "id of the loan being used in the dapp", + "tokenAddress": "address of the token" + } + }, + "aaveWithdraw(uint256,address,uint256)": { + "params": { + "amount": "amount of the underlying tokens to withdraw", + "loanID": "id of the loan being used in the dapp", + "tokenAddress": "address of the token" + } + }, + "aaveWithdrawAll(uint256,address)": { + "params": { + "loanID": "id of the loan being used in the dapp", + "tokenAddress": "address of the token" + } + } + }, + "version": 1 + }, + "userdoc": { + "events": { + "AaveDeposited(address,address,uint256,uint256,uint256)": { + "notice": "This event is emitted every time Aave deposit is invoked successfully." + }, + "AaveWithdrawn(address,address,uint256,uint256,uint256)": { + "notice": "This event is emitted every time Aave redeem is invoked successfully." + } + }, + "kind": "user", + "methods": { + "aaveDeposit(uint256,address,uint256)": { + "notice": "The deposit, the aToken needs to be approved to have access to the token balance" + }, + "aaveWithdraw(uint256,address,uint256)": { + "notice": "This function withdraws the user's aTokens for a specific amount" + }, + "aaveWithdrawAll(uint256,address)": { + "notice": "This function withdraws all the user's aTokens from previous deposits" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/AssetSettingsDataFacet.json b/deployments/polygon_mumbai/AssetSettingsDataFacet.json new file mode 100644 index 000000000..aeb1be862 --- /dev/null +++ b/deployments/polygon_mumbai/AssetSettingsDataFacet.json @@ -0,0 +1,208 @@ +{ + "address": "0x092B2Ee3864fd374EE1786Ed31d7824Af63e3BED", + "abi": [ + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetAToken", + "outputs": [ + { + "internalType": "contract IAToken", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetPPool", + "outputs": [ + { + "internalType": "contract PrizePoolInterface", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetPPoolTicket", + "outputs": [ + { + "internalType": "contract IERC20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + } + ], + "artifactName": "AssetSettingsDataFacet", + "transactionHash": "0x1e69170501c5a6d063409aff9741298c08bf4a5456105c59e4b17adfa5d0dec6", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x092B2Ee3864fd374EE1786Ed31d7824Af63e3BED", + "transactionIndex": 1, + "gasUsed": "309777", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000800100000000000000000100000000004000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000080000000000000000000200000000000000000000000000000000000000000000000000000000000004000000000000100000001000000000000000000000000000000100040000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0x27d393187f2dbd8f45c530ffee9fcf4dc3ded9164bc77563966ef4eb1f44b6c9", + "transactionHash": "0x1e69170501c5a6d063409aff9741298c08bf4a5456105c59e4b17adfa5d0dec6", + "logs": [ + { + "transactionIndex": 1, + "blockNumber": 15692445, + "transactionHash": "0x1e69170501c5a6d063409aff9741298c08bf4a5456105c59e4b17adfa5d0dec6", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000be188d6641e8b680743a4815dfa0f6208038960f" + ], + "data": "0x0000000000000000000000000000000000000000000000000021043759566c000000000000000000000000000000000000000000000000003f4f7c56d90ad80000000000000000000000000000000000000000000000007e59091337c0b681500000000000000000000000000000000000000000000000003f2e781f7fb46c0000000000000000000000000000000000000000000000007e592a176f1a0ced50", + "logIndex": 2, + "blockHash": "0x27d393187f2dbd8f45c530ffee9fcf4dc3ded9164bc77563966ef4eb1f44b6c9" + } + ], + "blockNumber": 15692445, + "cumulativeGasUsed": "330777", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"getAssetAToken\",\"outputs\":[{\"internalType\":\"contract IAToken\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"getAssetCToken\",\"outputs\":[{\"internalType\":\"contract ICErc20\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"getAssetMaxLoanAmount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"getAssetMaxTVL\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"getAssetPPool\",\"outputs\":[{\"internalType\":\"contract PrizePoolInterface\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"getAssetPPoolTicket\",\"outputs\":[{\"internalType\":\"contract IERC20\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"develop@teller.finance\",\"kind\":\"dev\",\"methods\":{\"getAssetCToken(address)\":{\"params\":{\"asset\":\"the address of the asset\"},\"returns\":{\"_0\":\"the cToken of an asset\"}},\"getAssetMaxLoanAmount(address)\":{\"params\":{\"asset\":\"the address of the asset\"},\"returns\":{\"_0\":\"the max loan amount\"}},\"getAssetMaxTVL(address)\":{\"params\":{\"asset\":\"the address of the asset\"},\"returns\":{\"_0\":\"it returns the maxTVL\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"getAssetCToken(address)\":{\"notice\":\"it returns the asset's cToken\"},\"getAssetMaxLoanAmount(address)\":{\"notice\":\"it gets the asset's max loan amount\"},\"getAssetMaxTVL(address)\":{\"notice\":\"it gets the maxTVL of an asset\"}},\"notice\":\"View function to get asset setting values.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/settings/asset/AssetSettingsDataFacet.sol\":\"AssetSettingsDataFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/PrizePoolInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/// @title Escrows assets and deposits them into a yield source. Exposes interest to Prize Strategy. Users deposit and withdraw from this contract to participate in Prize Pool.\\n/// @notice Accounting is managed using Controlled Tokens, whose mint and burn functions can only be called by this contract.\\n/// @dev Must be inherited to provide specific yield-bearing asset control, such as Compound cTokens\\ninterface PrizePoolInterface {\\n /// @notice Deposit assets into the Prize Pool in exchange for tokens\\n /// @param to The address receiving the newly minted tokens\\n /// @param amount The amount of assets to deposit\\n /// @param controlledToken The address of the type of token the user is minting\\n /// @param referrer The referrer of the deposit\\n function depositTo(\\n address to,\\n uint256 amount,\\n address controlledToken,\\n address referrer\\n ) external;\\n\\n /// @notice Withdraw assets from the Prize Pool instantly. A fairness fee may be charged for an early exit.\\n /// @param from The address to redeem tokens from.\\n /// @param amount The amount of tokens to redeem for assets.\\n /// @param controlledToken The address of the token to redeem (i.e. ticket or sponsorship)\\n /// @param maximumExitFee The maximum exit fee the caller is willing to pay. This should be pre-calculated by the calculateExitFee() fxn.\\n /// @return The actual exit fee paid\\n function withdrawInstantlyFrom(\\n address from,\\n uint256 amount,\\n address controlledToken,\\n uint256 maximumExitFee\\n ) external returns (uint256);\\n\\n /// @notice Returns the balance that is available to award.\\n /// @dev captureAwardBalance() should be called first\\n /// @return The total amount of assets to be awarded for the current prize\\n function awardBalance() external view returns (uint256);\\n\\n /// @notice Calculates the early exit fee for the given amount\\n /// @param from The user who is withdrawing\\n /// @param controlledToken The type of collateral being withdrawn\\n /// @param amount The amount of collateral to be withdrawn\\n /// @return exitFee The exit fee\\n /// @return burnedCredit The user's credit that was burned\\n function calculateEarlyExitFee(\\n address from,\\n address controlledToken,\\n uint256 amount\\n ) external returns (uint256 exitFee, uint256 burnedCredit);\\n\\n /// @notice Estimates the amount of time it will take for a given amount of funds to accrue the given amount of credit.\\n /// @param _principal The principal amount on which interest is accruing\\n /// @param _interest The amount of interest that must accrue\\n /// @return durationSeconds The duration of time it will take to accrue the given amount of interest, in seconds.\\n function estimateCreditAccrualTime(\\n address _controlledToken,\\n uint256 _principal,\\n uint256 _interest\\n ) external view returns (uint256 durationSeconds);\\n\\n /// @notice Returns the credit balance for a given user. Not that this includes both minted credit and pending credit.\\n /// @param user The user whose credit balance should be returned\\n /// @return The balance of the users credit\\n function balanceOfCredit(address user, address controlledToken)\\n external\\n returns (uint256);\\n\\n /// @notice Returns the credit rate of a controlled token\\n /// @param controlledToken The controlled token to retrieve the credit rates for\\n /// @return creditLimitMantissa The credit limit fraction. This number is used to calculate both the credit limit and early exit fee.\\n /// @return creditRateMantissa The credit rate. This is the amount of tokens that accrue per second.\\n function creditPlanOf(address controlledToken)\\n external\\n view\\n returns (uint128 creditLimitMantissa, uint128 creditRateMantissa);\\n\\n /// @dev Returns the address of the underlying ERC20 asset\\n /// @return The address of the asset\\n function token() external view returns (address);\\n\\n /// @notice An array of the Tokens controlled by the Prize Pool (ie. Tickets, Sponsorship)\\n /// @return An array of controlled token addresses\\n function tokens() external view returns (address[] memory);\\n\\n /// @notice The total of all controlled tokens and timelock.\\n /// @return The current total of all tokens and timelock.\\n function accountedBalance() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x050cea53e1d5563980c735230712fc81b1f31fc476f9cbd31dde6ce1a0bb3725\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/PoolTogetherLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport {\\n AssetPPoolLib\\n} from \\\"../../../settings/asset/libraries/AssetPPoolLib.sol\\\";\\n\\nlibrary PoolTogetherLib {\\n /**\\n * @notice Grabs the controlled ticket token address for the prize pool\\n * @notice The pool underlying address must match the supplied token address.\\n * @param tokenAddress The token address to get the cToken for.\\n * @return The address of the ticket token contract.\\n */\\n function getTicketAddress(address tokenAddress)\\n internal\\n view\\n returns (address)\\n {\\n return AssetPPoolLib.get(tokenAddress).tokens()[1];\\n }\\n}\\n\",\"keccak256\":\"0xd0e20f760a61505104cd45ea861407246d1ee13aea427e74528eff78f8428668\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x417b75f5d92be67993efc54db7d453be5b5058a9a54d8916380e0281d3299526\",\"license\":\"MIT\"},\"contracts/settings/asset/AssetSettingsDataFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../shared/roles.sol\\\";\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../../shared/interfaces/ICErc20.sol\\\";\\nimport { IAToken } from \\\"../../shared/interfaces/IAToken.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n// Libraries\\nimport {\\n CacheLib,\\n Cache,\\n CacheType\\n} from \\\"../../shared/libraries/CacheLib.sol\\\";\\nimport { AssetCTokenLib } from \\\"./libraries/AssetCTokenLib.sol\\\";\\nimport { AssetATokenLib } from \\\"./libraries/AssetATokenLib.sol\\\";\\nimport { AssetPPoolLib } from \\\"./libraries/AssetPPoolLib.sol\\\";\\nimport {\\n PoolTogetherLib\\n} from \\\"../../escrow/dapps/libraries/PoolTogetherLib.sol\\\";\\nimport { MaxLoanAmountLib } from \\\"./libraries/MaxLoanAmountLib.sol\\\";\\nimport { MaxTVLLib } from \\\"./libraries/MaxTVLLib.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\nimport {\\n PrizePoolInterface\\n} from \\\"../../escrow/dapps/interfaces/PrizePoolInterface.sol\\\";\\n\\n/**\\n * @notice View function to get asset setting values.\\n *\\n * @author develop@teller.finance\\n */\\ncontract AssetSettingsDataFacet {\\n /**\\n * @notice it gets the asset's max loan amount\\n * @param asset the address of the asset\\n * @return the max loan amount\\n */\\n function getAssetMaxLoanAmount(address asset)\\n external\\n view\\n returns (uint256)\\n {\\n return MaxLoanAmountLib.get(asset);\\n }\\n\\n /**\\n * @notice it gets the maxTVL of an asset\\n * @param asset the address of the asset\\n * @return it returns the maxTVL\\n */\\n function getAssetMaxTVL(address asset) external view returns (uint256) {\\n return MaxTVLLib.get(asset);\\n }\\n\\n /**\\n * @notice it returns the asset's cToken\\n * @param asset the address of the asset\\n * @return the cToken of an asset\\n */\\n function getAssetCToken(address asset) external view returns (ICErc20) {\\n return AssetCTokenLib.get(asset);\\n }\\n\\n function getAssetAToken(address asset) external view returns (IAToken) {\\n return AssetATokenLib.get(asset);\\n }\\n\\n function getAssetPPool(address asset)\\n external\\n view\\n returns (PrizePoolInterface)\\n {\\n return AssetPPoolLib.get(asset);\\n }\\n\\n function getAssetPPoolTicket(address asset) external view returns (IERC20) {\\n return IERC20(PoolTogetherLib.getTicketAddress(asset));\\n }\\n}\\n\",\"keccak256\":\"0xa7dc7671591532e4bc42cd0be5f744d59c417928be89147757c5ddf9582b906c\",\"license\":\"MIT\"},\"contracts/settings/asset/libraries/AssetATokenLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n CacheLib,\\n Cache,\\n CacheType\\n} from \\\"../../../shared/libraries/CacheLib.sol\\\";\\nimport { IAToken } from \\\"../../../shared/interfaces/IAToken.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library of inline functions for Aave asset setting.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary AssetATokenLib {\\n bytes32 private constant NAME = keccak256(\\\"aToken\\\");\\n\\n function s(address asset) private view returns (Cache storage) {\\n return AppStorageLib.store().assetSettings[asset];\\n }\\n\\n function get(address asset) internal view returns (IAToken) {\\n return IAToken(s(asset).addresses[NAME]);\\n }\\n\\n function set(address asset, address newValue) internal {\\n s(asset).addresses[NAME] = newValue;\\n }\\n}\\n\",\"keccak256\":\"0xb9c8f6e21ee86a35ebe07fe2fddc077e7acd5ed1328fabf3391085b964ffd848\",\"license\":\"MIT\"},\"contracts/settings/asset/libraries/AssetCTokenLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n CacheLib,\\n Cache,\\n CacheType\\n} from \\\"../../../shared/libraries/CacheLib.sol\\\";\\nimport { ICErc20 } from \\\"../../../shared/interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library of inline functions for Compound asset setting.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary AssetCTokenLib {\\n bytes32 private constant NAME = keccak256(\\\"cToken\\\");\\n\\n function s(address asset) private view returns (Cache storage) {\\n return AppStorageLib.store().assetSettings[asset];\\n }\\n\\n function get(address asset) internal view returns (ICErc20) {\\n return ICErc20(s(asset).addresses[NAME]);\\n }\\n\\n function set(address asset, address newValue) internal {\\n s(asset).addresses[NAME] = newValue;\\n }\\n}\\n\",\"keccak256\":\"0xa37bb503d0cb1f3b99c233833310aa3f9865499d8f1ee7e9af7fc9e71a769de4\",\"license\":\"MIT\"},\"contracts/settings/asset/libraries/AssetPPoolLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n CacheLib,\\n Cache,\\n CacheType\\n} from \\\"../../../shared/libraries/CacheLib.sol\\\";\\nimport {\\n PrizePoolInterface\\n} from \\\"../../../escrow/dapps/interfaces/PrizePoolInterface.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library of inline functions for Pool together asset setting.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary AssetPPoolLib {\\n bytes32 private constant NAME = keccak256(\\\"pPool\\\");\\n\\n function s(address asset) private view returns (Cache storage) {\\n return AppStorageLib.store().assetSettings[asset];\\n }\\n\\n function get(address asset) internal view returns (PrizePoolInterface) {\\n return PrizePoolInterface(s(asset).addresses[NAME]);\\n }\\n\\n function set(address asset, address newValue) internal {\\n s(asset).addresses[NAME] = newValue;\\n }\\n}\\n\",\"keccak256\":\"0x2e4b07dc02548201148c45ce33291f91c759bea8291f29ca081424d9b9aaef12\",\"license\":\"MIT\"},\"contracts/settings/asset/libraries/MaxLoanAmountLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n CacheLib,\\n Cache,\\n CacheType\\n} from \\\"../../../shared/libraries/CacheLib.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library of inline functions for MaxLoanAmount asset setting.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary MaxLoanAmountLib {\\n bytes32 private constant NAME = keccak256(\\\"MaxLoanAmount\\\");\\n\\n function s(address asset) private view returns (Cache storage) {\\n return AppStorageLib.store().assetSettings[asset];\\n }\\n\\n function get(address asset) internal view returns (uint256) {\\n return s(asset).uints[NAME];\\n }\\n\\n function set(address asset, uint256 newValue) internal {\\n s(asset).uints[NAME] = newValue;\\n }\\n}\\n\",\"keccak256\":\"0x5ccd9e2708630103508f6498a6ed200de70670a65a47a20f8b4bca8788111116\",\"license\":\"MIT\"},\"contracts/settings/asset/libraries/MaxTVLLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n CacheLib,\\n Cache,\\n CacheType\\n} from \\\"../../../shared/libraries/CacheLib.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library of inline functions for MaxDebtRatio asset setting.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary MaxTVLLib {\\n bytes32 private constant NAME = keccak256(\\\"MaxTVL\\\");\\n\\n function s(address asset) private view returns (Cache storage) {\\n return AppStorageLib.store().assetSettings[asset];\\n }\\n\\n function get(address asset) internal view returns (uint256) {\\n return s(asset).uints[NAME];\\n }\\n\\n function set(address asset, uint256 newValue) internal {\\n s(asset).uints[NAME] = newValue;\\n }\\n}\\n\",\"keccak256\":\"0x7ee0cef332ce56b76d23da67d1ea7d5a7cf6cd4fe1330516bd8339bbcfaf7006\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"NFTInterestRate\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getNFTInterestRate() internal view returns (uint16 value_) {\\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0x44294be1af9f913b2ed391a40cd4b646537a4b463b8d5ff1fac8ead3988966c1\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for loans taken out with an NFT.\\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\\n */\\nbytes32 constant NFT_INTEREST_RATE = keccak256(\\\"NFTInterestRate\\\");\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xd68a7df42b2bbba6f935d5890b7b37997c1432e25ae113827b8bde87f94fd86f\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n /**\\n * @notice Checks if the account should be allowed to mint tokens in the given market\\n * @param cToken The market to verify the mint against\\n * @param minter The account which would get the minted tokens\\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates mint and reverts on rejection. May emit logs.\\n * @param cToken Asset being minted\\n * @param minter The address minting the tokens\\n * @param mintAmount The amount of the underlying asset being minted\\n * @param mintTokens The number of tokens being minted\\n */\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to redeem tokens in the given market\\n * @param cToken The market to verify the redeem against\\n * @param redeemer The account which would redeem the tokens\\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates redeem and reverts on rejection. May emit logs.\\n * @param cToken Asset being redeemed\\n * @param redeemer The address redeeming the tokens\\n * @param redeemAmount The amount of the underlying asset being redeemed\\n * @param redeemTokens The number of tokens being redeemed\\n */\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\\n * @param cToken The market to verify the borrow against\\n * @param borrower The account which would borrow the asset\\n * @param borrowAmount The amount of underlying the account would borrow\\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates borrow and reverts on rejection. May emit logs.\\n * @param cToken Asset whose underlying is being borrowed\\n * @param borrower The address borrowing the underlying\\n * @param borrowAmount The amount of the underlying asset requested to borrow\\n */\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to repay a borrow in the given market\\n * @param cToken The market to verify the repay against\\n * @param payer The account which would repay the asset\\n * @param borrower The account which would borrowed the asset\\n * @param repayAmount The amount of the underlying asset the account would repay\\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\\n * @param cToken Asset being repaid\\n * @param payer The address repaying the borrow\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param borrowerIndex the index of the borrower\\n */\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n /**\\n * @notice Checks if the liquidation should be allowed to occur\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n */\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the seizing of assets should be allowed to occur\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates seize and reverts on rejection. May emit logs.\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to transfer tokens in the given market\\n * @param cToken The market to verify the transfer against\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates transfer and reverts on rejection. May emit logs.\\n * @param cToken Asset being transferred\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n */\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in all markets\\n * @param holder The address to claim COMP for\\n */\\n function claimComp(address holder) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in the specified markets\\n * @param holder The address to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n */\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n /**\\n * @notice Claim all comp accrued by the holders\\n * @param holders The addresses to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n * @param borrowers Whether or not to claim COMP earned by borrowing\\n * @param suppliers Whether or not to claim COMP earned by supplying\\n */\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n /**\\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\\n * @param cTokenBorrowed The address of the borrowed cToken\\n * @param cTokenCollateral The address of the collateral cToken\\n * @param repayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\\n */\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n /**\\n * @notice Return the address of the COMP token\\n * @return The address of COMP\\n */\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x38a824a4a21ce9370fa581a616d1bb9d311f27d8982a6b96ebeba90bd5fd0adb\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n address wrappedNativeToken;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4504c5c460972a25cd1f0e6eb1d8dd84a668be75a3aeb89a47a49c2327c12923\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "author": "develop@teller.finance", + "kind": "dev", + "methods": { + "getAssetCToken(address)": { + "params": { + "asset": "the address of the asset" + }, + "returns": { + "_0": "the cToken of an asset" + } + }, + "getAssetMaxLoanAmount(address)": { + "params": { + "asset": "the address of the asset" + }, + "returns": { + "_0": "the max loan amount" + } + }, + "getAssetMaxTVL(address)": { + "params": { + "asset": "the address of the asset" + }, + "returns": { + "_0": "it returns the maxTVL" + } + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "getAssetCToken(address)": { + "notice": "it returns the asset's cToken" + }, + "getAssetMaxLoanAmount(address)": { + "notice": "it gets the asset's max loan amount" + }, + "getAssetMaxTVL(address)": { + "notice": "it gets the maxTVL of an asset" + } + }, + "notice": "View function to get asset setting values.", + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/AssetSettingsFacet.json b/deployments/polygon_mumbai/AssetSettingsFacet.json new file mode 100644 index 000000000..8941c708f --- /dev/null +++ b/deployments/polygon_mumbai/AssetSettingsFacet.json @@ -0,0 +1,269 @@ +{ + "address": "0xF8441De2A5Ec87402989bB3691aa0d9926607302", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "AssetSettingsFacet", + "transactionHash": "0xd2231bb93ebe856c9b459175866c3ce556e116649c0e452aa759c20c2adc0ad3", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0xF8441De2A5Ec87402989bB3691aa0d9926607302", + "transactionIndex": 0, + "gasUsed": "599077", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000800100000000000000000100000000004000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000080000000000000000000200000000000000000000000000000000000000000000000000000000000004000000000000100000001000000000000000000000000000000100040000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0xa6b072ed819444436d4b7c66d6fc59b1b62b97529c6f474f3a300d0fb1874730", + "transactionHash": "0xd2231bb93ebe856c9b459175866c3ce556e116649c0e452aa759c20c2adc0ad3", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692449, + "transactionHash": "0xd2231bb93ebe856c9b459175866c3ce556e116649c0e452aa759c20c2adc0ad3", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000be188d6641e8b680743a4815dfa0f6208038960f" + ], + "data": "0x000000000000000000000000000000000000000000000000003fd9b88157dc000000000000000000000000000000000000000000000000003f2e781f7fb46c0000000000000000000000000000000000000000000000007e592c546a68424d500000000000000000000000000000000000000000000000003eee9e66fe5c900000000000000000000000000000000000000000000000007e596c2e22e99a2950", + "logIndex": 0, + "blockHash": "0xa6b072ed819444436d4b7c66d6fc59b1b62b97529c6f474f3a300d0fb1874730" + } + ], + "blockNumber": 15692449, + "cumulativeGasUsed": "599077", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"key\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"enum CacheType\",\"name\":\"cacheType\",\"type\":\"uint8\"}],\"name\":\"AssetSettingsCreated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"key\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"enum CacheType\",\"name\":\"cacheType\",\"type\":\"uint8\"}],\"name\":\"AssetSettingsUpdated\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"key\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"},{\"internalType\":\"enum CacheType\",\"name\":\"cacheType\",\"type\":\"uint8\"}],\"internalType\":\"struct AssetSettingRequest[]\",\"name\":\"requests\",\"type\":\"tuple[]\"}],\"name\":\"createAssetSetting\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"getMaxTVLAmount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"isAssetSettingInitialized\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"key\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"},{\"internalType\":\"enum CacheType\",\"name\":\"cacheType\",\"type\":\"uint8\"}],\"internalType\":\"struct AssetSettingRequest\",\"name\":\"request\",\"type\":\"tuple\"}],\"name\":\"updateAssetSetting\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"createAssetSetting(address,(bytes32,bytes32,uint8)[])\":{\"params\":{\"asset\":\"the address to create settings for\",\"requests\":\"the multiple settings to update the asset with \"}},\"getMaxTVLAmount(address)\":{\"params\":{\"asset\":\"the address of the asset\"},\"returns\":{\"_0\":\"the max TVL amount\"}},\"isAssetSettingInitialized(address)\":{\"params\":{\"asset\":\"the address of the asset\"},\"returns\":{\"_0\":\"bool to check if settings of an asset exists\"}},\"updateAssetSetting(address,(bytes32,bytes32,uint8))\":{\"params\":{\"asset\":\"the address of the asset to update\",\"request\":\"the setting to update the asset with\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"createAssetSetting(address,(bytes32,bytes32,uint8)[])\":{\"notice\":\"It creates an asset settings with the given parameters.\"},\"getMaxTVLAmount(address)\":{\"notice\":\"it gets the MaxTVL amount of an asset\"},\"isAssetSettingInitialized(address)\":{\"notice\":\"it checks if the settings of an asset is initialized\"},\"updateAssetSetting(address,(bytes32,bytes32,uint8))\":{\"notice\":\"It updates an asset with the given parameter\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/settings/asset/AssetSettingsFacet.sol\":\"AssetSettingsFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x417b75f5d92be67993efc54db7d453be5b5058a9a54d8916380e0281d3299526\",\"license\":\"MIT\"},\"contracts/settings/asset/AssetSettingsFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../shared/roles.sol\\\";\\n\\n// Libraries\\nimport {\\n CacheLib,\\n Cache,\\n CacheType\\n} from \\\"../../shared/libraries/CacheLib.sol\\\";\\nimport { MaxTVLLib } from \\\"./libraries/MaxTVLLib.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\n\\nstruct AssetSettingRequest {\\n bytes32 key;\\n bytes32 value;\\n CacheType cacheType;\\n}\\n\\ncontract AssetSettingsFacet is RolesMods {\\n function s(address asset) private view returns (Cache storage) {\\n return AppStorageLib.store().assetSettings[asset];\\n }\\n\\n event AssetSettingsCreated(\\n address indexed asset,\\n bytes32 indexed key,\\n bytes32 value,\\n CacheType cacheType\\n );\\n\\n event AssetSettingsUpdated(\\n address indexed asset,\\n bytes32 indexed key,\\n bytes32 value,\\n CacheType cacheType\\n );\\n\\n /**\\n * @notice it checks if the settings of an asset is initialized\\n * @param asset the address of the asset\\n * @return bool to check if settings of an asset exists\\n */\\n function isAssetSettingInitialized(address asset)\\n external\\n view\\n returns (bool)\\n {\\n return CacheLib.exists(s(asset));\\n }\\n\\n /**\\n * @notice it gets the MaxTVL amount of an asset\\n * @param asset the address of the asset\\n * @return the max TVL amount\\n */\\n function getMaxTVLAmount(address asset) external view returns (uint256) {\\n return MaxTVLLib.get(asset);\\n }\\n\\n /**\\n * @notice It creates an asset settings with the given parameters.\\n * @param asset the address to create settings for\\n * @param requests the multiple settings to update the asset with \\n */\\n function createAssetSetting(\\n address asset,\\n AssetSettingRequest[] calldata requests\\n ) external authorized(ADMIN, msg.sender) {\\n require(asset != address(0), \\\"Teller: asset address required\\\");\\n\\n CacheLib.initialize(s(asset));\\n\\n for (uint256 i; i < requests.length; i++) {\\n CacheLib.update(\\n s(asset),\\n requests[i].key,\\n requests[i].value,\\n requests[i].cacheType\\n );\\n\\n emit AssetSettingsCreated(\\n asset,\\n requests[i].key,\\n requests[i].value,\\n requests[i].cacheType\\n );\\n }\\n }\\n\\n /**\\n * @notice It updates an asset with the given parameter\\n * @param asset the address of the asset to update\\n * @param request the setting to update the asset with\\n */\\n function updateAssetSetting(\\n address asset,\\n AssetSettingRequest calldata request\\n ) external authorized(ADMIN, msg.sender) {\\n require(\\n CacheLib.exists(s(asset)),\\n \\\"Teller: asset setting does not exists\\\"\\n );\\n\\n CacheLib.update(\\n s(asset),\\n request.key,\\n request.value,\\n request.cacheType\\n );\\n\\n emit AssetSettingsUpdated(\\n asset,\\n request.key,\\n request.value,\\n request.cacheType\\n );\\n }\\n}\\n\",\"keccak256\":\"0x9e3fcf69df5d27a68b5666d62ebb143f74621eb6fb303c2945bb2686db1824e2\",\"license\":\"MIT\"},\"contracts/settings/asset/libraries/MaxTVLLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n CacheLib,\\n Cache,\\n CacheType\\n} from \\\"../../../shared/libraries/CacheLib.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library of inline functions for MaxDebtRatio asset setting.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary MaxTVLLib {\\n bytes32 private constant NAME = keccak256(\\\"MaxTVL\\\");\\n\\n function s(address asset) private view returns (Cache storage) {\\n return AppStorageLib.store().assetSettings[asset];\\n }\\n\\n function get(address asset) internal view returns (uint256) {\\n return s(asset).uints[NAME];\\n }\\n\\n function set(address asset, uint256 newValue) internal {\\n s(asset).uints[NAME] = newValue;\\n }\\n}\\n\",\"keccak256\":\"0x7ee0cef332ce56b76d23da67d1ea7d5a7cf6cd4fe1330516bd8339bbcfaf7006\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"NFTInterestRate\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getNFTInterestRate() internal view returns (uint16 value_) {\\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0x44294be1af9f913b2ed391a40cd4b646537a4b463b8d5ff1fac8ead3988966c1\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for loans taken out with an NFT.\\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\\n */\\nbytes32 constant NFT_INTEREST_RATE = keccak256(\\\"NFTInterestRate\\\");\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xd68a7df42b2bbba6f935d5890b7b37997c1432e25ae113827b8bde87f94fd86f\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n address wrappedNativeToken;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4504c5c460972a25cd1f0e6eb1d8dd84a668be75a3aeb89a47a49c2327c12923\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "kind": "dev", + "methods": { + "createAssetSetting(address,(bytes32,bytes32,uint8)[])": { + "params": { + "asset": "the address to create settings for", + "requests": "the multiple settings to update the asset with " + } + }, + "getMaxTVLAmount(address)": { + "params": { + "asset": "the address of the asset" + }, + "returns": { + "_0": "the max TVL amount" + } + }, + "isAssetSettingInitialized(address)": { + "params": { + "asset": "the address of the asset" + }, + "returns": { + "_0": "bool to check if settings of an asset exists" + } + }, + "updateAssetSetting(address,(bytes32,bytes32,uint8))": { + "params": { + "asset": "the address of the asset to update", + "request": "the setting to update the asset with" + } + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "createAssetSetting(address,(bytes32,bytes32,uint8)[])": { + "notice": "It creates an asset settings with the given parameters." + }, + "getMaxTVLAmount(address)": { + "notice": "it gets the MaxTVL amount of an asset" + }, + "isAssetSettingInitialized(address)": { + "notice": "it checks if the settings of an asset is initialized" + }, + "updateAssetSetting(address,(bytes32,bytes32,uint8))": { + "notice": "It updates an asset with the given parameter" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/ChainlinkAggFacet.json b/deployments/polygon_mumbai/ChainlinkAggFacet.json new file mode 100644 index 000000000..581e0fb5c --- /dev/null +++ b/deployments/polygon_mumbai/ChainlinkAggFacet.json @@ -0,0 +1,195 @@ +{ + "address": "0xB8030DBf749Ab84a59FE06D2346Ad2Cb856a9C49", + "abi": [ + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "ChainlinkAggFacet", + "transactionHash": "0x1e4a29ca095ee0ac9d3da8ed0671987f45bb9e5d743f5fa20e03d2686840369d", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0xB8030DBf749Ab84a59FE06D2346Ad2Cb856a9C49", + "transactionIndex": 0, + "gasUsed": "594205", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000800100000000000000000100000000004000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000080000000000000000000200000000000000000000000000000000000000000000000000000000000004000000000000100000001000000000000000000000000000000100040000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0xcbe179d573b08195552e0e8faf10929dedd4e94ede97c0c5b8a6e0566d3a3c8f", + "transactionHash": "0x1e4a29ca095ee0ac9d3da8ed0671987f45bb9e5d743f5fa20e03d2686840369d", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692460, + "transactionHash": "0x1e4a29ca095ee0ac9d3da8ed0671987f45bb9e5d743f5fa20e03d2686840369d", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000be188d6641e8b680743a4815dfa0f6208038960f" + ], + "data": "0x000000000000000000000000000000000000000000000000003f54c9fa767c000000000000000000000000000000000000000000000000003e8b23bdc0844c0000000000000000000000000000000000000000000000007e59e70507de017d500000000000000000000000000000000000000000000000003e4bcef3c60dd00000000000000000000000000000000000000000000000007e5a2659d1d877f950", + "logIndex": 0, + "blockHash": "0xcbe179d573b08195552e0e8faf10929dedd4e94ede97c0c5b8a6e0566d3a3c8f" + } + ], + "blockNumber": 15692460, + "cumulativeGasUsed": "594205", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"src\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"dst\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"aggregator\",\"type\":\"address\"}],\"name\":\"addChainlinkAggregator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"src\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"dst\",\"type\":\"address\"}],\"name\":\"getChainlinkAggregatorFor\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"agg\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"found\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"inverse\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"isChainlinkTokenSupported\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"src\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"dst\",\"type\":\"address\"}],\"name\":\"removeChainlinkAggregator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"addChainlinkAggregator(address,address,address)\":{\"params\":{\"aggregator\":\"Price aggregator address.\",\"dst\":\"Destination token address.\",\"src\":\"Source token address.\"}},\"getChainlinkAggregatorFor(address,address)\":{\"params\":{\"dst\":\"Destination token address.\",\"src\":\"Source token address.\"},\"returns\":{\"agg\":\"The Chainlink Aggregator address.\",\"found\":\"whether or not the ChainlinkAggregator exists.\",\"inverse\":\"whether or not the values from the Aggregator should be considered inverted.\"}},\"isChainlinkTokenSupported(address)\":{\"details\":\"Checks if a token address is supported by Chainlink (has a pair aggregator).\",\"params\":{\"token\":\"Token address to check if is supported.\"},\"returns\":{\"_0\":\"isSupported_ true if there is at least 1 pair aggregator for {token}\"}},\"removeChainlinkAggregator(address,address)\":{\"params\":{\"dst\":\"Destination token address.\",\"src\":\"Source token address.\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"addChainlinkAggregator(address,address,address)\":{\"notice\":\"It allows for additional Chainlink Aggregators to be supported.\"},\"getChainlinkAggregatorFor(address,address)\":{\"notice\":\"It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\"},\"removeChainlinkAggregator(address,address)\":{\"notice\":\"It removes support for a Chainlink Aggregator pair.\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/price-aggregator/chainlink/ChainlinkAggFacet.sol\":\"ChainlinkAggFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN } from \\\"../../shared/roles.sol\\\";\\n\\n// Libraries\\nimport { Address } from \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport { ChainlinkLib } from \\\"./ChainlinkLib.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n PriceAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\ncontract ChainlinkAggFacet is RolesMods {\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return agg The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function getChainlinkAggregatorFor(address src, address dst)\\n external\\n view\\n returns (\\n address agg,\\n bool found,\\n bool inverse\\n )\\n {\\n (agg, found, inverse) = ChainlinkLib.aggregatorFor(src, dst);\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isChainlinkTokenSupported(address token)\\n external\\n view\\n returns (bool)\\n {\\n return ChainlinkLib.isTokenSupported(token);\\n }\\n\\n /**\\n * @notice It allows for additional Chainlink Aggregators to be supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param aggregator Price aggregator address.\\n */\\n function addChainlinkAggregator(\\n address src,\\n address dst,\\n address aggregator\\n ) external authorized(ADMIN, msg.sender) {\\n (, bool found, ) = ChainlinkLib.aggregatorFor(src, dst);\\n require(!found, \\\"Teller: chainlink aggregator already exists\\\");\\n require(Address.isContract(src), \\\"Teller: source token not contract\\\");\\n require(\\n Address.isContract(dst),\\n \\\"Teller: destination token not contract\\\"\\n );\\n require(\\n Address.isContract(aggregator),\\n \\\"Teller: chainlink aggregator not contract\\\"\\n );\\n\\n // Store now aggregator\\n ChainlinkLib.s().aggregators[src][dst] = aggregator;\\n // Make sure token addresses are known to be supported\\n EnumerableSet.add(ChainlinkLib.s().supportedTokens, src);\\n EnumerableSet.add(ChainlinkLib.s().supportedTokens, dst);\\n // Increment token pair counts\\n ChainlinkLib.s().pairCount[src]++;\\n ChainlinkLib.s().pairCount[dst]++;\\n }\\n\\n /**\\n * @notice It removes support for a Chainlink Aggregator pair.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n */\\n function removeChainlinkAggregator(address src, address dst)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n (, bool found, ) = ChainlinkLib.aggregatorFor(src, dst);\\n if (!found) {\\n return;\\n }\\n\\n // Delete aggregator storage\\n delete ChainlinkLib.s().aggregators[src][dst];\\n // Decrement token pair counts\\n ChainlinkLib.s().pairCount[src]--;\\n ChainlinkLib.s().pairCount[dst]--;\\n // Remove token support if token pair length is 0\\n if (ChainlinkLib.s().pairCount[src] == 0) {\\n EnumerableSet.remove(ChainlinkLib.s().supportedTokens, src);\\n }\\n if (ChainlinkLib.s().pairCount[dst] == 0) {\\n EnumerableSet.remove(ChainlinkLib.s().supportedTokens, dst);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xa46a001a816c9cf4bc5fa59ab7f54622f661d0dca7b52ed2617feb3807211bbc\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "kind": "dev", + "methods": { + "addChainlinkAggregator(address,address,address)": { + "params": { + "aggregator": "Price aggregator address.", + "dst": "Destination token address.", + "src": "Source token address." + } + }, + "getChainlinkAggregatorFor(address,address)": { + "params": { + "dst": "Destination token address.", + "src": "Source token address." + }, + "returns": { + "agg": "The Chainlink Aggregator address.", + "found": "whether or not the ChainlinkAggregator exists.", + "inverse": "whether or not the values from the Aggregator should be considered inverted." + } + }, + "isChainlinkTokenSupported(address)": { + "details": "Checks if a token address is supported by Chainlink (has a pair aggregator).", + "params": { + "token": "Token address to check if is supported." + }, + "returns": { + "_0": "isSupported_ true if there is at least 1 pair aggregator for {token}" + } + }, + "removeChainlinkAggregator(address,address)": { + "params": { + "dst": "Destination token address.", + "src": "Source token address." + } + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "addChainlinkAggregator(address,address,address)": { + "notice": "It allows for additional Chainlink Aggregators to be supported." + }, + "getChainlinkAggregatorFor(address,address)": { + "notice": "It grabs the Chainlink Aggregator contract address for the token pair if it is supported." + }, + "removeChainlinkAggregator(address,address)": { + "notice": "It removes support for a Chainlink Aggregator pair." + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/CollateralEscrowBeaconFactory.json b/deployments/polygon_mumbai/CollateralEscrowBeaconFactory.json new file mode 100644 index 000000000..95931f1e8 --- /dev/null +++ b/deployments/polygon_mumbai/CollateralEscrowBeaconFactory.json @@ -0,0 +1,286 @@ +{ + "address": "0x3748F2e8a0E4609684805698EEa7855871D10467", + "abi": [ + { + "inputs": [ + { + "internalType": "address payable", + "name": "proxyAddress_", + "type": "address" + }, + { + "internalType": "address", + "name": "implementation_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "implementation", + "type": "address" + } + ], + "name": "Upgraded", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes", + "name": "initData", + "type": "bytes" + } + ], + "name": "cloneProxy", + "outputs": [ + { + "internalType": "address payable", + "name": "proxy_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "implementation", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "proxyAddress", + "outputs": [ + { + "internalType": "contract InitializeableBeaconProxy", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "renounceOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newImplementation", + "type": "address" + } + ], + "name": "upgradeTo", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "UpgradeableBeaconFactory", + "transactionHash": "0xe85c89a73d07c6b925b304e08b0474072ad3468cfe8b99fb50725161cefb85e9", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x3748F2e8a0E4609684805698EEa7855871D10467", + "transactionIndex": 0, + "gasUsed": "481877", + "logsBloom": "0x00000000000000000000000000008000000000000000000000800000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000800101000000000000000100000010005000000000020000000000000000000800000000000000000080000000000000400000000000000000000000000000000000000100000080000000000000000000200000000000000000000000000000000000000000000000000000000000004000000000000100000001000000000000000000000000000000100040000020000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0xeb7e755f000c23556930bcf105b09d31d83c7f045c76c16c3ec8ead2d7a86745", + "transactionHash": "0xe85c89a73d07c6b925b304e08b0474072ad3468cfe8b99fb50725161cefb85e9", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692426, + "transactionHash": "0xe85c89a73d07c6b925b304e08b0474072ad3468cfe8b99fb50725161cefb85e9", + "address": "0x3748F2e8a0E4609684805698EEa7855871D10467", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 0, + "blockHash": "0xeb7e755f000c23556930bcf105b09d31d83c7f045c76c16c3ec8ead2d7a86745" + }, + { + "transactionIndex": 0, + "blockNumber": 15692426, + "transactionHash": "0xe85c89a73d07c6b925b304e08b0474072ad3468cfe8b99fb50725161cefb85e9", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000be188d6641e8b680743a4815dfa0f6208038960f" + ], + "data": "0x00000000000000000000000000000000000000000000000000335beff6501c000000000000000000000000000000000000000000000000004127e138a767140000000000000000000000000000000000000000000000007e570bbdf7df3ae15000000000000000000000000000000000000000000000000040f48548b116f80000000000000000000000000000000000000000000000007e573f19e7d58afd50", + "logIndex": 1, + "blockHash": "0xeb7e755f000c23556930bcf105b09d31d83c7f045c76c16c3ec8ead2d7a86745" + } + ], + "blockNumber": 15692426, + "cumulativeGasUsed": "481877", + "status": 1, + "byzantium": true + }, + "args": [ + "0xbC71607119F3daf4A7F3baDd7bBA9A1fd072D9B1", + "0xAdc8bB19844F97467436Fb44d2C4b34e4D047740" + ], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address payable\",\"name\":\"proxyAddress_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"implementation_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"initData\",\"type\":\"bytes\"}],\"name\":\"cloneProxy\",\"outputs\":[{\"internalType\":\"address payable\",\"name\":\"proxy_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"implementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxyAddress\",\"outputs\":[{\"internalType\":\"contract InitializeableBeaconProxy\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their implementation contract, which is where they will delegate all function calls. An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\",\"events\":{\"Upgraded(address)\":{\"details\":\"Emitted when the implementation returned by the beacon is changed.\"}},\"kind\":\"dev\",\"methods\":{\"cloneProxy(bytes)\":{\"params\":{\"initData\":\"the data to initialize after the proxy is cloned\"},\"returns\":{\"proxy_\":\"the cloned proxy\"}},\"constructor\":{\"details\":\"Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the beacon.\"},\"implementation()\":{\"details\":\"Returns the current implementation address.\"},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"},\"upgradeTo(address)\":{\"details\":\"Upgrades the beacon to a new implementation. Emits an {Upgraded} event. Requirements: - msg.sender must be the owner of the contract. - `newImplementation` must be a contract.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"cloneProxy(bytes)\":{\"notice\":\"it clones the proxy contract at an address\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":\"UpgradeableBeaconFactory\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "details": "This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their implementation contract, which is where they will delegate all function calls. An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.", + "events": { + "Upgraded(address)": { + "details": "Emitted when the implementation returned by the beacon is changed." + } + }, + "kind": "dev", + "methods": { + "cloneProxy(bytes)": { + "params": { + "initData": "the data to initialize after the proxy is cloned" + }, + "returns": { + "proxy_": "the cloned proxy" + } + }, + "constructor": { + "details": "Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the beacon." + }, + "implementation()": { + "details": "Returns the current implementation address." + }, + "owner()": { + "details": "Returns the address of the current owner." + }, + "renounceOwnership()": { + "details": "Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner." + }, + "transferOwnership(address)": { + "details": "Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner." + }, + "upgradeTo(address)": { + "details": "Upgrades the beacon to a new implementation. Emits an {Upgraded} event. Requirements: - msg.sender must be the owner of the contract. - `newImplementation` must be a contract." + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "cloneProxy(bytes)": { + "notice": "it clones the proxy contract at an address" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [ + { + "astId": 3103, + "contract": "contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol:UpgradeableBeaconFactory", + "label": "_owner", + "offset": 0, + "slot": "0", + "type": "t_address" + }, + { + "astId": 25428, + "contract": "contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol:UpgradeableBeaconFactory", + "label": "_implementation", + "offset": 0, + "slot": "1", + "type": "t_address" + }, + { + "astId": 25431, + "contract": "contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol:UpgradeableBeaconFactory", + "label": "proxyAddress", + "offset": 0, + "slot": "2", + "type": "t_contract(InitializeableBeaconProxy)25414" + } + ], + "types": { + "t_address": { + "encoding": "inplace", + "label": "address", + "numberOfBytes": "20" + }, + "t_contract(InitializeableBeaconProxy)25414": { + "encoding": "inplace", + "label": "contract InitializeableBeaconProxy", + "numberOfBytes": "20" + } + } + } +} diff --git a/deployments/polygon_mumbai/CollateralEscrow_V1.json b/deployments/polygon_mumbai/CollateralEscrow_V1.json new file mode 100644 index 000000000..55e36e97f --- /dev/null +++ b/deployments/polygon_mumbai/CollateralEscrow_V1.json @@ -0,0 +1,372 @@ +{ + "address": "0xAdc8bB19844F97467436Fb44d2C4b34e4D047740", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "collateralToken", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "deposit", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "bool", + "name": "isWrappedNativeToken", + "type": "bool" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "loanSupply", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "renounceOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "totalSupply", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "address payable", + "name": "receiver", + "type": "address" + } + ], + "name": "withdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "CollateralEscrow_V1", + "transactionHash": "0x38d0f6ca3c4473dd78fc3c8456d21cbd37cab7bf6ada249af01351bf60f2648d", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0xAdc8bB19844F97467436Fb44d2C4b34e4D047740", + "transactionIndex": 0, + "gasUsed": "799181", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000800100000000000000000100000000004000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000080000000000000000000200000000000000000000000000000000000000000000000000000000000004000000000000100000001000000000000000000000000000000100040000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0x4aa46f2060b623150529415819a46380d9488d06652249d474753d4c6ba03088", + "transactionHash": "0x38d0f6ca3c4473dd78fc3c8456d21cbd37cab7bf6ada249af01351bf60f2648d", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692423, + "transactionHash": "0x38d0f6ca3c4473dd78fc3c8456d21cbd37cab7bf6ada249af01351bf60f2648d", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000be188d6641e8b680743a4815dfa0f6208038960f" + ], + "data": "0x00000000000000000000000000000000000000000000000000552d86cc7cbc00000000000000000000000000000000000000000000000000417d0ebf73e3d00000000000000000000000000000000000000000000000007e56b6907112be25500000000000000000000000000000000000000000000000004127e138a767140000000000000000000000000000000000000000000000007e570bbdf7df3ae150", + "logIndex": 0, + "blockHash": "0x4aa46f2060b623150529415819a46380d9488d06652249d474753d4c6ba03088" + } + ], + "blockNumber": 15692423, + "cumulativeGasUsed": "799181", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"collateralToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"isWrappedNativeToken\",\"type\":\"bool\"}],\"name\":\"init\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"loanSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"supply_\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"supply_\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address payable\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"deposit(uint256,uint256)\":{\"params\":{\"amount\":\"the amount of collateral tokens to be deposited\",\"loanID\":\"the ID of the loan\"}},\"init(address,bool)\":{\"params\":{\"isWrappedNativeToken\":\"check if it's wrapped Ethereum/MATIC\",\"tokenAddress\":\"the address of the collateral token to be stored\"}},\"loanSupply(uint256)\":{\"params\":{\"loanID\":\"the respective loan ID\"},\"returns\":{\"supply_\":\"the amount in collateral of the respective loan\"}},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner.\"},\"totalSupply()\":{\"returns\":{\"supply_\":\"the total amount of collateral\"}},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"},\"withdraw(uint256,uint256,address)\":{\"details\":\"only the TellerDiamond can make this call on behalf of the borrower\",\"params\":{\"amount\":\"number of collateral tokens to send\",\"loanID\":\"identifier of the loan\",\"receiver\":\"payable address to transfer money to\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"deposit(uint256,uint256)\":{\"notice\":\"it deposits an amount of the respective collateral token into the escrow\"},\"init(address,bool)\":{\"notice\":\"it initializes an escrow\"},\"loanSupply(uint256)\":{\"notice\":\"it returns the supply of collateral of the respective loan\"},\"totalSupply()\":{\"notice\":\"it returns the total supply of the collateral token held by the contract\"},\"withdraw(uint256,uint256,address)\":{\"notice\":\"it withdraws an amount of tokens in a respective loanID on behalf of the borrower\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/market/collateral/CollateralEscrow_V1.sol\":\"CollateralEscrow_V1\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n function __Ownable_init() internal initializer {\\n __Context_init_unchained();\\n __Ownable_init_unchained();\\n }\\n\\n function __Ownable_init_unchained() internal initializer {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0xc68cad93ce702131a09334e8705d4af062278defa99627a2c94685fb96ff8cc4\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"contracts/market/collateral/CollateralEscrow_V1.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ICollateralEscrow } from \\\"./ICollateralEscrow.sol\\\";\\nimport { IWETH } from \\\"../../shared/interfaces/IWETH.sol\\\";\\n\\n// Libraries\\nimport {\\n SafeERC20\\n} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Address } from \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\ncontract CollateralEscrow_V1 is OwnableUpgradeable, ICollateralEscrow {\\n mapping(uint256 => uint256) internal _balances; // loanID -> collateral\\n address public collateralToken;\\n bool internal _isWrappedNativeToken; // Should this be renamed to _isNetworkToken? more agnostic in cases of WMATIC\\n\\n /**\\n * @notice it initializes an escrow\\n * @param tokenAddress the address of the collateral token to be stored\\n * @param isWrappedNativeToken check if it's wrapped Ethereum/MATIC\\n */\\n function init(address tokenAddress, bool isWrappedNativeToken)\\n external\\n override\\n {\\n require(\\n tokenAddress != address(0),\\n \\\"Teller escrow: collateral token address 0\\\"\\n );\\n\\n OwnableUpgradeable.__Ownable_init();\\n collateralToken = tokenAddress;\\n _isWrappedNativeToken = isWrappedNativeToken;\\n }\\n\\n /**\\n * @notice it deposits an amount of the respective collateral token into the escrow\\n * @param loanID the ID of the loan\\n * @param amount the amount of collateral tokens to be deposited\\n */\\n function deposit(uint256 loanID, uint256 amount)\\n external\\n payable\\n override\\n onlyOwner\\n {\\n if (_isWrappedNativeToken && msg.value > 0) {\\n require(msg.value == amount, \\\"Teller: incorrect eth deposit\\\");\\n IWETH(collateralToken).deposit{ value: msg.value }();\\n } else {\\n SafeERC20.safeTransferFrom(\\n IERC20(collateralToken),\\n msg.sender,\\n address(this),\\n amount\\n );\\n }\\n\\n _balances[loanID] += amount;\\n }\\n\\n /**\\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\\n * @dev only the TellerDiamond can make this call on behalf of the borrower\\n * @param loanID identifier of the loan\\n * @param amount number of collateral tokens to send\\n * @param receiver payable address to transfer money to\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external override onlyOwner {\\n require(\\n _balances[loanID] >= amount,\\n \\\"Teller escrow: Insufficient collateral balance\\\"\\n );\\n\\n SafeERC20.safeTransfer(IERC20(collateralToken), receiver, amount);\\n _balances[loanID] -= amount;\\n }\\n\\n /**\\n * @notice it returns the supply of collateral of the respective loan\\n * @param loanID the respective loan ID\\n * @return supply_ the amount in collateral of the respective loan\\n */\\n function loanSupply(uint256 loanID)\\n external\\n view\\n override\\n returns (uint256 supply_)\\n {\\n supply_ = _balances[loanID];\\n }\\n\\n /**\\n * @notice it returns the total supply of the collateral token held by the contract\\n * @return supply_ the total amount of collateral\\n */\\n function totalSupply() external view override returns (uint256 supply_) {\\n supply_ = IERC20(collateralToken).balanceOf(address(this));\\n }\\n}\\n\",\"keccak256\":\"0x40e9fc6a37e8ada5a1f377b7b45f103da74af07cd8ed3d43acbcbe33547086bd\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n /**\\n * @notice it initializes an escrow\\n * @param tokenAddress the address of the collateral token to be stored\\n * @param isWETH check if it's wrapped Ethereum\\n */\\n function init(address tokenAddress, bool isWETH) external;\\n\\n /**\\n * @notice it deposits an amount of the respective collateral token into the escrow\\n * @param loanID the ID of the loan\\n * @param amount the amount of collateral tokens to be deposited\\n */\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n /**\\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\\n * @dev only the TellerDiamond can make this call on behalf of the borrower\\n * @param loanID identifier of the loan\\n * @param amount number of collateral tokens to send\\n * @param receiver payable address to transfer money to\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n /**\\n * @notice it returns the supply of the respective loan\\n * @param loanID the respective loan ID\\n * @return supply_ the amount in collateral of the respective loan\\n */\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n /**\\n * @notice it returns the total supply of the collateral token held by the contract\\n * @return supply_ the total amount of collateral\\n */\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x900fed2311f919ba1451a6583ddbf9f3bc8afa8f5189500fff51f0c049258ed3\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IWETH.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @notice It is the interface of functions that we use for the canonical WETH contract.\\n *\\n * @author develop@teller.finance\\n */\\ninterface IWETH {\\n /**\\n * @notice It withdraws ETH from the contract by sending it to the caller and reducing the caller's internal balance of WETH.\\n * @param amount The amount of ETH to withdraw.\\n */\\n function withdraw(uint256 amount) external;\\n\\n /**\\n * @notice It deposits ETH into the contract and increases the caller's internal balance of WETH.\\n */\\n function deposit() external payable;\\n\\n /**\\n * @notice It gets the ETH deposit balance of an {account}.\\n * @param account Address to get balance of.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x87169a67e37de400b6fa85dd7dbe8a882360033be9ae21a6788ce4ebbba4bbd5\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "kind": "dev", + "methods": { + "deposit(uint256,uint256)": { + "params": { + "amount": "the amount of collateral tokens to be deposited", + "loanID": "the ID of the loan" + } + }, + "init(address,bool)": { + "params": { + "isWrappedNativeToken": "check if it's wrapped Ethereum/MATIC", + "tokenAddress": "the address of the collateral token to be stored" + } + }, + "loanSupply(uint256)": { + "params": { + "loanID": "the respective loan ID" + }, + "returns": { + "supply_": "the amount in collateral of the respective loan" + } + }, + "owner()": { + "details": "Returns the address of the current owner." + }, + "renounceOwnership()": { + "details": "Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner." + }, + "totalSupply()": { + "returns": { + "supply_": "the total amount of collateral" + } + }, + "transferOwnership(address)": { + "details": "Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner." + }, + "withdraw(uint256,uint256,address)": { + "details": "only the TellerDiamond can make this call on behalf of the borrower", + "params": { + "amount": "number of collateral tokens to send", + "loanID": "identifier of the loan", + "receiver": "payable address to transfer money to" + } + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "deposit(uint256,uint256)": { + "notice": "it deposits an amount of the respective collateral token into the escrow" + }, + "init(address,bool)": { + "notice": "it initializes an escrow" + }, + "loanSupply(uint256)": { + "notice": "it returns the supply of collateral of the respective loan" + }, + "totalSupply()": { + "notice": "it returns the total supply of the collateral token held by the contract" + }, + "withdraw(uint256,uint256,address)": { + "notice": "it withdraws an amount of tokens in a respective loanID on behalf of the borrower" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [ + { + "astId": 635, + "contract": "contracts/market/collateral/CollateralEscrow_V1.sol:CollateralEscrow_V1", + "label": "_initialized", + "offset": 0, + "slot": "0", + "type": "t_bool" + }, + { + "astId": 638, + "contract": "contracts/market/collateral/CollateralEscrow_V1.sol:CollateralEscrow_V1", + "label": "_initializing", + "offset": 1, + "slot": "0", + "type": "t_bool" + }, + { + "astId": 2833, + "contract": "contracts/market/collateral/CollateralEscrow_V1.sol:CollateralEscrow_V1", + "label": "__gap", + "offset": 0, + "slot": "1", + "type": "t_array(t_uint256)50_storage" + }, + { + "astId": 509, + "contract": "contracts/market/collateral/CollateralEscrow_V1.sol:CollateralEscrow_V1", + "label": "_owner", + "offset": 0, + "slot": "51", + "type": "t_address" + }, + { + "astId": 628, + "contract": "contracts/market/collateral/CollateralEscrow_V1.sol:CollateralEscrow_V1", + "label": "__gap", + "offset": 0, + "slot": "52", + "type": "t_array(t_uint256)49_storage" + }, + { + "astId": 15548, + "contract": "contracts/market/collateral/CollateralEscrow_V1.sol:CollateralEscrow_V1", + "label": "_balances", + "offset": 0, + "slot": "101", + "type": "t_mapping(t_uint256,t_uint256)" + }, + { + "astId": 15550, + "contract": "contracts/market/collateral/CollateralEscrow_V1.sol:CollateralEscrow_V1", + "label": "collateralToken", + "offset": 0, + "slot": "102", + "type": "t_address" + }, + { + "astId": 15552, + "contract": "contracts/market/collateral/CollateralEscrow_V1.sol:CollateralEscrow_V1", + "label": "_isWrappedNativeToken", + "offset": 20, + "slot": "102", + "type": "t_bool" + } + ], + "types": { + "t_address": { + "encoding": "inplace", + "label": "address", + "numberOfBytes": "20" + }, + "t_array(t_uint256)49_storage": { + "base": "t_uint256", + "encoding": "inplace", + "label": "uint256[49]", + "numberOfBytes": "1568" + }, + "t_array(t_uint256)50_storage": { + "base": "t_uint256", + "encoding": "inplace", + "label": "uint256[50]", + "numberOfBytes": "1600" + }, + "t_bool": { + "encoding": "inplace", + "label": "bool", + "numberOfBytes": "1" + }, + "t_mapping(t_uint256,t_uint256)": { + "encoding": "mapping", + "key": "t_uint256", + "label": "mapping(uint256 => uint256)", + "numberOfBytes": "32", + "value": "t_uint256" + }, + "t_uint256": { + "encoding": "inplace", + "label": "uint256", + "numberOfBytes": "32" + } + } + } +} diff --git a/deployments/polygon_mumbai/CollateralFacet.json b/deployments/polygon_mumbai/CollateralFacet.json new file mode 100644 index 000000000..1357154c9 --- /dev/null +++ b/deployments/polygon_mumbai/CollateralFacet.json @@ -0,0 +1,200 @@ +{ + "address": "0xe42b077B892a0B282F2B636C017199d5a55B192b", + "abi": [ + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "CollateralFacet", + "transactionHash": "0xb0994a56ae53e1ce6479f6ac5b5a38e9b7df71a6b9536e403ddcf33bdd9b5468", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0xe42b077B892a0B282F2B636C017199d5a55B192b", + "transactionIndex": 0, + "gasUsed": "1369968", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000800100000000000000000100000000004000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000080000000000000000000200000000000000000000000000000000000000000000000000000000000004000000000000100000001000000000000000000000000000000100040000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0x7bb589b41e08d529924b3d78f27846682007dbf934322837264c01b8eace0580", + "transactionHash": "0xb0994a56ae53e1ce6479f6ac5b5a38e9b7df71a6b9536e403ddcf33bdd9b5468", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692467, + "transactionHash": "0xb0994a56ae53e1ce6479f6ac5b5a38e9b7df71a6b9536e403ddcf33bdd9b5468", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000be188d6641e8b680743a4815dfa0f6208038960f" + ], + "data": "0x0000000000000000000000000000000000000000000000000092035befcf40000000000000000000000000000000000000000000000000003df4de5a49f1a40000000000000000000000000000000000000000000000007e5a92f43a16eec5500000000000000000000000000000000000000000000000003d62dafe5a22640000000000000000000000000000000000000000000000007e5b24f79606be0550", + "logIndex": 0, + "blockHash": "0x7bb589b41e08d529924b3d78f27846682007dbf934322837264c01b8eace0580" + } + ], + "blockNumber": 15692467, + "cumulativeGasUsed": "1369968", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"address[]\",\"name\":\"collateralTokens\",\"type\":\"address[]\"}],\"name\":\"addCollateralTokens\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"depositCollateral\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"getCollateralTokens\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLoanCollateral\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"supply_\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"withdrawCollateral\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"addCollateralTokens(address,address[])\":{\"params\":{\"asset\":\"Token address to add allowed collateral tokens.\",\"collateralTokens\":\"List of allowed collateral token addresses. Requirements: - Sender must be admin\"}},\"depositCollateral(uint256,uint256)\":{\"params\":{\"amount\":\"The amount to deposit as collateral.\",\"loanID\":\"The ID of the loan the collateral is for\"}},\"getCollateralTokens(address)\":{\"params\":{\"asset\":\"token address to get allowed collateral tokens\"},\"returns\":{\"tokens_\":\"collateral tokens that are accepted\"}},\"getLoanCollateral(uint256)\":{\"params\":{\"loanID\":\"the identifier of the respective loan\"},\"returns\":{\"supply_\":\"the total amount of supply in collateral of the loan\"}},\"withdrawCollateral(uint256,uint256)\":{\"params\":{\"amount\":\"to wtihdraw from the loan\",\"loanID\":\"identifier of our loan\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"addCollateralTokens(address,address[])\":{\"notice\":\"Adds tokens allowed to be used as collateral for {asset} loans.it creates an escrow for each collateral token address\"},\"depositCollateral(uint256,uint256)\":{\"notice\":\"Deposit collateral tokens into a loan.\"},\"getCollateralTokens(address)\":{\"notice\":\"get list of collateral tokens that is allowed to be used on an {asset} loan\"},\"getLoanCollateral(uint256)\":{\"notice\":\"get the total collateral tokens in a respective loan\"},\"withdrawCollateral(uint256,uint256)\":{\"notice\":\"it withdraws collateral tokens from a loan\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/market/CollateralFacet.sol\":\"CollateralFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/reentry/ReentryMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nabstract contract ReentryMods {\\n modifier nonReentry(bytes32 id) {\\n AccessControlStorage storage s = AccessControlStorageLib.store();\\n require(!s.entered[id], \\\"AccessControl: reentered\\\");\\n s.entered[id] = true;\\n _;\\n s.entered[id] = false;\\n }\\n}\\n\",\"keccak256\":\"0x033c1164af25ef7d35a38a60973bf379b1cc603596914ffd85dcbcf0acdb6970\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../../../shared/interfaces/IAToken.sol\\\";\\nimport {\\n IAaveLendingPool\\n} from \\\"../../../shared/interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../../../shared/interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xd05e3E715d945B59290df0ae8eF85c1BdB684744 // Polygon mainnet\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x4c18d46f924a3a24d596971d39857477b618dad13dee55decc271bdccf915ee5\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n /**\\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\\n * @param dappAddress address of the target contract address\\n * @param dappData encoded abi of the function in our contract we want to call\\n * @return the called data in bytes\\n */\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n /**\\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\\n * @param token address of the respective ERC20 token to approve for the spender\\n * @param spender address of the respective spender who is approved by the token contract\\n */\\n function setTokenAllowance(address token, address spender) external;\\n\\n /**\\n * @notice it allows user to claim their escrow tokens\\n * @dev only the owner (TellerDiamond) can make this call on behalf of the users\\n * @param token address of the respective token contract to claim tokens from\\n * @param to address where the tokens should be transferred to\\n * @param amount uint256 amount of tokens to be claimed\\n */\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xaf67fc4454ffaa4d2f7e46fe7101876e8ebdb1a5426c30f87b8e18cc573ac019\",\"license\":\"MIT\"},\"contracts/escrow/libraries/LibEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibDapps } from \\\"../dapps/libraries/LibDapps.sol\\\";\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibEscrow {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\\n e_ = s().loanEscrows[loanID];\\n }\\n\\n /**\\n * @notice It returns a list of tokens owned by a loan escrow\\n * @param loanID uint256 index used to return our token list\\n * @return t_ which is a list of tokens \\n */\\n function getEscrowTokens(uint256 loanID)\\n internal\\n view\\n returns (EnumerableSet.AddressSet storage t_)\\n {\\n t_ = s().escrowTokens[loanID];\\n }\\n\\n /**\\n * @notice It returns the balance of a respective token in a loan escrow\\n * @param loanID uint256 index used to point to our loan escrow\\n * @param token address of respective token to give us the balance of in our loan escrow\\n * @return uint256 balance of respective token returned in an escrow loan\\n */\\n function balanceOf(uint256 loanID, address token)\\n internal\\n view\\n returns (uint256)\\n {\\n return IERC20(token).balanceOf(address(e(loanID)));\\n }\\n\\n /**\\n * @notice Adds or removes tokens held by the Escrow contract\\n * @param loanID The loan ID to update the token list for\\n * @param tokenAddress The token address to be added or removed\\n */\\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\\n // Skip if is lending token\\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\\n\\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\\n if (balanceOf(loanID, tokenAddress) > 0) {\\n if (!contains) {\\n EnumerableSet.add(tokens, tokenAddress);\\n }\\n } else if (contains) {\\n EnumerableSet.remove(tokens, tokenAddress);\\n }\\n }\\n\\n /**\\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\\n * @param loanID The loan ID to calculate value for\\n * @return value_ Escrow total value denoted in the lending token.\\n */\\n function calculateTotalValue(uint256 loanID)\\n internal\\n view\\n returns (uint256 value_)\\n {\\n address lendingToken = LibLoans.loan(loanID).lendingToken;\\n value_ += balanceOf(loanID, lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\\n if (EnumerableSet.length(tokens) > 0) {\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n uint256 tokenBal =\\n balanceOf(loanID, EnumerableSet.at(tokens, i));\\n value_ += PriceAggLib.valueFor(\\n EnumerableSet.at(tokens, i),\\n lendingToken,\\n tokenBal\\n );\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x17a7c6b11d6f280948e320525d1e131b89c23f80216918aa070df437a851d915\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when a user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when a user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n * @return ERC20 token\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n * @return balance_ the balance of the account\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice It calculates the total supply of the underlying asset.\\n * @return totalSupply_ the total supply denoted in the underlying asset.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given market.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n \\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfill the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n * @return mintAmount_ the amount minted of the specified token\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n * @return address of the strategy contract\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n * @param state boolean value that resembles the platform's state\\n */\\n function restrict(bool state) external virtual;\\n\\n /**\\n * @notice it initializes the Teller Token\\n * @param admin address of the admin to the respective Teller Token\\n * @param underlying address of the ERC20 token\\n */\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xf30ac4ef491851477ff9a3dd04974ebe74b529c37a3ef4e05798c3f734ceeb3d\",\"license\":\"MIT\"},\"contracts/market/CollateralFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport {\\n ReentryMods\\n} from \\\"../contexts2/access-control/reentry/ReentryMods.sol\\\";\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../shared/roles.sol\\\";\\n\\n// Libraries\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibCollateral } from \\\"./libraries/LibCollateral.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n LoanStatus,\\n Loan\\n} from \\\"../storage/market.sol\\\";\\n\\ncontract CollateralFacet is RolesMods, ReentryMods, PausableMods {\\n /**\\n * @notice Deposit collateral tokens into a loan.\\n * @param loanID The ID of the loan the collateral is for\\n * @param amount The amount to deposit as collateral.\\n */\\n function depositCollateral(uint256 loanID, uint256 amount)\\n external\\n payable\\n paused(\\\"\\\", false)\\n nonReentry(\\\"\\\")\\n authorized(AUTHORIZED, msg.sender)\\n {\\n uint256 status = uint256(LibLoans.loan(loanID).status);\\n require(\\n status ==\\n (uint256(LoanStatus.TermsSet) ^ uint256(LoanStatus.Active)) &\\n status,\\n \\\"Teller: loan not active or set\\\"\\n );\\n\\n // Transfer tokens to the collateral escrow\\n LibCollateral.deposit(loanID, amount);\\n }\\n\\n /**\\n * @notice it withdraws collateral tokens from a loan\\n * @param amount to wtihdraw from the loan\\n * @param loanID identifier of our loan\\n */\\n function withdrawCollateral(uint256 amount, uint256 loanID)\\n external\\n paused(\\\"\\\", false)\\n nonReentry(\\\"\\\")\\n authorized(AUTHORIZED, msg.sender)\\n {\\n // check if caller is borrower\\n require(\\n msg.sender == LibLoans.loan(loanID).borrower,\\n \\\"Teller: not borrower\\\"\\n );\\n\\n // check if amount required to withdraw is more than zero\\n require(amount > 0, \\\"Teller: zero withdraw\\\");\\n\\n // here, we check if the loan supply minus the needed collateral tokens is still\\n // greater than the amount we want to withdraw\\n if (LibLoans.loan(loanID).status == LoanStatus.Active) {\\n (, uint256 needed, ) = LibLoans.getCollateralNeededInfo(loanID);\\n if (needed > 0) {\\n require(\\n LibCollateral.e(loanID).loanSupply(loanID) - needed >=\\n amount,\\n \\\"Teller: collateral withdraw amount over limit\\\"\\n );\\n }\\n }\\n\\n // Withdraw collateral and send to loan borrower\\n LibCollateral.withdraw(loanID, amount, LibLoans.loan(loanID).borrower);\\n }\\n\\n /**\\n * @notice Adds tokens allowed to be used as collateral for {asset} loans.\\n * @notice it creates an escrow for each collateral token address\\n * @param asset Token address to add allowed collateral tokens.\\n * @param collateralTokens List of allowed collateral token addresses.\\n *\\n * Requirements:\\n * - Sender must be admin\\n */\\n function addCollateralTokens(\\n address asset,\\n address[] calldata collateralTokens\\n ) external authorized(ADMIN, msg.sender) {\\n for (uint256 i; i < collateralTokens.length; i++) {\\n EnumerableSet.add(\\n MarketStorageLib.store().collateralTokens[asset],\\n collateralTokens[i]\\n );\\n LibCollateral.createEscrow(collateralTokens[i]);\\n }\\n }\\n\\n /**\\n * @notice get list of collateral tokens that is allowed to be used on an {asset} loan\\n * @param asset token address to get allowed collateral tokens\\n * @return tokens_ collateral tokens that are accepted\\n */\\n function getCollateralTokens(address asset)\\n external\\n view\\n returns (address[] memory tokens_)\\n {\\n EnumerableSet.AddressSet storage collateralTokens =\\n MarketStorageLib.store().collateralTokens[asset];\\n tokens_ = new address[](EnumerableSet.length(collateralTokens));\\n for (uint256 i; i < EnumerableSet.length(collateralTokens); i++) {\\n tokens_[i] = EnumerableSet.at(collateralTokens, i);\\n }\\n }\\n\\n /**\\n * @notice get the total collateral tokens in a respective loan\\n * @param loanID the identifier of the respective loan\\n * @return supply_ the total amount of supply in collateral of the loan\\n */\\n function getLoanCollateral(uint256 loanID)\\n external\\n view\\n returns (uint256 supply_)\\n {\\n supply_ = LibCollateral.e(loanID).loanSupply(loanID);\\n }\\n}\\n\",\"keccak256\":\"0xaf2209ada5114b452aee9786c350bd4deb3e1ac55163fbd664a95b91bf8fd4bd\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n /**\\n * @notice it initializes an escrow\\n * @param tokenAddress the address of the collateral token to be stored\\n * @param isWETH check if it's wrapped Ethereum\\n */\\n function init(address tokenAddress, bool isWETH) external;\\n\\n /**\\n * @notice it deposits an amount of the respective collateral token into the escrow\\n * @param loanID the ID of the loan\\n * @param amount the amount of collateral tokens to be deposited\\n */\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n /**\\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\\n * @dev only the TellerDiamond can make this call on behalf of the borrower\\n * @param loanID identifier of the loan\\n * @param amount number of collateral tokens to send\\n * @param receiver payable address to transfer money to\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n /**\\n * @notice it returns the supply of the respective loan\\n * @param loanID the respective loan ID\\n * @return supply_ the amount in collateral of the respective loan\\n */\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n /**\\n * @notice it returns the total supply of the collateral token held by the contract\\n * @return supply_ the total amount of collateral\\n */\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x900fed2311f919ba1451a6583ddbf9f3bc8afa8f5189500fff51f0c049258ed3\",\"license\":\"MIT\"},\"contracts/market/libraries/LibCollateral.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport { ICollateralEscrow } from \\\"../collateral/ICollateralEscrow.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\nimport { MarketStorageLib } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibCollateral {\\n /**\\n * @notice This event is emitted when collateral has been deposited for the loan\\n * @param loanID ID of the loan for which collateral was deposited\\n * @param depositor Account that deposited funds\\n * @param amount Amount of collateral deposited\\n */\\n event CollateralDeposited(\\n uint256 indexed loanID,\\n address indexed depositor,\\n uint256 amount\\n );\\n\\n /**\\n * @notice This event is emitted when collateral has been withdrawn\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param receiver Account that received funds\\n * @param amount Value of collateral withdrawn\\n */\\n event CollateralWithdrawn(\\n uint256 indexed loanID,\\n address indexed receiver,\\n uint256 amount\\n );\\n\\n /**\\n * @notice it gets MarketStorage's collateral escrow using the loanID\\n * @param loanID the loanID to be used\\n * @return c_ which is the collateral escrow\\n */\\n function e(uint256 loanID) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[\\n MarketStorageLib.store().loans[loanID].collateralToken\\n ];\\n }\\n\\n function e(address token) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[token];\\n }\\n\\n /**\\n * @notice it deposits an amount of collateral into a collateral escrow's address of a respective loan\\n * @param loanID the respective loan ID\\n * @param amount the amount of collateral to deposit\\n */\\n function deposit(uint256 loanID, uint256 amount) internal {\\n e(loanID).deposit{ value: amount }(loanID, amount);\\n\\n emit CollateralDeposited(loanID, msg.sender, amount);\\n }\\n\\n /**\\n * @notice it withdraws an amount from the collateral escrow\\n * @param loanID the respective loanID to withdraw from\\n * @param amount the number of collateral tokens to withdraw\\n * @param receiver the address who receives the withdrawal\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) internal {\\n e(loanID).withdraw(loanID, amount, receiver);\\n\\n emit CollateralWithdrawn(loanID, receiver, amount);\\n }\\n\\n /**\\n * @notice it withdraws the entire supply in collateral of a respective loan to an address\\n * @param loanID the respective loan's ID\\n * @param receiver the address of the receiver to withdraw tokens from\\n */\\n function withdrawAll(uint256 loanID, address payable receiver) internal {\\n withdraw(loanID, e(loanID).loanSupply(loanID), receiver);\\n }\\n\\n /**\\n * @notice it initializes a new escrow collateral to hold collateral tokens\\n * @param token address of the collateral token it holds\\n */\\n function createEscrow(address token) internal {\\n // Check if collateral escrow exists\\n if (address(e(token)) == address(0)) {\\n // Create escrow\\n address escrow =\\n AppStorageLib.store().collateralEscrowBeacon.cloneProxy(\\\"\\\");\\n ICollateralEscrow(escrow).init(\\n token,\\n // Check if collateral token is the base network token\\n token == AppStorageLib.store().wrappedNativeToken\\n );\\n\\n // Set max allowance\\n IERC20(token).approve(escrow, type(uint256).max);\\n // Save escrow address for loan\\n MarketStorageLib.store().collateralEscrows[\\n token\\n ] = ICollateralEscrow(escrow);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x539fb96f6d41224bfe644fbd3def4d1c0bba3ffcd31e659ff6b4bd274c5a39da\",\"license\":\"MIT\"},\"contracts/market/libraries/LibLoans.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibEscrow } from \\\"../../escrow/libraries/LibEscrow.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus,\\n LoanDebt,\\n LoanTerms\\n} from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibLoans {\\n using NumbersLib for int256;\\n using NumbersLib for uint256;\\n\\n bytes32 internal constant ID = keccak256(\\\"LOANS\\\");\\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n * @notice it returns the loan\\n * @param loanID the ID of the respective loan\\n * @return l_ the loan\\n */\\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\\n l_ = s().loans[loanID];\\n }\\n\\n /**\\n * @notice it returns the loan debt from a respective loan\\n * @param loanID the ID of the respective loan\\n * @return d_ the loan debt from a respective loan\\n */\\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\\n d_ = s().loanDebt[loanID];\\n }\\n\\n // DEPRECATED\\n function terms(uint256 loanID)\\n internal\\n view\\n returns (LoanTerms storage t_)\\n {\\n t_ = s()._loanTerms[loanID];\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return owed_ uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID)\\n internal\\n view\\n returns (uint256 owed_)\\n {\\n if (loan(loanID).status == LoanStatus.Active) {\\n owed_ = debt(loanID).principalOwed + (debt(loanID).interestOwed);\\n }\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n internal\\n view\\n returns (uint256)\\n {\\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\\n }\\n\\n function getCollateralNeeded(uint256 loanID)\\n internal\\n view\\n returns (uint256 _needed)\\n {\\n (, _needed, ) = getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the total collateral needed in lending tokens, in collateral tokens and in escrowed loan values\\n * @param loanID the loanID to get the total collateral needed\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n internal\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\\n loanID\\n );\\n\\n // check if needed lending tokens is zero. if true, then needed collateral tokens is zero. else,\\n if (neededInLendingTokens == 0) {\\n neededInCollateralTokens = 0;\\n } else {\\n neededInCollateralTokens = PriceAggLib.valueFor(\\n loan(loanID).lendingToken,\\n loan(loanID).collateralToken,\\n neededInLendingTokens\\n );\\n }\\n }\\n\\n /**\\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\\n * @param loanID The loan ID to get needed collateral info for.\\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\\n */\\n function getCollateralNeededInTokens(uint256 loanID)\\n internal\\n view\\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\\n {\\n if (loan(loanID).collateralRatio == 0) {\\n return (0, 0);\\n }\\n\\n /*\\n The collateral to principal owed ratio is the sum of:\\n * collateral buffer percent\\n * loan interest rate\\n * liquidation reward percent\\n * X factor of additional collateral\\n */\\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n neededInLendingTokens = loan(loanID).borrowedAmount.percent(\\n loan(loanID).collateralRatio\\n );\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n uint16 requiredRatio =\\n loan(loanID).collateralRatio -\\n getInterestRatio(loanID) -\\n uint16(PlatformSettingsLib.getCollateralBufferValue());\\n\\n neededInLendingTokens =\\n debt(loanID).principalOwed +\\n debt(loanID).interestOwed;\\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\\n if (\\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\\n ) {\\n neededInLendingTokens -= escrowLoanValue;\\n }\\n neededInLendingTokens = neededInLendingTokens.percent(\\n requiredRatio\\n );\\n }\\n }\\n\\n /**\\n * @notice check if a loan can go to end of auction with a collateral ratio\\n * @return bool checking if collateralRatio is >= the over collateralized buffer value\\n */\\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\\n internal\\n view\\n returns (bool)\\n {\\n return\\n collateralRatio >=\\n PlatformSettingsLib.getOverCollateralizedBufferValue();\\n }\\n\\n /**\\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\\n * @notice There is a minimum threshold of 1%.\\n * @dev The interest rate is APY (annual percentage yield).\\n * @param loanID The loan ID to get the interest rate for.\\n */\\n function getInterestRatio(uint256 loanID)\\n internal\\n view\\n returns (uint16 ratio_)\\n {\\n ratio_ = uint16(\\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\\n SECONDS_PER_YEAR\\n );\\n\\n if (ratio_ == 0) {\\n ratio_ = 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0xaabb82718f6948669e5c984d7bdc0d0ae4806e3b17beba4dd60e771d67444c07\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x417b75f5d92be67993efc54db7d453be5b5058a9a54d8916380e0281d3299526\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param amount Amount of the source token to convert into the destination token.\\n * @param exchangeRate The calculated exchange rate between the tokens.\\n * @return uint256 Value of the source token amount given an exchange rate peg.\\n */\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n /**\\n * @notice it returns 10^{numberOfDecimals} for a token\\n * @param token the address to calculate the decimals for\\n * @return 10^number of decimals used to calculate the price and value of different token pairs\\n */\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @notice It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @notice it tries to calculate a price from Compound and Chainlink.\\n * @dev if no price is found on compound, then calculate it on chainlink\\n * @param src the token address to calculate the price for in dst\\n * @param dst the token address to retrieve the price of src\\n * @return price_ the price of src in dst\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n * @param src the address of the src token\\n * @param dst the address of the dst token\\n * @return the price of the src token in dst token\\n\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n * @param src the source token to calculate price for with chainlink\\n * @param dst the destination token to calculate price for with chainlink\\n * @param cRate the compound rate to multiply with the price of the dst token\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @notice Scales the {value} by the difference in decimal values.\\n * @param value the the value of the src in dst\\n * @param srcDecimals src token decimals\\n * @param dstDecimals dst token decimals\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @notice it tries to calculate the price of {src} in {dst}\\n * @param src address of source token\\n * @param dst address of destination token\\n * @return the price of src token in dst\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address wrappedNativeToken =\\n AppStorageLib.store().wrappedNativeToken;\\n if (dst != wrappedNativeToken) {\\n int256 price1 = _priceFor(src, wrappedNativeToken);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, wrappedNativeToken);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice it checks if a token is a cToken. If it is, then get the underlying address\\n * @param token address of the token\\n * @return isCToken boolean whether it's a cToken\\n * @return underlying the address of the cToken\\n */\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xcf6280e2d36fdedbca4c0b94e413832f4bb267202de235bfc1cf6fda26c780ec\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { PriceAggFacet } from \\\"./PriceAggFacet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\n/**\\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\\n */\\nlibrary PriceAggLib {\\n /**\\n * @notice It calculates the value of one token amount into another\\n * @param src the source token\\n * @param dst the destination token\\n * @param srcAmount the amount of source token\\n * @return value_ the returned value of src in dst\\n */\\n function valueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) internal view returns (uint256 value_) {\\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\\n }\\n\\n /**\\n * @notice It returns the price of the token pair as given from Compound.\\n * @dev if no compound price is calculated, then it checks Chainlink price Aggregator\\n * @param src the address of the source token\\n * @param dst the address of the desitnation token\\n * @return price_ gets the price of src in dst\\n */\\n function priceFor(address src, address dst)\\n internal\\n view\\n returns (int256 price_)\\n {\\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\\n }\\n}\\n\",\"keccak256\":\"0xff59eee567fa4a7f5cac432e31d918be92834f04614f49572d3984a5b030ac79\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\nabstract contract PausableMods {\\n /**\\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\\n * @param id id of the facet to check if is paused.\\n * @param state Boolean that the protocol AND facet should be in.\\n */\\n modifier paused(bytes32 id, bool state) {\\n require(\\n __isPaused(\\\"\\\") == state && __isPaused(id) == state,\\n __pausedMessage(state)\\n );\\n _;\\n }\\n\\n /**\\n * @dev Checks if the given id is paused.\\n * @param id Encoded id of the facet to check if is paused.\\n * @return the bool to tell us if the facet is paused (true) or not (false)\\n */\\n function __isPaused(bytes32 id) private view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n\\n /**\\n * @dev Gets the message that should be reverted with given a state it should be in.\\n * @param state Boolean that an id should be in.\\n * @return a message stating whether the facet is paused or not\\n */\\n function __pausedMessage(bool state) private pure returns (string memory) {\\n return state ? \\\"Pausable: not paused\\\" : \\\"Pausable: paused\\\";\\n }\\n}\\n\",\"keccak256\":\"0x2d3f848ee56ae5fa365539c2509c03c167affc89c89f98bb98cb9b83fbe8ae4c\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"NFTInterestRate\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getNFTInterestRate() internal view returns (uint16 value_) {\\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0x44294be1af9f913b2ed391a40cd4b646537a4b463b8d5ff1fac8ead3988966c1\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for loans taken out with an NFT.\\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\\n */\\nbytes32 constant NFT_INTEREST_RATE = keccak256(\\\"NFTInterestRate\\\");\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xd68a7df42b2bbba6f935d5890b7b37997c1432e25ae113827b8bde87f94fd86f\",\"license\":\"MIT\"},\"contracts/shared/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n /**\\n * @notice Checks if the account should be allowed to mint tokens in the given market\\n * @param cToken The market to verify the mint against\\n * @param minter The account which would get the minted tokens\\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates mint and reverts on rejection. May emit logs.\\n * @param cToken Asset being minted\\n * @param minter The address minting the tokens\\n * @param mintAmount The amount of the underlying asset being minted\\n * @param mintTokens The number of tokens being minted\\n */\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to redeem tokens in the given market\\n * @param cToken The market to verify the redeem against\\n * @param redeemer The account which would redeem the tokens\\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates redeem and reverts on rejection. May emit logs.\\n * @param cToken Asset being redeemed\\n * @param redeemer The address redeeming the tokens\\n * @param redeemAmount The amount of the underlying asset being redeemed\\n * @param redeemTokens The number of tokens being redeemed\\n */\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\\n * @param cToken The market to verify the borrow against\\n * @param borrower The account which would borrow the asset\\n * @param borrowAmount The amount of underlying the account would borrow\\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates borrow and reverts on rejection. May emit logs.\\n * @param cToken Asset whose underlying is being borrowed\\n * @param borrower The address borrowing the underlying\\n * @param borrowAmount The amount of the underlying asset requested to borrow\\n */\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to repay a borrow in the given market\\n * @param cToken The market to verify the repay against\\n * @param payer The account which would repay the asset\\n * @param borrower The account which would borrowed the asset\\n * @param repayAmount The amount of the underlying asset the account would repay\\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\\n * @param cToken Asset being repaid\\n * @param payer The address repaying the borrow\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param borrowerIndex the index of the borrower\\n */\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n /**\\n * @notice Checks if the liquidation should be allowed to occur\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n */\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the seizing of assets should be allowed to occur\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates seize and reverts on rejection. May emit logs.\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to transfer tokens in the given market\\n * @param cToken The market to verify the transfer against\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates transfer and reverts on rejection. May emit logs.\\n * @param cToken Asset being transferred\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n */\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in all markets\\n * @param holder The address to claim COMP for\\n */\\n function claimComp(address holder) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in the specified markets\\n * @param holder The address to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n */\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n /**\\n * @notice Claim all comp accrued by the holders\\n * @param holders The addresses to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n * @param borrowers Whether or not to claim COMP earned by borrowing\\n * @param suppliers Whether or not to claim COMP earned by supplying\\n */\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n /**\\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\\n * @param cTokenBorrowed The address of the borrowed cToken\\n * @param cTokenCollateral The address of the collateral cToken\\n * @param repayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\\n */\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n /**\\n * @notice Return the address of the COMP token\\n * @return The address of COMP\\n */\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x38a824a4a21ce9370fa581a616d1bb9d311f27d8982a6b96ebeba90bd5fd0adb\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n\\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x208769886b3db8f03ef1fa26f1caee189038dfc744b9a499402fc4e4c0090c38\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @dev CETH is the only Compound token that does not support the {underlying} function.\\n * @param cToken address of the compound token\\n * @return address of the underlying cToken\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x99206384c27b0e68b1ec7b82260f6a47965f611875c018bc076ff8a688a6c6d7\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n /**\\n * @notice it returns the absolute number of a specified parameter\\n * @param self the number to be returned in it's absolute\\n * @return the absolute number\\n */\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0x4f750cde25d4b1db919abf3192d58ed6aef617d03637e1e9e2dc31b70dcc32a3\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n address wrappedNativeToken;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4504c5c460972a25cd1f0e6eb1d8dd84a668be75a3aeb89a47a49c2327c12923\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\n// DEPRECATED\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\nstruct LoanRequest {\\n LoanUserRequest request;\\n LoanConsensusResponse[] responses;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanUserRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanConsensusResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) _loanTerms; // DEPRECATED: DO NOT REMOVE\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb7e05aeec806b5621512def93f4a389b4ef88c50ef9fe7115a33f57db2f2304b\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "0x60806040526004361061004a5760003560e01c8063010d57301461004f57806313abaf0714610082578063767a7b05146100a4578063ece13732146100c4578063ed903f7a146100d7575b600080fd5b34801561005b57600080fd5b5061006f61006a36600461153d565b610104565b6040519081526020015b60405180910390f35b34801561008e57600080fd5b506100a261009d36600461149a565b610192565b005b3480156100b057600080fd5b506100a26100bf36600461156d565b6102bb565b6100a26100d236600461156d565b61064d565b3480156100e357600080fd5b506100f76100f2366004611462565b61086e565b604051610079919061158e565b600061010f82610971565b6001600160a01b031663d17b71d7836040518263ffffffff1660e01b815260040161013c91815260200190565b60206040518083038186803b15801561015457600080fd5b505afa158015610168573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061018c9190611555565b92915050565b7fdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42336101be82826109de565b6101e35760405162461bcd60e51b81526004016101da9061162e565b60405180910390fd5b60005b838110156102b3576001600160a01b03861660009081527f0553069f1f0518e59f8623c18c83a1f987f2a0544d563e98dd803a7078142a8f602052604090206102639086868481811061024957634e487b7160e01b600052603260045260246000fd5b905060200201602081019061025e9190611462565b610a12565b506102a185858381811061028757634e487b7160e01b600052603260045260246000fd5b905060200201602081019061029c9190611462565b610a2e565b806102ab81611741565b9150506101e6565b505050505050565b600080806102c881610c4a565b15151480156102e257508015156102de83610c4a565b1515145b6102eb82610c62565b906103095760405162461bcd60e51b81526004016101da91906115db565b5060008080527f7b305b6be5f275f648d05716597c483d754c2a242bd605feba3c64fb853605366020527f63eec20f0ae1af135811da961c707cd581594291a92cf7bcd78c1cf1aca4e4b0547f7b305b6be5f275f648d05716597c483d754c2a242bd605feba3c64fb853605349060ff16156103c25760405162461bcd60e51b81526020600482015260186024820152771058d8d95cdcd0dbdb9d1c9bdb0e881c99595b9d195c995960421b60448201526064016101da565b60008281526002820160205260409020805460ff191660011790557f50e75b23f8ec51bbcb044fe377457e835f3b5ccc7ebf69e80906452015dff6073361040982826109de565b6104255760405162461bcd60e51b81526004016101da9061162e565b61042e87610cc7565b546001600160a01b0316331461047d5760405162461bcd60e51b81526020600482015260146024820152732a32b63632b91d103737ba103137b93937bbb2b960611b60448201526064016101da565b600088116104c55760405162461bcd60e51b815260206004820152601560248201527454656c6c65723a207a65726f20776974686472617760581b60448201526064016101da565b60026104d088610cc7565b600490810154600160e01b900460ff16908111156104fe57634e487b7160e01b600052602160045260246000fd5b141561061157600061050f88610ce4565b50915050801561060f5788816105248a610971565b6001600160a01b031663d17b71d78b6040518263ffffffff1660e01b815260040161055191815260200190565b60206040518083038186803b15801561056957600080fd5b505afa15801561057d573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906105a19190611555565b6105ab919061172a565b101561060f5760405162461bcd60e51b815260206004820152602d60248201527f54656c6c65723a20636f6c6c61746572616c20776974686472617720616d6f7560448201526c1b9d081bdd995c881b1a5b5a5d609a1b60648201526084016101da565b505b61062e878961061f8a610cc7565b546001600160a01b0316610d44565b5050600091825260020160205260409020805460ff1916905550505050565b6000808061065a81610c4a565b1515148015610674575080151561067083610c4a565b1515145b61067d82610c62565b9061069b5760405162461bcd60e51b81526004016101da91906115db565b5060008080527f7b305b6be5f275f648d05716597c483d754c2a242bd605feba3c64fb853605366020527f63eec20f0ae1af135811da961c707cd581594291a92cf7bcd78c1cf1aca4e4b0547f7b305b6be5f275f648d05716597c483d754c2a242bd605feba3c64fb853605349060ff16156107545760405162461bcd60e51b81526020600482015260186024820152771058d8d95cdcd0dbdb9d1c9bdb0e881c99595b9d195c995960421b60448201526064016101da565b60008281526002820160205260409020805460ff191660011790557f50e75b23f8ec51bbcb044fe377457e835f3b5ccc7ebf69e80906452015dff6073361079b82826109de565b6107b75760405162461bcd60e51b81526004016101da9061162e565b60006107c289610cc7565b600490810154600160e01b900460ff16908111156107f057634e487b7160e01b600052602160045260246000fd5b90506003811681146108445760405162461bcd60e51b815260206004820152601e60248201527f54656c6c65723a206c6f616e206e6f7420616374697665206f7220736574000060448201526064016101da565b61084e8989610e01565b505050600091825260020160205260409020805460ff1916905550505050565b6001600160a01b03811660009081527f0553069f1f0518e59f8623c18c83a1f987f2a0544d563e98dd803a7078142a8f602052604090206060906108b181610eaa565b67ffffffffffffffff8111156108d757634e487b7160e01b600052604160045260246000fd5b604051908082528060200260200182016040528015610900578160200160208202803683370190505b50915060005b61090f82610eaa565b81101561096a576109208282610eb4565b83828151811061094057634e487b7160e01b600052603260045260246000fd5b6001600160a01b03909216602092830291909101909101528061096281611741565b915050610906565b5050919050565b60009081527f0553069f1f0518e59f8623c18c83a1f987f2a0544d563e98dd803a7078142a8660209081526040808320600201546001600160a01b0390811684527f0553069f1f0518e59f8623c18c83a1f987f2a0544d563e98dd803a7078142a8b909252909120541690565b60006109e8610ec0565b6000938452602090815260408085206001600160a01b039490941685529290525090205460ff1690565b6000610a27836001600160a01b038416610ee9565b9392505050565b6001600160a01b0381811660009081527f0553069f1f0518e59f8623c18c83a1f987f2a0544d563e98dd803a7078142a8b602052604090205416610c4757600080600801546040516327662c6960e11b815260206004820152600060248201526001600160a01b0390911690634ecc58d290604401602060405180830381600087803b158015610abd57600080fd5b505af1158015610ad1573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610af5919061147e565b90506001600160a01b03811663cb9fa366836000600b015460405160e084901b6001600160e01b03191681526001600160a01b039283166004820152908216918616919091146024820152604401600060405180830381600087803b158015610b5d57600080fd5b505af1158015610b71573d6000803e3d6000fd5b505060405163095ea7b360e01b81526001600160a01b03848116600483015260001960248301528516925063095ea7b39150604401602060405180830381600087803b158015610bc057600080fd5b505af1158015610bd4573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610bf8919061151d565b506001600160a01b0382811660009081527f0553069f1f0518e59f8623c18c83a1f987f2a0544d563e98dd803a7078142a8b602052604090208054919092166001600160a01b03199091161790555b50565b60008181526001602052604090205460ff165b919050565b606081610c97576040518060400160405280601081526020016f14185d5cd8589b194e881c185d5cd95960821b81525061018c565b505060408051808201909152601481527314185d5cd8589b194e881b9bdd081c185d5cd95960621b602082015290565b6000610cd1610f38565b6000928352600101602052506040902090565b6000806000610cf284610f60565b909350905082610d055760009150610d3d565b610d3a610d1185610cc7565b600101546001600160a01b0316610d2786610cc7565b600201546001600160a01b0316856110e0565b91505b9193909250565b610d4d83610971565b604051630ad58d2f60e01b815260048101859052602481018490526001600160a01b0383811660448301529190911690630ad58d2f90606401600060405180830381600087803b158015610da057600080fd5b505af1158015610db4573d6000803e3d6000fd5b50505050806001600160a01b0316837f7c5e5cb62e5ed3caf3764e4b0afedfedef533e27809d43367799787ad2abcd4184604051610df491815260200190565b60405180910390a3505050565b610e0a82610971565b604051631c57762b60e31b815260048101849052602481018390526001600160a01b03919091169063e2bbb1589083906044016000604051808303818588803b158015610e5657600080fd5b505af1158015610e6a573d6000803e3d6000fd5b50506040518481523393508592507feec2f3feb835e2f2fd44281034b04700a1ddda63dd402949d470a25a7c40b36c915060200160405180910390a35050565b600061018c825490565b6000610a278383611171565b60007f7b305b6be5f275f648d05716597c483d754c2a242bd605feba3c64fb853605345b905090565b6000818152600183016020526040812054610f305750815460018181018455600084815260208082209093018490558454848252828601909352604090209190915561018c565b50600061018c565b60007f0553069f1f0518e59f8623c18c83a1f987f2a0544d563e98dd803a7078142a85610ee4565b600080610f6c83610cc7565b60040154600160d01b900461ffff16610f8a575060009050806110db565b6001610f9584610cc7565b600490810154600160e01b900460ff1690811115610fc357634e487b7160e01b600052602160045260246000fd5b1415610ffe57610ff7610fd584610cc7565b60040154600160d01b900461ffff16610fed85610cc7565b6003015490611205565b91506110db565b600261100984610cc7565b600490810154600160e01b900460ff169081111561103757634e487b7160e01b600052602160045260246000fd5b14156110db576000611047611222565b61105085611253565b61105986610cc7565b600401546110729190600160d01b900461ffff16611707565b61107c9190611707565b9050611087846112b3565b60010154611094856112b3565b5461109f9190611665565b92506110aa846112d0565b91506000821180156110bb57508183115b156110cd576110ca828461172a565b92505b6110d78382611205565b9250505b915091565b60405163c05b1ec360e01b81526001600160a01b0380851660048301528316602482015260448101829052600090309063c05b1ec39060640160206040518083038186803b15801561113157600080fd5b505afa158015611145573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906111699190611555565b949350505050565b815460009082106111cf5760405162461bcd60e51b815260206004820152602260248201527f456e756d657261626c655365743a20696e646578206f7574206f6620626f756e604482015261647360f01b60648201526084016101da565b8260000182815481106111f257634e487b7160e01b600052603260045260246000fd5b9060005260206000200154905092915050565b600061271061121861ffff8416856116b8565b610a27919061167d565b600061124d7f30876f9fd2a6e11f15d1ba3c09dc28f8fb0930bf076960ca8796d199fd0b2ec3611385565b54919050565b60006301e1338061126383610cc7565b60040154600160c01b900461ffff1661127b84610cc7565b600401546112969190600160801b900463ffffffff166116d7565b6112a09190611691565b905061ffff8116610c5d57506001919050565b60006112bd610f38565b6000928352600201602052506040902090565b6000806112dc83610cc7565b600101546001600160a01b031690506112f5838261138d565b6112ff9083611665565b9150600061130c8461141e565b9050600061131982610eaa565b111561096a5760005b61132b82610eaa565b81101561137d576000611347866113428585610eb4565b61138d565b905061135d6113568484610eb4565b85836110e0565b6113679086611665565b945050808061137590611741565b915050611322565b505050919050565b6000806112bd565b6000816001600160a01b03166370a082316113a78561143b565b6040516001600160e01b031960e084901b1681526001600160a01b03909116600482015260240160206040518083038186803b1580156113e657600080fd5b505afa1580156113fa573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610a279190611555565b6000611428610f38565b6000928352600501602052506040902090565b6000611445610f38565b60009283526004016020525060409020546001600160a01b031690565b600060208284031215611473578081fd5b8135610a2781611788565b60006020828403121561148f578081fd5b8151610a2781611788565b6000806000604084860312156114ae578182fd5b83356114b981611788565b9250602084013567ffffffffffffffff808211156114d5578384fd5b818601915086601f8301126114e8578384fd5b8135818111156114f6578485fd5b8760208260051b850101111561150a578485fd5b6020830194508093505050509250925092565b60006020828403121561152e578081fd5b81518015158114610a27578182fd5b60006020828403121561154e578081fd5b5035919050565b600060208284031215611566578081fd5b5051919050565b6000806040838503121561157f578182fd5b50508035926020909101359150565b6020808252825182820181905260009190848201906040850190845b818110156115cf5783516001600160a01b0316835292840192918401916001016115aa565b50909695505050505050565b6000602080835283518082850152825b81811015611607578581018301518582016040015282016115eb565b818111156116185783604083870101525b50601f01601f1916929092016040019392505050565b6020808252601d908201527f416363657373436f6e74726f6c3a206e6f7420617574686f72697a6564000000604082015260600190565b600082198211156116785761167861175c565b500190565b60008261168c5761168c611772565b500490565b600067ffffffffffffffff808416806116ac576116ac611772565b92169190910492915050565b60008160001904831182151516156116d2576116d261175c565b500290565b600067ffffffffffffffff808316818516818304811182151516156116fe576116fe61175c565b02949350505050565b600061ffff838116908316818110156117225761172261175c565b039392505050565b60008282101561173c5761173c61175c565b500390565b60006000198214156117555761175561175c565b5060010190565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052601260045260246000fd5b6001600160a01b0381168114610c4757600080fdfea26469706673582212204ba36b968d2193b7797aa1e51086b85a1996a61b77b01f1d153d9706b8b6a7ee64736f6c63430008030033", + "devdoc": { + "kind": "dev", + "methods": { + "addCollateralTokens(address,address[])": { + "params": { + "asset": "Token address to add allowed collateral tokens.", + "collateralTokens": "List of allowed collateral token addresses. Requirements: - Sender must be admin" + } + }, + "depositCollateral(uint256,uint256)": { + "params": { + "amount": "The amount to deposit as collateral.", + "loanID": "The ID of the loan the collateral is for" + } + }, + "getCollateralTokens(address)": { + "params": { + "asset": "token address to get allowed collateral tokens" + }, + "returns": { + "tokens_": "collateral tokens that are accepted" + } + }, + "getLoanCollateral(uint256)": { + "params": { + "loanID": "the identifier of the respective loan" + }, + "returns": { + "supply_": "the total amount of supply in collateral of the loan" + } + }, + "withdrawCollateral(uint256,uint256)": { + "params": { + "amount": "to wtihdraw from the loan", + "loanID": "identifier of our loan" + } + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "addCollateralTokens(address,address[])": { + "notice": "Adds tokens allowed to be used as collateral for {asset} loans.it creates an escrow for each collateral token address" + }, + "depositCollateral(uint256,uint256)": { + "notice": "Deposit collateral tokens into a loan." + }, + "getCollateralTokens(address)": { + "notice": "get list of collateral tokens that is allowed to be used on an {asset} loan" + }, + "getLoanCollateral(uint256)": { + "notice": "get the total collateral tokens in a respective loan" + }, + "withdrawCollateral(uint256,uint256)": { + "notice": "it withdraws collateral tokens from a loan" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/CreateLoanFacet.json b/deployments/polygon_mumbai/CreateLoanFacet.json new file mode 100644 index 000000000..214b81b51 --- /dev/null +++ b/deployments/polygon_mumbai/CreateLoanFacet.json @@ -0,0 +1,362 @@ +{ + "address": "0xB53dD2fE8B837E7877dfb43c046D75D5648A9005", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanUserRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanConsensusResponse[]", + "name": "responses", + "type": "tuple[]" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanUserRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanConsensusResponse[]", + "name": "responses", + "type": "tuple[]" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "internalType": "uint16[]", + "name": "nftIDs", + "type": "uint16[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "CreateLoanFacet", + "transactionHash": "0xe080f284e11c5d6bde8dcd5471f2193fb1967be55f2dafae2d91c9b2472087bf", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0xB53dD2fE8B837E7877dfb43c046D75D5648A9005", + "transactionIndex": 0, + "gasUsed": "2642483", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000800100000000000000000100000000004000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000080000000000000000000200000000000000000000000000000000000000000000000000000000000004000000000000100000001000000000000000000000000000000100040000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0xcfaaef626fefde0f4c3d0fb6435af3f695e4b8b64f81d2d477765f788db1c529", + "transactionHash": "0xe080f284e11c5d6bde8dcd5471f2193fb1967be55f2dafae2d91c9b2472087bf", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692471, + "transactionHash": "0xe080f284e11c5d6bde8dcd5471f2193fb1967be55f2dafae2d91c9b2472087bf", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000be188d6641e8b680743a4815dfa0f6208038960f" + ], + "data": "0x0000000000000000000000000000000000000000000000000119a3ba883344000000000000000000000000000000000000000000000000003d62dafe5a22640000000000000000000000000000000000000000000000007e5b44aec3734189500000000000000000000000000000000000000000000000003c493743d1ef200000000000000000000000000000000000000000000000007e5c5e527dfb74cd50", + "logIndex": 0, + "blockHash": "0xcfaaef626fefde0f4c3d0fb6435af3f695e4b8b64f81d2d477765f788db1c529" + } + ], + "blockNumber": 15692471, + "cumulativeGasUsed": "2642483", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountBorrowed\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"withNFT\",\"type\":\"bool\"}],\"name\":\"LoanTakenOut\",\"type\":\"event\"},{\"inputs\":[{\"components\":[{\"components\":[{\"internalType\":\"address payable\",\"name\":\"borrower\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"assetAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint32\",\"name\":\"requestNonce\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"duration\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"requestTime\",\"type\":\"uint32\"}],\"internalType\":\"struct LoanUserRequest\",\"name\":\"request\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"assetAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"maxLoanAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint32\",\"name\":\"responseTime\",\"type\":\"uint32\"},{\"internalType\":\"uint16\",\"name\":\"interestRate\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"collateralRatio\",\"type\":\"uint16\"},{\"components\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"internalType\":\"struct Signature\",\"name\":\"signature\",\"type\":\"tuple\"}],\"internalType\":\"struct LoanConsensusResponse[]\",\"name\":\"responses\",\"type\":\"tuple[]\"}],\"internalType\":\"struct LoanRequest\",\"name\":\"request\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"collateralToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"collateralAmount\",\"type\":\"uint256\"}],\"name\":\"takeOutLoan\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"components\":[{\"internalType\":\"address payable\",\"name\":\"borrower\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"assetAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint32\",\"name\":\"requestNonce\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"duration\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"requestTime\",\"type\":\"uint32\"}],\"internalType\":\"struct LoanUserRequest\",\"name\":\"request\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"assetAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"maxLoanAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint32\",\"name\":\"responseTime\",\"type\":\"uint32\"},{\"internalType\":\"uint16\",\"name\":\"interestRate\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"collateralRatio\",\"type\":\"uint16\"},{\"components\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"internalType\":\"struct Signature\",\"name\":\"signature\",\"type\":\"tuple\"}],\"internalType\":\"struct LoanConsensusResponse[]\",\"name\":\"responses\",\"type\":\"tuple[]\"}],\"internalType\":\"struct LoanRequest\",\"name\":\"request\",\"type\":\"tuple\"},{\"internalType\":\"uint16[]\",\"name\":\"nftIDs\",\"type\":\"uint16[]\"}],\"name\":\"takeOutLoanWithNFTs\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"LoanTakenOut(uint256,address,uint256,bool)\":{\"params\":{\"amountBorrowed\":\"Total amount taken out in the loan\",\"borrower\":\"Account address of the borrower\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"withNFT\":\"Boolean indicating if the loan was taken out using NFTs\"}}},\"kind\":\"dev\",\"methods\":{\"takeOutLoan(((address,address,uint256,uint32,uint32,uint32),(address,address,uint256,uint32,uint16,uint16,(uint8,bytes32,bytes32))[]),address,uint256)\":{\"details\":\"collateral ratio is a percentage of the loan amount that's required in collateralthe percentage will be *(10**2). I.e. collateralRatio of 5244 means 52.44% collateralis required in the loan. Interest rate is also a percentage with 2 decimal points.\",\"params\":{\"collateralAmount\":\"Amount of collateral required for the loan\",\"collateralToken\":\"Token address to use as collateral for the new loan\",\"request\":\"Struct of the protocol loan request\"}},\"takeOutLoanWithNFTs(((address,address,uint256,uint32,uint32,uint32),(address,address,uint256,uint32,uint16,uint16,(uint8,bytes32,bytes32))[]),uint16[])\":{\"params\":{\"nftIDs\":\"IDs of TellerNFTs to use for the loan\",\"request\":\"Struct of the protocol loan request\"}}},\"version\":1},\"userdoc\":{\"events\":{\"LoanTakenOut(uint256,address,uint256,bool)\":{\"notice\":\"This event is emitted when a loan has been successfully taken out\"}},\"kind\":\"user\",\"methods\":{\"takeOutLoan(((address,address,uint256,uint32,uint32,uint32),(address,address,uint256,uint32,uint16,uint16,(uint8,bytes32,bytes32))[]),address,uint256)\":{\"notice\":\"Take out a loan\"},\"takeOutLoanWithNFTs(((address,address,uint256,uint32,uint32,uint32),(address,address,uint256,uint32,uint16,uint16,(uint8,bytes32,bytes32))[]),uint16[])\":{\"notice\":\"Creates a loan with the loan request and NFTs without any collateral\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/market/CreateLoanFacet.sol\":\"CreateLoanFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../beacon/IBeacon.sol\\\";\\nimport \\\"../../utils/Address.sol\\\";\\nimport \\\"../../utils/StorageSlot.sol\\\";\\n\\n/**\\n * @dev This abstract contract provides getters and event emitting update functions for\\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\\n *\\n * _Available since v4.1._\\n *\\n * @custom:oz-upgrades-unsafe-allow delegatecall\\n */\\nabstract contract ERC1967Upgrade {\\n // This is the keccak-256 hash of \\\"eip1967.proxy.rollback\\\" subtracted by 1\\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\\n\\n /**\\n * @dev Storage slot with the address of the current implementation.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.implementation\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n /**\\n * @dev Emitted when the implementation is upgraded.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function _getImplementation() internal view returns (address) {\\n return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 implementation slot.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(Address.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n }\\n\\n /**\\n * @dev Perform implementation upgrade\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeTo(address newImplementation) internal {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Perform implementation upgrade with additional setup call.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n if (data.length > 0 || forceCall) {\\n Address.functionDelegateCall(newImplementation, data);\\n }\\n }\\n\\n /**\\n * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeToAndCallSecure(address newImplementation, bytes memory data, bool forceCall) internal {\\n address oldImplementation = _getImplementation();\\n\\n // Initial upgrade and setup call\\n _setImplementation(newImplementation);\\n if (data.length > 0 || forceCall) {\\n Address.functionDelegateCall(newImplementation, data);\\n }\\n\\n // Perform rollback test if not already in progress\\n StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);\\n if (!rollbackTesting.value) {\\n // Trigger rollback using upgradeTo from the new implementation\\n rollbackTesting.value = true;\\n Address.functionDelegateCall(\\n newImplementation,\\n abi.encodeWithSignature(\\n \\\"upgradeTo(address)\\\",\\n oldImplementation\\n )\\n );\\n rollbackTesting.value = false;\\n // Check rollback was effective\\n require(oldImplementation == _getImplementation(), \\\"ERC1967Upgrade: upgrade breaks further upgrades\\\");\\n // Finally reset to the new implementation and log the upgrade\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n }\\n\\n /**\\n * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\\n * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\\n *\\n * Emits a {BeaconUpgraded} event.\\n */\\n function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {\\n _setBeacon(newBeacon);\\n emit BeaconUpgraded(newBeacon);\\n if (data.length > 0 || forceCall) {\\n Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\\n }\\n }\\n\\n /**\\n * @dev Storage slot with the admin of the contract.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.admin\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\\n\\n /**\\n * @dev Emitted when the admin account has changed.\\n */\\n event AdminChanged(address previousAdmin, address newAdmin);\\n\\n /**\\n * @dev Returns the current admin.\\n */\\n function _getAdmin() internal view returns (address) {\\n return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 admin slot.\\n */\\n function _setAdmin(address newAdmin) private {\\n require(newAdmin != address(0), \\\"ERC1967: new admin is the zero address\\\");\\n StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\\n }\\n\\n /**\\n * @dev Changes the admin of the proxy.\\n *\\n * Emits an {AdminChanged} event.\\n */\\n function _changeAdmin(address newAdmin) internal {\\n emit AdminChanged(_getAdmin(), newAdmin);\\n _setAdmin(newAdmin);\\n }\\n\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Emitted when the beacon is upgraded.\\n */\\n event BeaconUpgraded(address indexed beacon);\\n\\n /**\\n * @dev Returns the current beacon.\\n */\\n function _getBeacon() internal view returns (address) {\\n return StorageSlot.getAddressSlot(_BEACON_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new beacon in the EIP1967 beacon slot.\\n */\\n function _setBeacon(address newBeacon) private {\\n require(\\n Address.isContract(newBeacon),\\n \\\"ERC1967: new beacon is not a contract\\\"\\n );\\n require(\\n Address.isContract(IBeacon(newBeacon).implementation()),\\n \\\"ERC1967: beacon implementation is not a contract\\\"\\n );\\n StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;\\n }\\n}\\n\",\"keccak256\":\"0x91a577fa9cbb3fda527eefa0e4ab327bbd9949bf5d358be286a33623ed69f76d\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IBeacon.sol\\\";\\nimport \\\"../Proxy.sol\\\";\\nimport \\\"../ERC1967/ERC1967Upgrade.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract BeaconProxy is Proxy, ERC1967Upgrade {\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n constructor(address beacon, bytes memory data) payable {\\n assert(_BEACON_SLOT == bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1));\\n _upgradeBeaconToAndCall(beacon, data, false);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address) {\\n return _getBeacon();\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation() internal view virtual override returns (address) {\\n return IBeacon(_getBeacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon. Deprecated: see {_upgradeBeaconToAndCall}.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n _upgradeBeaconToAndCall(beacon, data, false);\\n }\\n}\\n\",\"keccak256\":\"0x617614c3aaada8d7a901da2126a7407ae7e06b0410807f5c1b49cea9076199e9\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/StorageSlot.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for reading and writing primitive types to specific storage slots.\\n *\\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\\n * This library helps with reading and writing to such slots without the need for inline assembly.\\n *\\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\\n *\\n * Example usage to set ERC1967 implementation slot:\\n * ```\\n * contract ERC1967 {\\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n *\\n * function _getImplementation() internal view returns (address) {\\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n * }\\n *\\n * function _setImplementation(address newImplementation) internal {\\n * require(Address.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n * }\\n * }\\n * ```\\n *\\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\\n */\\nlibrary StorageSlot {\\n struct AddressSlot {\\n address value;\\n }\\n\\n struct BooleanSlot {\\n bool value;\\n }\\n\\n struct Bytes32Slot {\\n bytes32 value;\\n }\\n\\n struct Uint256Slot {\\n uint256 value;\\n }\\n\\n /**\\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\\n */\\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\\n */\\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\\n */\\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\\n */\\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\\n assembly {\\n r.slot := slot\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5d15d280d1f868f59a8264dc73f7ea8c51f10d78aac864b2f2ad29412d187ff5\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\\n *\\n * These functions can be used to verify that a message was signed by the holder\\n * of the private keys of a given address.\\n */\\nlibrary ECDSA {\\n /**\\n * @dev Returns the address that signed a hashed message (`hash`) with\\n * `signature`. This address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it.\\n */\\n function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\\n // Divide the signature in r, s and v variables\\n bytes32 r;\\n bytes32 s;\\n uint8 v;\\n\\n // Check the signature length\\n // - case 65: r,s,v signature (standard)\\n // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._\\n if (signature.length == 65) {\\n // ecrecover takes the signature parameters, and the only way to get them\\n // currently is to use assembly.\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n r := mload(add(signature, 0x20))\\n s := mload(add(signature, 0x40))\\n v := byte(0, mload(add(signature, 0x60)))\\n }\\n } else if (signature.length == 64) {\\n // ecrecover takes the signature parameters, and the only way to get them\\n // currently is to use assembly.\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let vs := mload(add(signature, 0x40))\\n r := mload(add(signature, 0x20))\\n s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)\\n v := add(shr(255, vs), 27)\\n }\\n } else {\\n revert(\\\"ECDSA: invalid signature length\\\");\\n }\\n\\n return recover(hash, v, r, s);\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n */\\n function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {\\n // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\\n // the valid range for s in (281): 0 < s < secp256k1n \\u00f7 2 + 1, and for v in (282): v \\u2208 {27, 28}. Most\\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\\n //\\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\\n // these malleable signatures as well.\\n require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, \\\"ECDSA: invalid signature 's' value\\\");\\n require(v == 27 || v == 28, \\\"ECDSA: invalid signature 'v' value\\\");\\n\\n // If the signature is valid (and not malleable), return the signer address\\n address signer = ecrecover(hash, v, r, s);\\n require(signer != address(0), \\\"ECDSA: invalid signature\\\");\\n\\n return signer;\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Message, created from a `hash`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {\\n // 32 is the length in bytes of hash,\\n // enforced by the type signature above\\n return keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n32\\\", hash));\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Typed Data, created from a\\n * `domainSeparator` and a `structHash`. This produces hash corresponding\\n * to the one signed with the\\n * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\\n * JSON-RPC method as part of EIP-712.\\n *\\n * See {recover}.\\n */\\n function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(\\\"\\\\x19\\\\x01\\\", domainSeparator, structHash));\\n }\\n}\\n\",\"keccak256\":\"0x2b7a01bbc90040fd4a48bc143ac5a192da3b9bfc559ac08a78eaca40bf49e436\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Trees proofs.\\n *\\n * The proofs can be generated using the JavaScript library\\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\\n *\\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n bytes32 computedHash = leaf;\\n\\n for (uint256 i = 0; i < proof.length; i++) {\\n bytes32 proofElement = proof[i];\\n\\n if (computedHash <= proofElement) {\\n // Hash(current computed hash + current element of the proof)\\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\\n } else {\\n // Hash(current element of the proof + current computed hash)\\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\\n }\\n }\\n\\n // Check if the computed hash (root) is equal to the provided root\\n return computedHash == root;\\n }\\n}\\n\",\"keccak256\":\"0xeee34bfb413657b6cd6c8e1e15c2080ba5ebaac479578515922804346fb63f7c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/reentry/ReentryMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nabstract contract ReentryMods {\\n modifier nonReentry(bytes32 id) {\\n AccessControlStorage storage s = AccessControlStorageLib.store();\\n require(!s.entered[id], \\\"AccessControl: reentered\\\");\\n s.entered[id] = true;\\n _;\\n s.entered[id] = false;\\n }\\n}\\n\",\"keccak256\":\"0x033c1164af25ef7d35a38a60973bf379b1cc603596914ffd85dcbcf0acdb6970\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../../../shared/interfaces/IAToken.sol\\\";\\nimport {\\n IAaveLendingPool\\n} from \\\"../../../shared/interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../../../shared/interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xd05e3E715d945B59290df0ae8eF85c1BdB684744 // Polygon mainnet\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x4c18d46f924a3a24d596971d39857477b618dad13dee55decc271bdccf915ee5\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n /**\\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\\n * @param dappAddress address of the target contract address\\n * @param dappData encoded abi of the function in our contract we want to call\\n * @return the called data in bytes\\n */\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n /**\\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\\n * @param token address of the respective ERC20 token to approve for the spender\\n * @param spender address of the respective spender who is approved by the token contract\\n */\\n function setTokenAllowance(address token, address spender) external;\\n\\n /**\\n * @notice it allows user to claim their escrow tokens\\n * @dev only the owner (TellerDiamond) can make this call on behalf of the users\\n * @param token address of the respective token contract to claim tokens from\\n * @param to address where the tokens should be transferred to\\n * @param amount uint256 amount of tokens to be claimed\\n */\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xaf67fc4454ffaa4d2f7e46fe7101876e8ebdb1a5426c30f87b8e18cc573ac019\",\"license\":\"MIT\"},\"contracts/escrow/libraries/LibEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibDapps } from \\\"../dapps/libraries/LibDapps.sol\\\";\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibEscrow {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\\n e_ = s().loanEscrows[loanID];\\n }\\n\\n /**\\n * @notice It returns a list of tokens owned by a loan escrow\\n * @param loanID uint256 index used to return our token list\\n * @return t_ which is a list of tokens \\n */\\n function getEscrowTokens(uint256 loanID)\\n internal\\n view\\n returns (EnumerableSet.AddressSet storage t_)\\n {\\n t_ = s().escrowTokens[loanID];\\n }\\n\\n /**\\n * @notice It returns the balance of a respective token in a loan escrow\\n * @param loanID uint256 index used to point to our loan escrow\\n * @param token address of respective token to give us the balance of in our loan escrow\\n * @return uint256 balance of respective token returned in an escrow loan\\n */\\n function balanceOf(uint256 loanID, address token)\\n internal\\n view\\n returns (uint256)\\n {\\n return IERC20(token).balanceOf(address(e(loanID)));\\n }\\n\\n /**\\n * @notice Adds or removes tokens held by the Escrow contract\\n * @param loanID The loan ID to update the token list for\\n * @param tokenAddress The token address to be added or removed\\n */\\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\\n // Skip if is lending token\\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\\n\\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\\n if (balanceOf(loanID, tokenAddress) > 0) {\\n if (!contains) {\\n EnumerableSet.add(tokens, tokenAddress);\\n }\\n } else if (contains) {\\n EnumerableSet.remove(tokens, tokenAddress);\\n }\\n }\\n\\n /**\\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\\n * @param loanID The loan ID to calculate value for\\n * @return value_ Escrow total value denoted in the lending token.\\n */\\n function calculateTotalValue(uint256 loanID)\\n internal\\n view\\n returns (uint256 value_)\\n {\\n address lendingToken = LibLoans.loan(loanID).lendingToken;\\n value_ += balanceOf(loanID, lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\\n if (EnumerableSet.length(tokens) > 0) {\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n uint256 tokenBal =\\n balanceOf(loanID, EnumerableSet.at(tokens, i));\\n value_ += PriceAggLib.valueFor(\\n EnumerableSet.at(tokens, i),\\n lendingToken,\\n tokenBal\\n );\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x17a7c6b11d6f280948e320525d1e131b89c23f80216918aa070df437a851d915\",\"license\":\"MIT\"},\"contracts/lending/libraries/LendingLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\n\\n// Interfaces\\nimport { ITToken } from \\\"../ttoken/ITToken.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LendingLib {\\n bytes32 internal constant ID = keccak256(\\\"LENDING\\\");\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function tToken(address asset) internal view returns (ITToken tToken_) {\\n tToken_ = s().tTokens[asset];\\n }\\n}\",\"keccak256\":\"0xc396ed8e9815696bf409386b4d99ea04168659e0f895ce1e4bd7453749924e1c\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when a user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when a user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n * @return ERC20 token\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n * @return balance_ the balance of the account\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice It calculates the total supply of the underlying asset.\\n * @return totalSupply_ the total supply denoted in the underlying asset.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given market.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n \\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfill the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n * @return mintAmount_ the amount minted of the specified token\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n * @return address of the strategy contract\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n * @param state boolean value that resembles the platform's state\\n */\\n function restrict(bool state) external virtual;\\n\\n /**\\n * @notice it initializes the Teller Token\\n * @param admin address of the admin to the respective Teller Token\\n * @param underlying address of the ERC20 token\\n */\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xf30ac4ef491851477ff9a3dd04974ebe74b529c37a3ef4e05798c3f734ceeb3d\",\"license\":\"MIT\"},\"contracts/market/CreateLoanFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\nimport {\\n ReentryMods\\n} from \\\"../contexts2/access-control/reentry/ReentryMods.sol\\\";\\nimport { RolesMods } from \\\"../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { AUTHORIZED } from \\\"../shared/roles.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Libraries\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\nimport { LibCollateral } from \\\"./libraries/LibCollateral.sol\\\";\\nimport { LibConsensus } from \\\"./libraries/LibConsensus.sol\\\";\\nimport { LendingLib } from \\\"../lending/libraries/LendingLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport {\\n MaxDebtRatioLib\\n} from \\\"../settings/asset/libraries/MaxDebtRatioLib.sol\\\";\\nimport {\\n MaxLoanAmountLib\\n} from \\\"../settings/asset/libraries/MaxLoanAmountLib.sol\\\";\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport { NumbersLib } from \\\"../shared/libraries/NumbersLib.sol\\\";\\nimport { NFTLib } from \\\"../nft/libraries/NFTLib.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\n// Proxy\\nimport {\\n BeaconProxy\\n} from \\\"@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol\\\";\\nimport { Clones } from \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\n\\n// Storage\\nimport {\\n LoanRequest,\\n LoanStatus,\\n LoanTerms,\\n Loan,\\n MarketStorageLib\\n} from \\\"../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract CreateLoanFacet is RolesMods, ReentryMods, PausableMods {\\n /**\\n * @notice This event is emitted when a loan has been successfully taken out\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param borrower Account address of the borrower\\n * @param amountBorrowed Total amount taken out in the loan\\n * @param withNFT Boolean indicating if the loan was taken out using NFTs\\n */\\n event LoanTakenOut(\\n uint256 indexed loanID,\\n address indexed borrower,\\n uint256 amountBorrowed,\\n bool withNFT\\n );\\n\\n /**\\n * @notice Creates the loan from requests and validator responses then calling the main function.\\n * @param request Struct of the protocol loan request\\n */\\n modifier __createLoan(LoanRequest calldata request, bool withNFT) {\\n Loan storage loan = CreateLoanLib.createLoan(request, withNFT);\\n\\n _;\\n\\n loan.status = LoanStatus.Active;\\n loan.loanStartTime = uint32(block.timestamp);\\n loan.duration = request.request.duration;\\n }\\n\\n /**\\n * @notice Creates a loan with the loan request and NFTs without any collateral\\n * @param request Struct of the protocol loan request\\n * @param nftIDs IDs of TellerNFTs to use for the loan\\n */\\n function takeOutLoanWithNFTs(\\n LoanRequest calldata request,\\n uint16[] calldata nftIDs\\n ) external paused(LibLoans.ID, false) __createLoan(request, true) {\\n // Get the ID of the newly created loan\\n uint256 loanID = CreateLoanLib.currentID() - 1;\\n uint256 amount = LibLoans.loan(loanID).borrowedAmount;\\n uint8 lendingDecimals = ERC20(request.request.assetAddress).decimals();\\n\\n uint256 allowedBaseLoanSize;\\n for (uint256 i; i < nftIDs.length; i++) {\\n NFTLib.applyToLoan(loanID, nftIDs[i]);\\n\\n allowedBaseLoanSize += NFTLib.s().nftDictionary.tokenBaseLoanSize(\\n nftIDs[i]\\n );\\n }\\n require(\\n amount <= allowedBaseLoanSize * (10**lendingDecimals),\\n \\\"Teller: insufficient NFT loan size\\\"\\n );\\n\\n // Pull funds from Teller Token LP and transfer to the new loan escrow\\n LendingLib.tToken(LibLoans.loan(loanID).lendingToken).fundLoan(\\n CreateLoanLib.createEscrow(loanID),\\n amount\\n );\\n\\n emit LoanTakenOut(\\n loanID,\\n msg.sender,\\n LibLoans.loan(loanID).borrowedAmount,\\n true\\n );\\n }\\n\\n /**\\n * @notice Take out a loan\\n *\\n * @dev collateral ratio is a percentage of the loan amount that's required in collateral\\n * @dev the percentage will be *(10**2). I.e. collateralRatio of 5244 means 52.44% collateral\\n * @dev is required in the loan. Interest rate is also a percentage with 2 decimal points.\\n *\\n * @param request Struct of the protocol loan request\\n * @param collateralToken Token address to use as collateral for the new loan\\n * @param collateralAmount Amount of collateral required for the loan\\n */\\n function takeOutLoan(\\n LoanRequest calldata request,\\n address collateralToken,\\n uint256 collateralAmount\\n )\\n external\\n payable\\n paused(LibLoans.ID, false)\\n nonReentry(\\\"\\\")\\n authorized(AUTHORIZED, msg.sender)\\n __createLoan(request, false)\\n {\\n // Check if collateral token is zero\\n require(\\n collateralToken != address(0x0),\\n \\\"Teller: token addr can't be 0\\\"\\n );\\n\\n // Verify collateral token is acceptable\\n require(\\n EnumerableSet.contains(\\n MarketStorageLib.store().collateralTokens[\\n request.request.assetAddress\\n ],\\n collateralToken\\n ),\\n \\\"Teller: collateral token not allowed\\\"\\n );\\n\\n // Get the ID of the newly created loan\\n Loan storage loan = LibLoans.loan(CreateLoanLib.currentID() - 1);\\n\\n // Save collateral token to loan\\n loan.collateralToken = collateralToken;\\n\\n // Pay in collateral\\n if (collateralAmount > 0) {\\n LibCollateral.deposit(loan.id, collateralAmount);\\n }\\n\\n // Check that enough collateral has been provided for this loan\\n require(\\n LibLoans.getCollateralNeeded(loan.id) <=\\n LibCollateral.e(loan.id).loanSupply(loan.id),\\n \\\"Teller: more collateral required\\\"\\n );\\n // Pull funds from Teller token LP and and transfer to the recipient\\n ITToken tToken = LendingLib.tToken(request.request.assetAddress);\\n\\n tToken.fundLoan(\\n LibLoans.canGoToEOAWithCollateralRatio(loan.collateralRatio)\\n ? loan.borrower\\n : CreateLoanLib.createEscrow(loan.id),\\n loan.borrowedAmount\\n );\\n\\n emit LoanTakenOut(loan.id, msg.sender, loan.borrowedAmount, false);\\n }\\n}\\n\\nlibrary CreateLoanLib {\\n function createLoan(LoanRequest calldata request, bool withNFT)\\n internal\\n returns (Loan storage loan)\\n {\\n // Perform loan request checks\\n require(\\n msg.sender == request.request.borrower,\\n \\\"Teller: not loan requester\\\"\\n );\\n require(\\n PlatformSettingsLib.getMaximumLoanDurationValue() >=\\n request.request.duration,\\n \\\"Teller: max loan duration exceeded\\\"\\n );\\n\\n // Get consensus values from request\\n (uint16 interestRate, uint16 collateralRatio, uint256 maxLoanAmount) =\\n LibConsensus.processLoanTerms(request);\\n\\n // Perform loan value checks\\n require(\\n MaxLoanAmountLib.get(request.request.assetAddress) > maxLoanAmount,\\n \\\"Teller: asset max loan amount exceeded\\\"\\n );\\n require(\\n LendingLib.tToken(request.request.assetAddress).debtRatioFor(\\n maxLoanAmount\\n ) <= MaxDebtRatioLib.get(request.request.assetAddress),\\n \\\"Teller: max supply-to-debt ratio exceeded\\\"\\n );\\n\\n // Get and increment new loan ID\\n uint256 loanID = CreateLoanLib.newID();\\n // Set loan data based on terms\\n loan = LibLoans.loan(loanID);\\n loan.id = uint128(loanID);\\n loan.status = LoanStatus.TermsSet;\\n loan.lendingToken = request.request.assetAddress;\\n loan.borrower = request.request.borrower;\\n loan.borrowedAmount = maxLoanAmount;\\n if (withNFT) {\\n loan.interestRate = PlatformSettingsLib.getNFTInterestRate();\\n } else {\\n loan.interestRate = interestRate;\\n loan.collateralRatio = collateralRatio;\\n }\\n\\n // Set loan debt\\n LibLoans.debt(loanID).principalOwed = maxLoanAmount;\\n LibLoans.debt(loanID).interestOwed = LibLoans.getInterestOwedFor(\\n uint256(loanID),\\n maxLoanAmount\\n );\\n\\n // Add loanID to borrower list\\n MarketStorageLib.store().borrowerLoans[loan.borrower].push(\\n uint128(loanID)\\n );\\n }\\n\\n /**\\n * @notice increments the loanIDCounter\\n * @return id_ the new ID requested, which stores it in the loan data\\n */\\n function newID() internal returns (uint256 id_) {\\n Counters.Counter storage counter =\\n MarketStorageLib.store().loanIDCounter;\\n id_ = Counters.current(counter);\\n Counters.increment(counter);\\n }\\n\\n function currentID() internal view returns (uint256 id_) {\\n Counters.Counter storage counter =\\n MarketStorageLib.store().loanIDCounter;\\n id_ = Counters.current(counter);\\n }\\n\\n /**\\n * @notice it creates a new loan escrow contract\\n * @param loanID the ID that identifies the loan\\n * @return escrow_ the loanEscrow that gets created\\n */\\n function createEscrow(uint256 loanID) internal returns (address escrow_) {\\n // Create escrow\\n escrow_ = AppStorageLib.store().loansEscrowBeacon.cloneProxy(\\\"\\\");\\n ILoansEscrow(escrow_).init();\\n // Save escrow address for loan\\n MarketStorageLib.store().loanEscrows[loanID] = ILoansEscrow(escrow_);\\n }\\n}\\n\",\"keccak256\":\"0xe405b44fc7a24140b25f02336a3e3750c4afb8da01f73a6e7e4ce7c5255e015d\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n /**\\n * @notice it initializes an escrow\\n * @param tokenAddress the address of the collateral token to be stored\\n * @param isWETH check if it's wrapped Ethereum\\n */\\n function init(address tokenAddress, bool isWETH) external;\\n\\n /**\\n * @notice it deposits an amount of the respective collateral token into the escrow\\n * @param loanID the ID of the loan\\n * @param amount the amount of collateral tokens to be deposited\\n */\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n /**\\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\\n * @dev only the TellerDiamond can make this call on behalf of the borrower\\n * @param loanID identifier of the loan\\n * @param amount number of collateral tokens to send\\n * @param receiver payable address to transfer money to\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n /**\\n * @notice it returns the supply of the respective loan\\n * @param loanID the respective loan ID\\n * @return supply_ the amount in collateral of the respective loan\\n */\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n /**\\n * @notice it returns the total supply of the collateral token held by the contract\\n * @return supply_ the total amount of collateral\\n */\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x900fed2311f919ba1451a6583ddbf9f3bc8afa8f5189500fff51f0c049258ed3\",\"license\":\"MIT\"},\"contracts/market/libraries/LibCollateral.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport { ICollateralEscrow } from \\\"../collateral/ICollateralEscrow.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\nimport { MarketStorageLib } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibCollateral {\\n /**\\n * @notice This event is emitted when collateral has been deposited for the loan\\n * @param loanID ID of the loan for which collateral was deposited\\n * @param depositor Account that deposited funds\\n * @param amount Amount of collateral deposited\\n */\\n event CollateralDeposited(\\n uint256 indexed loanID,\\n address indexed depositor,\\n uint256 amount\\n );\\n\\n /**\\n * @notice This event is emitted when collateral has been withdrawn\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param receiver Account that received funds\\n * @param amount Value of collateral withdrawn\\n */\\n event CollateralWithdrawn(\\n uint256 indexed loanID,\\n address indexed receiver,\\n uint256 amount\\n );\\n\\n /**\\n * @notice it gets MarketStorage's collateral escrow using the loanID\\n * @param loanID the loanID to be used\\n * @return c_ which is the collateral escrow\\n */\\n function e(uint256 loanID) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[\\n MarketStorageLib.store().loans[loanID].collateralToken\\n ];\\n }\\n\\n function e(address token) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[token];\\n }\\n\\n /**\\n * @notice it deposits an amount of collateral into a collateral escrow's address of a respective loan\\n * @param loanID the respective loan ID\\n * @param amount the amount of collateral to deposit\\n */\\n function deposit(uint256 loanID, uint256 amount) internal {\\n e(loanID).deposit{ value: amount }(loanID, amount);\\n\\n emit CollateralDeposited(loanID, msg.sender, amount);\\n }\\n\\n /**\\n * @notice it withdraws an amount from the collateral escrow\\n * @param loanID the respective loanID to withdraw from\\n * @param amount the number of collateral tokens to withdraw\\n * @param receiver the address who receives the withdrawal\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) internal {\\n e(loanID).withdraw(loanID, amount, receiver);\\n\\n emit CollateralWithdrawn(loanID, receiver, amount);\\n }\\n\\n /**\\n * @notice it withdraws the entire supply in collateral of a respective loan to an address\\n * @param loanID the respective loan's ID\\n * @param receiver the address of the receiver to withdraw tokens from\\n */\\n function withdrawAll(uint256 loanID, address payable receiver) internal {\\n withdraw(loanID, e(loanID).loanSupply(loanID), receiver);\\n }\\n\\n /**\\n * @notice it initializes a new escrow collateral to hold collateral tokens\\n * @param token address of the collateral token it holds\\n */\\n function createEscrow(address token) internal {\\n // Check if collateral escrow exists\\n if (address(e(token)) == address(0)) {\\n // Create escrow\\n address escrow =\\n AppStorageLib.store().collateralEscrowBeacon.cloneProxy(\\\"\\\");\\n ICollateralEscrow(escrow).init(\\n token,\\n // Check if collateral token is the base network token\\n token == AppStorageLib.store().wrappedNativeToken\\n );\\n\\n // Set max allowance\\n IERC20(token).approve(escrow, type(uint256).max);\\n // Save escrow address for loan\\n MarketStorageLib.store().collateralEscrows[\\n token\\n ] = ICollateralEscrow(escrow);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x539fb96f6d41224bfe644fbd3def4d1c0bba3ffcd31e659ff6b4bd274c5a39da\",\"license\":\"MIT\"},\"contracts/market/libraries/LibConsensus.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n LoanRequest,\\n LoanUserRequest,\\n LoanConsensusResponse,\\n Signature\\n} from \\\"../../storage/market.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport { NumbersList } from \\\"../../shared/libraries/NumbersList.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { ECDSA } from \\\"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\\\";\\nimport { RolesLib } from \\\"../../contexts2/access-control/roles/RolesLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nlibrary LibConsensus {\\n using NumbersList for NumbersList.Values;\\n\\n /**\\n * @notice Represents loan terms based on consensus values\\n * @param interestRate The consensus value for the interest rate based on all the loan responses from the signers\\n * @param collateralRatio The consensus value for the ratio of collateral to loan amount required for the loan, based on all the loan responses from the signers\\n * @param maxLoanAmount The consensus value for the largest amount of tokens that can be taken out in the loan, based on all the loan responses from the signers\\n */\\n struct AccruedLoanTerms {\\n NumbersList.Values interestRate;\\n NumbersList.Values collateralRatio;\\n NumbersList.Values maxLoanAmount;\\n }\\n\\n function s() private pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n * @notice it processes a loan terms by doing multiple checks on the LoanRequest request and LoanResponse[] responses\\n * @param request LoanRequest is the borrower request object to take out a loan\\n * @return interestRate the borrower needs to pay back\\n * @return collateralRatio the ratio of collateral the borrower needs to put up for the loan with an underlying asset\\n * @return maxLoanAmount the borrower is entitled for\\n */\\n function processLoanTerms(LoanRequest calldata request)\\n internal\\n view\\n returns (\\n uint16 interestRate,\\n uint16 collateralRatio,\\n uint256 maxLoanAmount\\n )\\n {\\n // get the signers from the asset address\\n EnumerableSet.AddressSet storage signers =\\n s().signers[request.request.assetAddress];\\n\\n require(\\n uint256(\\n NumbersLib.ratioOf(\\n request.responses.length,\\n EnumerableSet.length(signers)\\n )\\n ) >= PlatformSettingsLib.getRequiredSubmissionsPercentageValue(),\\n \\\"Teller: insufficient signer responses\\\"\\n );\\n\\n _validateLoanRequest(\\n request.request.borrower,\\n request.request.requestNonce\\n );\\n\\n uint32 chainId = _getChainId();\\n bytes32 requestHash = _hashRequest(request.request, chainId);\\n\\n // create term submissions for every response ...\\n AccruedLoanTerms memory termSubmissions;\\n\\n for (uint256 i = 0; i < request.responses.length; i++) {\\n LoanConsensusResponse memory response = request.responses[i];\\n\\n // check if the signers contains the response's signer\\n require(\\n EnumerableSet.contains(signers, response.signer),\\n \\\"Teller: invalid signer\\\"\\n );\\n\\n // check if the request's asset address equates to the response's asset address\\n require(\\n response.assetAddress == request.request.assetAddress,\\n \\\"Teller: consensus address mismatch\\\"\\n );\\n\\n // check if consensus response has expired\\n require(\\n uint256(response.responseTime) >=\\n block.timestamp -\\n PlatformSettingsLib.getTermsExpiryTimeValue(),\\n \\\"Teller: consensus response expired\\\"\\n );\\n\\n // check if the signature of hashed response data matches\\n require(\\n _signatureValid(\\n response.signature,\\n _hashResponse(requestHash, response, chainId),\\n response.signer\\n ),\\n \\\"Teller: response signature invalid\\\"\\n );\\n\\n // TODO: use a local AddressArrayLib instead to save gas\\n for (uint8 j = 0; j < i; j++) {\\n require(\\n response.signer != request.responses[j].signer,\\n \\\"Teller: dup signer response\\\"\\n );\\n }\\n\\n termSubmissions.interestRate.addValue(response.interestRate);\\n termSubmissions.collateralRatio.addValue(response.collateralRatio);\\n termSubmissions.maxLoanAmount.addValue(response.maxLoanAmount);\\n }\\n\\n // get maximum tolerance value in order to receive the interestRate, collateralRatio and maxLoanAmount\\n uint16 tolerance =\\n uint16(PlatformSettingsLib.getMaximumToleranceValue());\\n interestRate = uint16(\\n _getConsensus(termSubmissions.interestRate, tolerance)\\n );\\n collateralRatio = uint16(\\n _getConsensus(termSubmissions.collateralRatio, tolerance)\\n );\\n maxLoanAmount = _getConsensus(termSubmissions.maxLoanAmount, tolerance);\\n }\\n\\n /**\\n * @dev Checks if the nonce provided in the request is equal to the borrower's number of loans.\\n * @dev Also verifies if the borrower has taken out a loan recently (rate limit).\\n * @param borrower the borrower's address.\\n * @param nonce the nonce included in the loan request.\\n */\\n function _validateLoanRequest(address borrower, uint256 nonce)\\n private\\n view\\n {\\n uint128[] storage borrowerLoans = s().borrowerLoans[borrower];\\n uint256 numberOfLoans = borrowerLoans.length;\\n\\n require(nonce == numberOfLoans, \\\"Teller: bad request nonce\\\");\\n\\n // In case it is the first time that borrower requests loan terms, we don't\\n // validate the rate limit.\\n if (numberOfLoans == 0) {\\n return;\\n }\\n\\n require(\\n uint256(\\n s().loans[uint256(borrowerLoans[numberOfLoans - 1])]\\n .loanStartTime\\n ) +\\n PlatformSettingsLib.getRequestLoanTermsRateLimitValue() <=\\n block.timestamp,\\n \\\"Teller: loan terms rate limit reached\\\"\\n );\\n }\\n\\n /**\\n * @notice Gets the current chain id using the opcode 'chainid()'.\\n * @return id_ The current chain id.\\n */\\n function _getChainId() private view returns (uint32 id_) {\\n // silence state mutability warning without generating bytecode.\\n // see https://github.com/ethereum/solidity/issues/2691\\n assembly {\\n id_ := chainid()\\n }\\n }\\n\\n /**\\n * @notice Generates a hash for the loan request\\n * @param request Struct of the protocol loan request\\n * @return bytes32 Hash of the loan request\\n */\\n function _hashRequest(LoanUserRequest memory request, uint32 chainId)\\n private\\n pure\\n returns (bytes32)\\n {\\n return\\n keccak256(\\n abi.encode(\\n request.borrower,\\n request.assetAddress,\\n request.amount,\\n request.requestNonce,\\n request.duration,\\n request.requestTime,\\n chainId\\n )\\n );\\n }\\n\\n /**\\n * @notice Generates a hash for the loan response\\n * @param requestHash Hash of the loan request\\n * @param response Structs of the protocol loan responses\\n * @return bytes32 Hash of the loan response\\n */\\n function _hashResponse(\\n bytes32 requestHash,\\n LoanConsensusResponse memory response,\\n uint32 chainId\\n ) internal pure returns (bytes32) {\\n return\\n keccak256(\\n abi.encode(\\n response.assetAddress,\\n response.maxLoanAmount,\\n requestHash,\\n response.responseTime,\\n response.interestRate,\\n response.collateralRatio,\\n chainId\\n )\\n );\\n }\\n\\n /**\\n * @notice It validates whether a signature is valid or not.\\n * @param signature signature to validate.\\n * @param dataHash used to recover the signer.\\n * @param expectedSigner the expected signer address.\\n * @return true if the expected signer is equal to the signer. Otherwise it returns false.\\n */\\n function _signatureValid(\\n Signature memory signature,\\n bytes32 dataHash,\\n address expectedSigner\\n ) internal pure returns (bool) {\\n return\\n expectedSigner ==\\n ECDSA.recover(\\n keccak256(\\n abi.encodePacked(\\n \\\"\\\\x19Ethereum Signed Message:\\\\n32\\\",\\n dataHash\\n )\\n ),\\n signature.v,\\n signature.r,\\n signature.s\\n );\\n }\\n\\n /**\\n * @notice Gets the consensus value for a list of values (uint values).\\n * @notice The values must be in a maximum tolerance range.\\n * @return the consensus value.\\n */\\n function _getConsensus(NumbersList.Values memory values, uint16 tolerance)\\n internal\\n pure\\n returns (uint256)\\n {\\n require(\\n values.isWithinTolerance(tolerance),\\n \\\"Teller: consensus response values too varied\\\"\\n );\\n\\n return values.getAverage();\\n }\\n}\\n\",\"keccak256\":\"0x554c7c483f579c00c5a4609677e3230a31cf68b04c244935ca60a6da1173e2f6\",\"license\":\"MIT\"},\"contracts/market/libraries/LibLoans.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibEscrow } from \\\"../../escrow/libraries/LibEscrow.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus,\\n LoanDebt,\\n LoanTerms\\n} from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibLoans {\\n using NumbersLib for int256;\\n using NumbersLib for uint256;\\n\\n bytes32 internal constant ID = keccak256(\\\"LOANS\\\");\\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n * @notice it returns the loan\\n * @param loanID the ID of the respective loan\\n * @return l_ the loan\\n */\\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\\n l_ = s().loans[loanID];\\n }\\n\\n /**\\n * @notice it returns the loan debt from a respective loan\\n * @param loanID the ID of the respective loan\\n * @return d_ the loan debt from a respective loan\\n */\\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\\n d_ = s().loanDebt[loanID];\\n }\\n\\n // DEPRECATED\\n function terms(uint256 loanID)\\n internal\\n view\\n returns (LoanTerms storage t_)\\n {\\n t_ = s()._loanTerms[loanID];\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return owed_ uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID)\\n internal\\n view\\n returns (uint256 owed_)\\n {\\n if (loan(loanID).status == LoanStatus.Active) {\\n owed_ = debt(loanID).principalOwed + (debt(loanID).interestOwed);\\n }\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n internal\\n view\\n returns (uint256)\\n {\\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\\n }\\n\\n function getCollateralNeeded(uint256 loanID)\\n internal\\n view\\n returns (uint256 _needed)\\n {\\n (, _needed, ) = getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the total collateral needed in lending tokens, in collateral tokens and in escrowed loan values\\n * @param loanID the loanID to get the total collateral needed\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n internal\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\\n loanID\\n );\\n\\n // check if needed lending tokens is zero. if true, then needed collateral tokens is zero. else,\\n if (neededInLendingTokens == 0) {\\n neededInCollateralTokens = 0;\\n } else {\\n neededInCollateralTokens = PriceAggLib.valueFor(\\n loan(loanID).lendingToken,\\n loan(loanID).collateralToken,\\n neededInLendingTokens\\n );\\n }\\n }\\n\\n /**\\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\\n * @param loanID The loan ID to get needed collateral info for.\\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\\n */\\n function getCollateralNeededInTokens(uint256 loanID)\\n internal\\n view\\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\\n {\\n if (loan(loanID).collateralRatio == 0) {\\n return (0, 0);\\n }\\n\\n /*\\n The collateral to principal owed ratio is the sum of:\\n * collateral buffer percent\\n * loan interest rate\\n * liquidation reward percent\\n * X factor of additional collateral\\n */\\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n neededInLendingTokens = loan(loanID).borrowedAmount.percent(\\n loan(loanID).collateralRatio\\n );\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n uint16 requiredRatio =\\n loan(loanID).collateralRatio -\\n getInterestRatio(loanID) -\\n uint16(PlatformSettingsLib.getCollateralBufferValue());\\n\\n neededInLendingTokens =\\n debt(loanID).principalOwed +\\n debt(loanID).interestOwed;\\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\\n if (\\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\\n ) {\\n neededInLendingTokens -= escrowLoanValue;\\n }\\n neededInLendingTokens = neededInLendingTokens.percent(\\n requiredRatio\\n );\\n }\\n }\\n\\n /**\\n * @notice check if a loan can go to end of auction with a collateral ratio\\n * @return bool checking if collateralRatio is >= the over collateralized buffer value\\n */\\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\\n internal\\n view\\n returns (bool)\\n {\\n return\\n collateralRatio >=\\n PlatformSettingsLib.getOverCollateralizedBufferValue();\\n }\\n\\n /**\\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\\n * @notice There is a minimum threshold of 1%.\\n * @dev The interest rate is APY (annual percentage yield).\\n * @param loanID The loan ID to get the interest rate for.\\n */\\n function getInterestRatio(uint256 loanID)\\n internal\\n view\\n returns (uint16 ratio_)\\n {\\n ratio_ = uint16(\\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\\n SECONDS_PER_YEAR\\n );\\n\\n if (ratio_ == 0) {\\n ratio_ = 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0xaabb82718f6948669e5c984d7bdc0d0ae4806e3b17beba4dd60e771d67444c07\",\"license\":\"MIT\"},\"contracts/nft/IStakeableNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IStakeableNFT {\\n function tokenBaseLoanSize(uint256 tokenId) external view returns (uint256);\\n\\n function tokenURIHash(uint256 tokenId)\\n external\\n view\\n returns (string memory);\\n\\n function tokenContributionAsset(uint256 tokenId)\\n external\\n view\\n returns (address);\\n\\n function tokenContributionSize(uint256 tokenId)\\n external\\n view\\n returns (uint256);\\n\\n function tokenContributionMultiplier(uint256 tokenId)\\n external\\n view\\n returns (uint8);\\n}\\n\",\"keccak256\":\"0xfbf44350ad91a54de26f39195d714580d7dade556ea4c7991a51eef5aa839105\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x417b75f5d92be67993efc54db7d453be5b5058a9a54d8916380e0281d3299526\",\"license\":\"MIT\"},\"contracts/nft/TellerNFTDictionary.sol\":{\"content\":\"/**\\n * @notice TellerNFTDictionary Version 1.02\\n *\\n * @notice This contract is used to gather data for TellerV1 NFTs more efficiently.\\n * @notice This contract has data which must be continuously synchronized with the TellerV1 NFT data\\n *\\n * @author develop@teller.finance\\n */\\n\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Interfaces\\nimport \\\"./IStakeableNFT.sol\\\";\\n\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFTDictionary is IStakeableNFT, AccessControlUpgradeable {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n mapping(uint256 => uint256) public baseLoanSizes;\\n mapping(uint256 => string[]) public hashes;\\n mapping(uint256 => address) public contributionAssets;\\n mapping(uint256 => uint256) public contributionSizes;\\n mapping(uint256 => uint8) public contributionMultipliers;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n\\n /* State Variables */\\n\\n mapping(uint256 => uint256) public _tokenTierMappingCompressed;\\n bool public _tokenTierMappingCompressedSet;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFTDictionary: not admin\\\");\\n _;\\n }\\n\\n function initialize(address initialAdmin) public {\\n _setupRole(ADMIN, initialAdmin);\\n _setRoleAdmin(ADMIN, ADMIN);\\n\\n __AccessControl_init();\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTierIndex(uint256 tokenId)\\n public\\n view\\n returns (uint8 index_)\\n {\\n //32 * 8 = 256 - each uint256 holds the data of 32 tokens . 8 bits each.\\n\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 compressedRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n //use 31 instead of 32 to account for the '0x' in the start.\\n //the '31 -' reverses our bytes order which is necessary\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint8 tierIndex = uint8((compressedRegister >> offset));\\n\\n return tierIndex;\\n }\\n\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory)\\n {\\n return hashes[tierIndex];\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTier(uint256 index, Tier memory newTier)\\n external\\n onlyAdmin\\n returns (bool)\\n {\\n baseLoanSizes[index] = newTier.baseLoanSize;\\n hashes[index] = newTier.hashes;\\n contributionAssets[index] = newTier.contributionAsset;\\n contributionSizes[index] = newTier.contributionSize;\\n contributionMultipliers[index] = newTier.contributionMultiplier;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param tiersMapping Information about the new tiers to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setAllTokenTierMappings(uint256[] memory tiersMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n require(\\n !_tokenTierMappingCompressedSet,\\n \\\"TellerNFTDictionary: token tier mapping already set\\\"\\n );\\n for (uint256 i = 0; i < tiersMapping.length; i++) {\\n _tokenTierMappingCompressed[i] = tiersMapping[i];\\n }\\n\\n _tokenTierMappingCompressedSet = true;\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param index the mapping row, each holds data for 32 tokens\\n * @param tierMapping Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierMapping(uint256 index, uint256 tierMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n _tokenTierMappingCompressed[index] = tierMapping;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenIds the NFT token Ids for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenIds(\\n uint256[] calldata tokenIds,\\n uint256 tokenTier\\n ) public onlyAdmin returns (bool) {\\n for (uint256 i; i < tokenIds.length; i++) {\\n setTokenTierForTokenId(tokenIds[i], tokenTier);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenId the NFT token Id for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenId(uint256 tokenId, uint256 tokenTier)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 existingRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint256 updateMaskShifted =\\n 0x00000000000000000000000000000000000000000000000000000000000000FF <<\\n offset;\\n\\n uint256 updateMaskShiftedNegated = ~updateMaskShifted;\\n\\n uint256 tokenTierShifted =\\n ((0x0000000000000000000000000000000000000000000000000000000000000000 |\\n tokenTier) << offset);\\n\\n uint256 existingRegisterClearedWithMask =\\n existingRegister & updateMaskShiftedNegated;\\n\\n uint256 updatedRegister =\\n existingRegisterClearedWithMask | tokenTierShifted;\\n\\n _tokenTierMappingCompressed[mappingIndex] = updatedRegister;\\n\\n return true;\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(IStakeableNFT).interfaceId ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n New methods for the dictionary\\n */\\n\\n /**\\n * @notice It returns Base Loan Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenBaseLoanSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return baseLoanSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Token URI Hash for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenURIHash(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n string[] memory tierImageHashes = hashes[tokenTier];\\n return tierImageHashes[tokenId % (tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice It returns Contribution Asset for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionAsset(uint256 tokenId)\\n public\\n view\\n override\\n returns (address)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionAssets[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Multiplier for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionMultiplier(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint8)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionMultipliers[tokenTier];\\n }\\n}\\n\",\"keccak256\":\"0xf33e3fa1f609fdd2abb3b5fb9c232269d13363a3e4fa5697ea96269e361e74fa\"},\"contracts/nft/libraries/NFTLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../TellerNFT.sol\\\";\\n\\n// Libraries\\nimport {\\n MerkleProof\\n} from \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\nimport { NFTStorageLib, NFTStorage } from \\\"../../storage/nft.sol\\\";\\n\\nlibrary NFTLib {\\n function s() internal pure returns (NFTStorage storage s_) {\\n s_ = NFTStorageLib.store();\\n }\\n\\n function nft() internal view returns (TellerNFT nft_) {\\n nft_ = AppStorageLib.store().nft;\\n }\\n\\n /**s\\n * @notice it transfers the NFT from the sender to the diamond to stake then adds the NFTID to the list of the owner's stakedNFTs\\n * @param nftID the ID of the NFT to stake\\n * @param owner the owner of the NFT who will stake the NFT\\n */\\n function stake(uint256 nftID, address owner) internal {\\n // Transfer to diamond\\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\\n // Add NFT ID to user set\\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\\n }\\n\\n /**\\n * @notice it unstakes the NFT by removing the NFT ID from the list of the user's staked NFTs\\n * @param nftID the ID of the NFT to remove from the list of the user's staked NFTs\\n * @return success_ the boolean value telling us if the user has unsuccessfully unstaked the NFT\\n */\\n function unstake(uint256 nftID) internal returns (bool success_) {\\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\\n }\\n\\n /**\\n * @notice it gets the list of staked NFTs from the owner\\n * @param nftOwner the owner of the staked NFTs to pull from\\n * @return staked_ the array of the staked NFTs owned by the user\\n */\\n function stakedNFTs(address nftOwner)\\n internal\\n view\\n returns (uint256[] memory staked_)\\n {\\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\\n staked_ = new uint256[](EnumerableSet.length(nfts));\\n for (uint256 i; i < staked_.length; i++) {\\n staked_[i] = EnumerableSet.at(nfts, i);\\n }\\n }\\n\\n /**\\n * @notice if the user fails to pay his loan, then we liquidate the all the NFTs associated with the loan\\n * @param loanID the identifier of the loan to liquidate the NFTs from\\n */\\n function liquidateNFT(uint256 loanID) internal {\\n // Check if NFTs are linked\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n NFTLib.nft().transferFrom(\\n address(this),\\n AppStorageLib.store().nftLiquidationController,\\n EnumerableSet.at(nfts, i)\\n );\\n }\\n }\\n\\n /**\\n * @notice it unstakes an NFT and verifies the proof in order to apply the proof to a loan\\n * @param loanID the identifier of the loan\\n * @param nftID the NFT ID to apply to the loan\\n */\\n function applyToLoan(uint256 loanID, uint256 nftID) internal {\\n // NFT must be currently staked\\n // Remove NFT from being staked - returns bool\\n require(unstake(nftID), \\\"Teller: borrower nft not staked\\\");\\n\\n // Apply NFT to loan\\n EnumerableSet.add(s().loanNFTs[loanID], nftID);\\n }\\n\\n /**\\n * @notice it finds the loan's NFTs and adds them back to the owner's list of staked NFTs\\n * @param loanID the identifier of the respective loan to add the NFTs back to the user's staked NFTs\\n * @param owner the owner to add the unstaked NFTs back to the staked pile\\n */\\n function restakeLinked(uint256 loanID, address owner) internal {\\n // Get linked NFT\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n // Restake the NFT\\n EnumerableSet.add(s().stakedNFTs[owner], EnumerableSet.at(nfts, i));\\n }\\n }\\n}\\n\",\"keccak256\":\"0xccbd35c6e8d0130b38f5025ee81c47d55e4fa48c8fcb8bec6f70c21061e0ce61\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param amount Amount of the source token to convert into the destination token.\\n * @param exchangeRate The calculated exchange rate between the tokens.\\n * @return uint256 Value of the source token amount given an exchange rate peg.\\n */\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n /**\\n * @notice it returns 10^{numberOfDecimals} for a token\\n * @param token the address to calculate the decimals for\\n * @return 10^number of decimals used to calculate the price and value of different token pairs\\n */\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @notice It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @notice it tries to calculate a price from Compound and Chainlink.\\n * @dev if no price is found on compound, then calculate it on chainlink\\n * @param src the token address to calculate the price for in dst\\n * @param dst the token address to retrieve the price of src\\n * @return price_ the price of src in dst\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n * @param src the address of the src token\\n * @param dst the address of the dst token\\n * @return the price of the src token in dst token\\n\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n * @param src the source token to calculate price for with chainlink\\n * @param dst the destination token to calculate price for with chainlink\\n * @param cRate the compound rate to multiply with the price of the dst token\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @notice Scales the {value} by the difference in decimal values.\\n * @param value the the value of the src in dst\\n * @param srcDecimals src token decimals\\n * @param dstDecimals dst token decimals\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @notice it tries to calculate the price of {src} in {dst}\\n * @param src address of source token\\n * @param dst address of destination token\\n * @return the price of src token in dst\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address wrappedNativeToken =\\n AppStorageLib.store().wrappedNativeToken;\\n if (dst != wrappedNativeToken) {\\n int256 price1 = _priceFor(src, wrappedNativeToken);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, wrappedNativeToken);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice it checks if a token is a cToken. If it is, then get the underlying address\\n * @param token address of the token\\n * @return isCToken boolean whether it's a cToken\\n * @return underlying the address of the cToken\\n */\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xcf6280e2d36fdedbca4c0b94e413832f4bb267202de235bfc1cf6fda26c780ec\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { PriceAggFacet } from \\\"./PriceAggFacet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\n/**\\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\\n */\\nlibrary PriceAggLib {\\n /**\\n * @notice It calculates the value of one token amount into another\\n * @param src the source token\\n * @param dst the destination token\\n * @param srcAmount the amount of source token\\n * @return value_ the returned value of src in dst\\n */\\n function valueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) internal view returns (uint256 value_) {\\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\\n }\\n\\n /**\\n * @notice It returns the price of the token pair as given from Compound.\\n * @dev if no compound price is calculated, then it checks Chainlink price Aggregator\\n * @param src the address of the source token\\n * @param dst the address of the desitnation token\\n * @return price_ gets the price of src in dst\\n */\\n function priceFor(address src, address dst)\\n internal\\n view\\n returns (int256 price_)\\n {\\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\\n }\\n}\\n\",\"keccak256\":\"0xff59eee567fa4a7f5cac432e31d918be92834f04614f49572d3984a5b030ac79\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/asset/libraries/MaxDebtRatioLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n CacheLib,\\n Cache,\\n CacheType\\n} from \\\"../../../shared/libraries/CacheLib.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library of inline functions for MaxDebtRatio asset setting.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary MaxDebtRatioLib {\\n bytes32 private constant NAME = keccak256(\\\"MaxDebtRatio\\\");\\n\\n function s(address asset) private view returns (Cache storage) {\\n return AppStorageLib.store().assetSettings[asset];\\n }\\n\\n function get(address asset) internal view returns (uint16) {\\n return uint16(s(asset).uints[NAME]);\\n }\\n\\n function set(address asset, uint16 newValue) internal {\\n s(asset).uints[NAME] = uint256(newValue);\\n }\\n}\\n\",\"keccak256\":\"0x66a869c2cf30a14cb54a6bfbd241aaaac58bced13f40da7c4b5cbc5edc363769\",\"license\":\"MIT\"},\"contracts/settings/asset/libraries/MaxLoanAmountLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n CacheLib,\\n Cache,\\n CacheType\\n} from \\\"../../../shared/libraries/CacheLib.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library of inline functions for MaxLoanAmount asset setting.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary MaxLoanAmountLib {\\n bytes32 private constant NAME = keccak256(\\\"MaxLoanAmount\\\");\\n\\n function s(address asset) private view returns (Cache storage) {\\n return AppStorageLib.store().assetSettings[asset];\\n }\\n\\n function get(address asset) internal view returns (uint256) {\\n return s(asset).uints[NAME];\\n }\\n\\n function set(address asset, uint256 newValue) internal {\\n s(asset).uints[NAME] = newValue;\\n }\\n}\\n\",\"keccak256\":\"0x5ccd9e2708630103508f6498a6ed200de70670a65a47a20f8b4bca8788111116\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\nabstract contract PausableMods {\\n /**\\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\\n * @param id id of the facet to check if is paused.\\n * @param state Boolean that the protocol AND facet should be in.\\n */\\n modifier paused(bytes32 id, bool state) {\\n require(\\n __isPaused(\\\"\\\") == state && __isPaused(id) == state,\\n __pausedMessage(state)\\n );\\n _;\\n }\\n\\n /**\\n * @dev Checks if the given id is paused.\\n * @param id Encoded id of the facet to check if is paused.\\n * @return the bool to tell us if the facet is paused (true) or not (false)\\n */\\n function __isPaused(bytes32 id) private view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n\\n /**\\n * @dev Gets the message that should be reverted with given a state it should be in.\\n * @param state Boolean that an id should be in.\\n * @return a message stating whether the facet is paused or not\\n */\\n function __pausedMessage(bool state) private pure returns (string memory) {\\n return state ? \\\"Pausable: not paused\\\" : \\\"Pausable: paused\\\";\\n }\\n}\\n\",\"keccak256\":\"0x2d3f848ee56ae5fa365539c2509c03c167affc89c89f98bb98cb9b83fbe8ae4c\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"NFTInterestRate\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getNFTInterestRate() internal view returns (uint16 value_) {\\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0x44294be1af9f913b2ed391a40cd4b646537a4b463b8d5ff1fac8ead3988966c1\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for loans taken out with an NFT.\\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\\n */\\nbytes32 constant NFT_INTEREST_RATE = keccak256(\\\"NFTInterestRate\\\");\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xd68a7df42b2bbba6f935d5890b7b37997c1432e25ae113827b8bde87f94fd86f\",\"license\":\"MIT\"},\"contracts/shared/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n /**\\n * @notice Checks if the account should be allowed to mint tokens in the given market\\n * @param cToken The market to verify the mint against\\n * @param minter The account which would get the minted tokens\\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates mint and reverts on rejection. May emit logs.\\n * @param cToken Asset being minted\\n * @param minter The address minting the tokens\\n * @param mintAmount The amount of the underlying asset being minted\\n * @param mintTokens The number of tokens being minted\\n */\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to redeem tokens in the given market\\n * @param cToken The market to verify the redeem against\\n * @param redeemer The account which would redeem the tokens\\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates redeem and reverts on rejection. May emit logs.\\n * @param cToken Asset being redeemed\\n * @param redeemer The address redeeming the tokens\\n * @param redeemAmount The amount of the underlying asset being redeemed\\n * @param redeemTokens The number of tokens being redeemed\\n */\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\\n * @param cToken The market to verify the borrow against\\n * @param borrower The account which would borrow the asset\\n * @param borrowAmount The amount of underlying the account would borrow\\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates borrow and reverts on rejection. May emit logs.\\n * @param cToken Asset whose underlying is being borrowed\\n * @param borrower The address borrowing the underlying\\n * @param borrowAmount The amount of the underlying asset requested to borrow\\n */\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to repay a borrow in the given market\\n * @param cToken The market to verify the repay against\\n * @param payer The account which would repay the asset\\n * @param borrower The account which would borrowed the asset\\n * @param repayAmount The amount of the underlying asset the account would repay\\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\\n * @param cToken Asset being repaid\\n * @param payer The address repaying the borrow\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param borrowerIndex the index of the borrower\\n */\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n /**\\n * @notice Checks if the liquidation should be allowed to occur\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n */\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the seizing of assets should be allowed to occur\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates seize and reverts on rejection. May emit logs.\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to transfer tokens in the given market\\n * @param cToken The market to verify the transfer against\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates transfer and reverts on rejection. May emit logs.\\n * @param cToken Asset being transferred\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n */\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in all markets\\n * @param holder The address to claim COMP for\\n */\\n function claimComp(address holder) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in the specified markets\\n * @param holder The address to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n */\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n /**\\n * @notice Claim all comp accrued by the holders\\n * @param holders The addresses to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n * @param borrowers Whether or not to claim COMP earned by borrowing\\n * @param suppliers Whether or not to claim COMP earned by supplying\\n */\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n /**\\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\\n * @param cTokenBorrowed The address of the borrowed cToken\\n * @param cTokenCollateral The address of the collateral cToken\\n * @param repayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\\n */\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n /**\\n * @notice Return the address of the COMP token\\n * @return The address of COMP\\n */\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x38a824a4a21ce9370fa581a616d1bb9d311f27d8982a6b96ebeba90bd5fd0adb\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n\\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x208769886b3db8f03ef1fa26f1caee189038dfc744b9a499402fc4e4c0090c38\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @dev CETH is the only Compound token that does not support the {underlying} function.\\n * @param cToken address of the compound token\\n * @return address of the underlying cToken\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x99206384c27b0e68b1ec7b82260f6a47965f611875c018bc076ff8a688a6c6d7\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n /**\\n * @notice it returns the absolute number of a specified parameter\\n * @param self the number to be returned in it's absolute\\n * @return the absolute number\\n */\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0x4f750cde25d4b1db919abf3192d58ed6aef617d03637e1e9e2dc31b70dcc32a3\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n address wrappedNativeToken;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4504c5c460972a25cd1f0e6eb1d8dd84a668be75a3aeb89a47a49c2327c12923\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\n// DEPRECATED\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\nstruct LoanRequest {\\n LoanUserRequest request;\\n LoanConsensusResponse[] responses;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanUserRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanConsensusResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) _loanTerms; // DEPRECATED: DO NOT REMOVE\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb7e05aeec806b5621512def93f4a389b4ef88c50ef9fe7115a33f57db2f2304b\",\"license\":\"MIT\"},\"contracts/storage/nft.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"../nft/TellerNFTDictionary.sol\\\";\\n\\n// Utils\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct NFTStorage {\\n // Maps NFT owner to set of token IDs owned\\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\\n // Maps loanID to NFT IDs indicating NFT being used for the loan\\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\\n // Merkle root used for verifying nft IDs to base loan size\\n TellerNFTDictionary nftDictionary;\\n}\\n\\nbytes32 constant NFT_STORAGE_POS = keccak256(\\\"teller.staking.storage\\\");\\n\\nlibrary NFTStorageLib {\\n function store() internal pure returns (NFTStorage storage s) {\\n bytes32 pos = NFT_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd44f213be3125ea2e2de120c241832f1861be18b3ff2fd4c3baa52ea20b94812\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "events": { + "LoanTakenOut(uint256,address,uint256,bool)": { + "params": { + "amountBorrowed": "Total amount taken out in the loan", + "borrower": "Account address of the borrower", + "loanID": "ID of loan from which collateral was withdrawn", + "withNFT": "Boolean indicating if the loan was taken out using NFTs" + } + } + }, + "kind": "dev", + "methods": { + "takeOutLoan(((address,address,uint256,uint32,uint32,uint32),(address,address,uint256,uint32,uint16,uint16,(uint8,bytes32,bytes32))[]),address,uint256)": { + "details": "collateral ratio is a percentage of the loan amount that's required in collateralthe percentage will be *(10**2). I.e. collateralRatio of 5244 means 52.44% collateralis required in the loan. Interest rate is also a percentage with 2 decimal points.", + "params": { + "collateralAmount": "Amount of collateral required for the loan", + "collateralToken": "Token address to use as collateral for the new loan", + "request": "Struct of the protocol loan request" + } + }, + "takeOutLoanWithNFTs(((address,address,uint256,uint32,uint32,uint32),(address,address,uint256,uint32,uint16,uint16,(uint8,bytes32,bytes32))[]),uint16[])": { + "params": { + "nftIDs": "IDs of TellerNFTs to use for the loan", + "request": "Struct of the protocol loan request" + } + } + }, + "version": 1 + }, + "userdoc": { + "events": { + "LoanTakenOut(uint256,address,uint256,bool)": { + "notice": "This event is emitted when a loan has been successfully taken out" + } + }, + "kind": "user", + "methods": { + "takeOutLoan(((address,address,uint256,uint32,uint32,uint32),(address,address,uint256,uint32,uint16,uint16,(uint8,bytes32,bytes32))[]),address,uint256)": { + "notice": "Take out a loan" + }, + "takeOutLoanWithNFTs(((address,address,uint256,uint32,uint32,uint32),(address,address,uint256,uint32,uint16,uint16,(uint8,bytes32,bytes32))[]),uint16[])": { + "notice": "Creates a loan with the loan request and NFTs without any collateral" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/DefaultProxyAdmin.json b/deployments/polygon_mumbai/DefaultProxyAdmin.json new file mode 100644 index 000000000..d5ea4924c --- /dev/null +++ b/deployments/polygon_mumbai/DefaultProxyAdmin.json @@ -0,0 +1,272 @@ +{ + "address": "0x40d6Cab1722fF9A0C5bBf5Fb00141C427039fE4a", + "abi": [ + { + "inputs": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "contract TransparentUpgradeableProxy", + "name": "proxy", + "type": "address" + }, + { + "internalType": "address", + "name": "newAdmin", + "type": "address" + } + ], + "name": "changeProxyAdmin", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract TransparentUpgradeableProxy", + "name": "proxy", + "type": "address" + } + ], + "name": "getProxyAdmin", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract TransparentUpgradeableProxy", + "name": "proxy", + "type": "address" + } + ], + "name": "getProxyImplementation", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "renounceOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract TransparentUpgradeableProxy", + "name": "proxy", + "type": "address" + }, + { + "internalType": "address", + "name": "implementation", + "type": "address" + } + ], + "name": "upgrade", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract TransparentUpgradeableProxy", + "name": "proxy", + "type": "address" + }, + { + "internalType": "address", + "name": "implementation", + "type": "address" + }, + { + "internalType": "bytes", + "name": "data", + "type": "bytes" + } + ], + "name": "upgradeAndCall", + "outputs": [], + "stateMutability": "payable", + "type": "function" + } + ], + "artifactName": "ProxyAdmin", + "transactionHash": "0x6aa463070802b81bb583dfb593a667b362474efd46a573051a93a799032c8069", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x40d6Cab1722fF9A0C5bBf5Fb00141C427039fE4a", + "transactionIndex": 0, + "gasUsed": "671461", + "logsBloom": "0x00000000000000000000000000008000000000000000000000800000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000800000000800101000000000000000100000000000000000000020000000000000000000800000000000000080080000000000000400000000000040000000000000000000000000000000000000000000000000000200000000000000000000000000000002000000000000000000000000000004000000000000100200001000000000000000000000000000000100000000020000000000000000000000000000000000000000000000008000000000000100000", + "blockHash": "0x3e06d600604a10e75e7d831059354313cc980ed24cacca273dc3fa488ad215c8", + "transactionHash": "0x6aa463070802b81bb583dfb593a667b362474efd46a573051a93a799032c8069", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692284, + "transactionHash": "0x6aa463070802b81bb583dfb593a667b362474efd46a573051a93a799032c8069", + "address": "0x40d6Cab1722fF9A0C5bBf5Fb00141C427039fE4a", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 0, + "blockHash": "0x3e06d600604a10e75e7d831059354313cc980ed24cacca273dc3fa488ad215c8" + }, + { + "transactionIndex": 0, + "blockNumber": 15692284, + "transactionHash": "0x6aa463070802b81bb583dfb593a667b362474efd46a573051a93a799032c8069", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b26c22237816d898cb9992d767444105bfdc03b6" + ], + "data": "0x000000000000000000000000000000000000000000000000004790b4e790dc0000000000000000000000000000000000000000000000000051a5e41efe898c00000000000000000000000000000000000000000000000005a41dc89325d1f730000000000000000000000000000000000000000000000000515e536a16f8b000000000000000000000000000000000000000000000000005a46559480d62d330", + "logIndex": 1, + "blockHash": "0x3e06d600604a10e75e7d831059354313cc980ed24cacca273dc3fa488ad215c8" + } + ], + "blockNumber": 15692284, + "cumulativeGasUsed": "671461", + "status": 1, + "byzantium": true + }, + "args": ["0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5"], + "solcInputHash": "1635d55d57a0a2552952c0d22586ed23", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"contract TransparentUpgradeableProxy\",\"name\":\"proxy\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"changeProxyAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract TransparentUpgradeableProxy\",\"name\":\"proxy\",\"type\":\"address\"}],\"name\":\"getProxyAdmin\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract TransparentUpgradeableProxy\",\"name\":\"proxy\",\"type\":\"address\"}],\"name\":\"getProxyImplementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract TransparentUpgradeableProxy\",\"name\":\"proxy\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"upgrade\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract TransparentUpgradeableProxy\",\"name\":\"proxy\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"This is an auxiliary contract meant to be assigned as the admin of a {TransparentUpgradeableProxy}. For an explanation of why you would want to use this see the documentation for {TransparentUpgradeableProxy}.\",\"kind\":\"dev\",\"methods\":{\"changeProxyAdmin(address,address)\":{\"details\":\"Changes the admin of `proxy` to `newAdmin`. Requirements: - This contract must be the current admin of `proxy`.\"},\"getProxyAdmin(address)\":{\"details\":\"Returns the current admin of `proxy`. Requirements: - This contract must be the admin of `proxy`.\"},\"getProxyImplementation(address)\":{\"details\":\"Returns the current implementation of `proxy`. Requirements: - This contract must be the admin of `proxy`.\"},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"},\"upgrade(address,address)\":{\"details\":\"Upgrades `proxy` to `implementation`. See {TransparentUpgradeableProxy-upgradeTo}. Requirements: - This contract must be the admin of `proxy`.\"},\"upgradeAndCall(address,address,bytes)\":{\"details\":\"Upgrades `proxy` to `implementation` and calls a function on the new implementation. See {TransparentUpgradeableProxy-upgradeToAndCall}. Requirements: - This contract must be the admin of `proxy`.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/openzeppelin/proxy/ProxyAdmin.sol\":\"ProxyAdmin\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/openzeppelin/GSN/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.7.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with GSN meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address payable) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes memory) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x910a2e625b71168563edf9eeef55a50d6d699acfe27ceba3921f291829a8f938\",\"license\":\"MIT\"},\"solc_0.7/openzeppelin/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.7.0;\\n\\nimport \\\"../GSN/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\ncontract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor (address initialOwner) {\\n _owner = initialOwner;\\n emit OwnershipTransferred(address(0), initialOwner);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(_owner == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x85eb3b8575f16937ed27e36fae8b617d9e3e7a7e49f04e10d52dad66d0fa9e75\",\"license\":\"MIT\"},\"solc_0.7/openzeppelin/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.7.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n * \\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n * \\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n * \\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal virtual view returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n * \\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () payable external {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () payable external {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n * \\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc33f9858a67e34c77831163d5611d21fc627dfd2c303806a98a6c9db5a01b034\",\"license\":\"MIT\"},\"solc_0.7/openzeppelin/proxy/ProxyAdmin.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.7.0;\\n\\nimport \\\"../access/Ownable.sol\\\";\\nimport \\\"./TransparentUpgradeableProxy.sol\\\";\\n\\n/**\\n * @dev This is an auxiliary contract meant to be assigned as the admin of a {TransparentUpgradeableProxy}. For an\\n * explanation of why you would want to use this see the documentation for {TransparentUpgradeableProxy}.\\n */\\ncontract ProxyAdmin is Ownable {\\n\\n constructor(address owner) Ownable(owner) {}\\n\\n /**\\n * @dev Returns the current implementation of `proxy`.\\n *\\n * Requirements:\\n *\\n * - This contract must be the admin of `proxy`.\\n */\\n function getProxyImplementation(TransparentUpgradeableProxy proxy) public view returns (address) {\\n // We need to manually run the static call since the getter cannot be flagged as view\\n // bytes4(keccak256(\\\"implementation()\\\")) == 0x5c60da1b\\n (bool success, bytes memory returndata) = address(proxy).staticcall(hex\\\"5c60da1b\\\");\\n require(success);\\n return abi.decode(returndata, (address));\\n }\\n\\n /**\\n * @dev Returns the current admin of `proxy`.\\n *\\n * Requirements:\\n *\\n * - This contract must be the admin of `proxy`.\\n */\\n function getProxyAdmin(TransparentUpgradeableProxy proxy) public view returns (address) {\\n // We need to manually run the static call since the getter cannot be flagged as view\\n // bytes4(keccak256(\\\"admin()\\\")) == 0xf851a440\\n (bool success, bytes memory returndata) = address(proxy).staticcall(hex\\\"f851a440\\\");\\n require(success);\\n return abi.decode(returndata, (address));\\n }\\n\\n /**\\n * @dev Changes the admin of `proxy` to `newAdmin`.\\n *\\n * Requirements:\\n *\\n * - This contract must be the current admin of `proxy`.\\n */\\n function changeProxyAdmin(TransparentUpgradeableProxy proxy, address newAdmin) public onlyOwner {\\n proxy.changeAdmin(newAdmin);\\n }\\n\\n /**\\n * @dev Upgrades `proxy` to `implementation`. See {TransparentUpgradeableProxy-upgradeTo}.\\n *\\n * Requirements:\\n *\\n * - This contract must be the admin of `proxy`.\\n */\\n function upgrade(TransparentUpgradeableProxy proxy, address implementation) public onlyOwner {\\n proxy.upgradeTo(implementation);\\n }\\n\\n /**\\n * @dev Upgrades `proxy` to `implementation` and calls a function on the new implementation. See\\n * {TransparentUpgradeableProxy-upgradeToAndCall}.\\n *\\n * Requirements:\\n *\\n * - This contract must be the admin of `proxy`.\\n */\\n function upgradeAndCall(TransparentUpgradeableProxy proxy, address implementation, bytes memory data) public payable onlyOwner {\\n proxy.upgradeToAndCall{value: msg.value}(implementation, data);\\n }\\n}\\n\",\"keccak256\":\"0xae77885dd899a14e94f172e4e9ec7ef4b2ced0472904626c59b46150a26b5714\",\"license\":\"MIT\"},\"solc_0.7/openzeppelin/proxy/TransparentUpgradeableProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.7.0;\\n\\nimport \\\"./UpgradeableProxy.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that is upgradeable by an admin.\\n * \\n * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector\\n * clashing], which can potentially be used in an attack, this contract uses the\\n * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two\\n * things that go hand in hand:\\n * \\n * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if\\n * that call matches one of the admin functions exposed by the proxy itself.\\n * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the\\n * implementation. If the admin tries to call a function on the implementation it will fail with an error that says\\n * \\\"admin cannot fallback to proxy target\\\".\\n * \\n * These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing\\n * the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due\\n * to sudden errors when trying to call a function from the proxy implementation.\\n * \\n * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way,\\n * you should think of the `ProxyAdmin` instance as the real administrative inerface of your proxy.\\n */\\ncontract TransparentUpgradeableProxy is UpgradeableProxy {\\n /**\\n * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and\\n * optionally initialized with `_data` as explained in {UpgradeableProxy-constructor}.\\n */\\n constructor(address initialLogic, address initialAdmin, bytes memory _data) payable UpgradeableProxy(initialLogic, _data) {\\n assert(_ADMIN_SLOT == bytes32(uint256(keccak256(\\\"eip1967.proxy.admin\\\")) - 1));\\n _setAdmin(initialAdmin);\\n }\\n\\n /**\\n * @dev Emitted when the admin account has changed.\\n */\\n event AdminChanged(address previousAdmin, address newAdmin);\\n\\n /**\\n * @dev Storage slot with the admin of the contract.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.admin\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 private constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\\n\\n /**\\n * @dev Modifier used internally that will delegate the call to the implementation unless the sender is the admin.\\n */\\n modifier ifAdmin() {\\n if (msg.sender == _admin()) {\\n _;\\n } else {\\n _fallback();\\n }\\n }\\n\\n /**\\n * @dev Returns the current admin.\\n * \\n * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}.\\n * \\n * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the\\n * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\\n * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`\\n */\\n function admin() external ifAdmin returns (address) {\\n return _admin();\\n }\\n\\n /**\\n * @dev Returns the current implementation.\\n * \\n * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}.\\n * \\n * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the\\n * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\\n * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`\\n */\\n function implementation() external ifAdmin returns (address) {\\n return _implementation();\\n }\\n\\n /**\\n * @dev Changes the admin of the proxy.\\n * \\n * Emits an {AdminChanged} event.\\n * \\n * NOTE: Only the admin can call this function. See {ProxyAdmin-changeProxyAdmin}.\\n */\\n function changeAdmin(address newAdmin) external ifAdmin {\\n require(newAdmin != address(0), \\\"TransparentUpgradeableProxy: new admin is the zero address\\\");\\n emit AdminChanged(_admin(), newAdmin);\\n _setAdmin(newAdmin);\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy.\\n * \\n * NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}.\\n */\\n function upgradeTo(address newImplementation) external ifAdmin {\\n _upgradeTo(newImplementation);\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified\\n * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the\\n * proxied contract.\\n * \\n * NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}.\\n */\\n function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {\\n _upgradeTo(newImplementation);\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success,) = newImplementation.delegatecall(data);\\n require(success);\\n }\\n\\n /**\\n * @dev Returns the current admin.\\n */\\n function _admin() internal view returns (address adm) {\\n bytes32 slot = _ADMIN_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n adm := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 admin slot.\\n */\\n function _setAdmin(address newAdmin) private {\\n bytes32 slot = _ADMIN_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, newAdmin)\\n }\\n }\\n\\n /**\\n * @dev Makes sure the admin cannot access the fallback function. See {Proxy-_beforeFallback}.\\n */\\n function _beforeFallback() internal override virtual {\\n require(msg.sender != _admin(), \\\"TransparentUpgradeableProxy: admin cannot fallback to proxy target\\\");\\n super._beforeFallback();\\n }\\n}\\n\",\"keccak256\":\"0xd6cecbe00dc78355aff1a16d83487bb73c54701004d61a2e48cdb81e2bcacc26\",\"license\":\"MIT\"},\"solc_0.7/openzeppelin/proxy/UpgradeableProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.7.0;\\n\\nimport \\\"./Proxy.sol\\\";\\nimport \\\"../utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an\\n * implementation address that can be changed. This address is stored in storage in the location specified by\\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the\\n * implementation behind the proxy.\\n * \\n * Upgradeability is only provided internally through {_upgradeTo}. For an externally upgradeable proxy see\\n * {TransparentUpgradeableProxy}.\\n */\\ncontract UpgradeableProxy is Proxy {\\n /**\\n * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.\\n * \\n * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded\\n * function call, and allows initializating the storage of the proxy like a Solidity constructor.\\n */\\n constructor(address _logic, bytes memory _data) payable {\\n assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256(\\\"eip1967.proxy.implementation\\\")) - 1));\\n _setImplementation(_logic);\\n if(_data.length > 0) {\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success,) = _logic.delegatecall(_data);\\n require(success);\\n }\\n }\\n\\n /**\\n * @dev Emitted when the implementation is upgraded.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Storage slot with the address of the current implementation.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.implementation\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 private constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function _implementation() internal override view returns (address impl) {\\n bytes32 slot = _IMPLEMENTATION_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n impl := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Upgrades the proxy to a new implementation.\\n * \\n * Emits an {Upgraded} event.\\n */\\n function _upgradeTo(address newImplementation) internal {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 implementation slot.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(Address.isContract(newImplementation), \\\"UpgradeableProxy: new implementation is not a contract\\\");\\n\\n bytes32 slot = _IMPLEMENTATION_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, newImplementation)\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd68f4c11941712db79a61b9dca81a5db663cfacec3d7bb19f8d2c23bb1ab8afe\",\"license\":\"MIT\"},\"solc_0.7/openzeppelin/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.7.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // According to EIP-1052, 0x0 is the value returned for not-yet created accounts\\n // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned\\n // for accounts without code, i.e. `keccak256('')`\\n bytes32 codehash;\\n bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { codehash := extcodehash(account) }\\n return (codehash != accountHash && codehash != 0x0);\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return _functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n return _functionCallWithValue(target, data, value, errorMessage);\\n }\\n\\n function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x698f929f1097637d051976b322a2d532c27df022b09010e8d091e2888a5ebdf8\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "details": "This is an auxiliary contract meant to be assigned as the admin of a {TransparentUpgradeableProxy}. For an explanation of why you would want to use this see the documentation for {TransparentUpgradeableProxy}.", + "kind": "dev", + "methods": { + "changeProxyAdmin(address,address)": { + "details": "Changes the admin of `proxy` to `newAdmin`. Requirements: - This contract must be the current admin of `proxy`." + }, + "getProxyAdmin(address)": { + "details": "Returns the current admin of `proxy`. Requirements: - This contract must be the admin of `proxy`." + }, + "getProxyImplementation(address)": { + "details": "Returns the current implementation of `proxy`. Requirements: - This contract must be the admin of `proxy`." + }, + "owner()": { + "details": "Returns the address of the current owner." + }, + "renounceOwnership()": { + "details": "Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner." + }, + "transferOwnership(address)": { + "details": "Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner." + }, + "upgrade(address,address)": { + "details": "Upgrades `proxy` to `implementation`. See {TransparentUpgradeableProxy-upgradeTo}. Requirements: - This contract must be the admin of `proxy`." + }, + "upgradeAndCall(address,address,bytes)": { + "details": "Upgrades `proxy` to `implementation` and calls a function on the new implementation. See {TransparentUpgradeableProxy-upgradeToAndCall}. Requirements: - This contract must be the admin of `proxy`." + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [ + { + "astId": 30, + "contract": "solc_0.7/openzeppelin/proxy/ProxyAdmin.sol:ProxyAdmin", + "label": "_owner", + "offset": 0, + "slot": "0", + "type": "t_address" + } + ], + "types": { + "t_address": { + "encoding": "inplace", + "label": "address", + "numberOfBytes": "20" + } + } + } +} diff --git a/deployments/polygon_mumbai/Diamantaire.json b/deployments/polygon_mumbai/Diamantaire.json new file mode 100644 index 000000000..12ca4201c --- /dev/null +++ b/deployments/polygon_mumbai/Diamantaire.json @@ -0,0 +1,162 @@ +{ + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "abi": [ + { + "inputs": [], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "contract Diamond", + "name": "diamond", + "type": "address" + } + ], + "name": "DiamondCreated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + }, + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "bytes", + "name": "data", + "type": "bytes" + }, + { + "internalType": "bytes32", + "name": "salt", + "type": "bytes32" + } + ], + "name": "createDiamond", + "outputs": [ + { + "internalType": "contract Diamond", + "name": "diamond", + "type": "address" + } + ], + "stateMutability": "payable", + "type": "function" + } + ], + "artifactName": "Diamantaire", + "args": [], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"contract Diamond\",\"name\":\"diamond\",\"type\":\"address\"}],\"name\":\"DiamondCreated\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"}],\"name\":\"createDiamond\",\"outputs\":[{\"internalType\":\"contract Diamond\",\"name\":\"diamond\",\"type\":\"address\"}],\"stateMutability\":\"payable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamantaire.sol\":\"Diamantaire\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamantaire.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.1;\\npragma experimental ABIEncoderV2;\\n\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./Diamond.sol\\\";\\nimport \\\"./facets/DiamondCutFacet.sol\\\";\\nimport \\\"./facets/DiamondLoupeFacet.sol\\\";\\nimport \\\"./facets/OwnershipFacet.sol\\\";\\n\\ncontract Diamantaire {\\n event DiamondCreated(Diamond diamond);\\n\\n IDiamondCut.FacetCut[] internal _builtinDiamondCut;\\n\\n constructor() {\\n bytes4[] memory functionSelectors;\\n\\n // -------------------------------------------------------------------------\\n // adding diamondCut function\\n // -------------------------------------------------------------------------\\n DiamondCutFacet diamondCutFacet = new DiamondCutFacet();\\n\\n functionSelectors = new bytes4[](1);\\n functionSelectors[0] = DiamondCutFacet.diamondCut.selector;\\n _builtinDiamondCut.push(IDiamondCut.FacetCut({\\n facetAddress:address(diamondCutFacet),\\n action: IDiamondCut.FacetCutAction.Add,\\n functionSelectors: functionSelectors\\n }));\\n\\n\\n // -------------------------------------------------------------------------\\n // adding diamond loupe functions\\n // -------------------------------------------------------------------------\\n DiamondLoupeFacet diamondLoupeFacet = new DiamondLoupeFacet();\\n\\n functionSelectors = new bytes4[](5);\\n functionSelectors[0] = DiamondLoupeFacet.facetFunctionSelectors.selector;\\n functionSelectors[1] = DiamondLoupeFacet.facets.selector;\\n functionSelectors[2] = DiamondLoupeFacet.facetAddress.selector;\\n functionSelectors[3] = DiamondLoupeFacet.facetAddresses.selector;\\n functionSelectors[4] = DiamondLoupeFacet.supportsInterface.selector;\\n _builtinDiamondCut.push(IDiamondCut.FacetCut({\\n facetAddress:address(diamondLoupeFacet),\\n action: IDiamondCut.FacetCutAction.Add,\\n functionSelectors: functionSelectors\\n }));\\n\\n\\n // -------------------------------------------------------------------------\\n // adding ownership functions\\n // -------------------------------------------------------------------------\\n OwnershipFacet ownershipFacet = new OwnershipFacet();\\n\\n functionSelectors = new bytes4[](2);\\n functionSelectors[0] = OwnershipFacet.transferOwnership.selector;\\n functionSelectors[1] = OwnershipFacet.owner.selector;\\n _builtinDiamondCut.push(IDiamondCut.FacetCut({\\n facetAddress:address(ownershipFacet),\\n action: IDiamondCut.FacetCutAction.Add,\\n functionSelectors: functionSelectors\\n }));\\n }\\n\\n function createDiamond(\\n address owner,\\n IDiamondCut.FacetCut[] calldata _diamondCut,\\n bytes calldata data,\\n bytes32 salt\\n ) external payable returns (Diamond diamond) {\\n if (salt != 0x0000000000000000000000000000000000000000000000000000000000000000) {\\n salt = keccak256(abi.encodePacked(salt, owner));\\n diamond = new Diamond{value: msg.value, salt: salt}(\\n _builtinDiamondCut,\\n Diamond.DiamondArgs({owner:address(this)})\\n );\\n } else {\\n diamond = new Diamond{value: msg.value}(_builtinDiamondCut, Diamond.DiamondArgs({owner:address(this)}));\\n }\\n emit DiamondCreated(diamond);\\n\\n IDiamondCut(address(diamond)).diamondCut(_diamondCut, data.length > 0 ? address(diamond) : address(0), data);\\n IERC173(address(diamond)).transferOwnership(owner);\\n }\\n}\\n\",\"keccak256\":\"0x9e84b633e6eaca79cafdb3074e5e5621e3e3c8ed38c67f6332621a34517f2fd2\",\"license\":\"MIT\"},\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/facets/DiamondCutFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\nimport \\\"../libraries/LibDiamond.sol\\\";\\n\\ncontract DiamondCutFacet is IDiamondCut {\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external override {\\n LibDiamond.enforceIsContractOwner();\\n LibDiamond.diamondCut(_diamondCut, _init, _calldata);\\n }\\n}\\n\",\"keccak256\":\"0x5ba6b5339797ec786263a4f7027f0248868dee5e75174a643d09e10197502ce4\",\"license\":\"MIT\"},\"solc_0.7/diamond/facets/DiamondLoupeFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../libraries/LibDiamond.sol\\\";\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\nimport \\\"../interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"../interfaces/IERC165.sol\\\";\\n\\ncontract DiamondLoupeFacet is IDiamondLoupe, IERC165 {\\n // Diamond Loupe Functions\\n ////////////////////////////////////////////////////////////////////\\n /// These functions are expected to be called frequently by tools.\\n //\\n // struct Facet {\\n // address facetAddress;\\n // bytes4[] functionSelectors;\\n // }\\n\\n /// @notice Gets all facets and their selectors.\\n /// @return facets_ Facet\\n function facets() external override view returns (Facet[] memory facets_) {\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n uint256 numFacets = ds.facetAddresses.length;\\n facets_ = new Facet[](numFacets);\\n for (uint256 i; i < numFacets; i++) {\\n address facetAddress_ = ds.facetAddresses[i];\\n facets_[i].facetAddress = facetAddress_;\\n facets_[i].functionSelectors = ds.facetFunctionSelectors[facetAddress_].functionSelectors;\\n }\\n }\\n\\n /// @notice Gets all the function selectors provided by a facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external override view returns (bytes4[] memory facetFunctionSelectors_) {\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n facetFunctionSelectors_ = ds.facetFunctionSelectors[_facet].functionSelectors;\\n }\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external override view returns (address[] memory facetAddresses_) {\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n facetAddresses_ = ds.facetAddresses;\\n }\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external override view returns (address facetAddress_) {\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n facetAddress_ = ds.selectorToFacetAndPosition[_functionSelector].facetAddress;\\n }\\n\\n // This implements ERC-165.\\n function supportsInterface(bytes4 _interfaceId) external override view returns (bool) {\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n return ds.supportedInterfaces[_interfaceId];\\n }\\n}\\n\",\"keccak256\":\"0x0d7e901df775b4518d6a9805cbe226e19f8f3b1050cb8d3edccee1f382efdc00\",\"license\":\"MIT\"},\"solc_0.7/diamond/facets/OwnershipFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\nimport \\\"../libraries/LibDiamond.sol\\\";\\nimport \\\"../interfaces/IERC173.sol\\\";\\n\\ncontract OwnershipFacet is IERC173 {\\n function transferOwnership(address _newOwner) external override {\\n LibDiamond.enforceIsContractOwner();\\n LibDiamond.setContractOwner(_newOwner);\\n }\\n\\n function owner() external override view returns (address owner_) {\\n owner_ = LibDiamond.contractOwner();\\n }\\n}\\n\",\"keccak256\":\"0x9ffdb0b88ad708052930bb61b44cd178843eb66a08de48722f7d4cb94eedfaf5\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [ + { + "astId": 14, + "contract": "solc_0.7/diamond/Diamantaire.sol:Diamantaire", + "label": "_builtinDiamondCut", + "offset": 0, + "slot": "0", + "type": "t_array(t_struct(FacetCut)679_storage)dyn_storage" + } + ], + "types": { + "t_address": { + "encoding": "inplace", + "label": "address", + "numberOfBytes": "20" + }, + "t_array(t_bytes4)dyn_storage": { + "base": "t_bytes4", + "encoding": "dynamic_array", + "label": "bytes4[]", + "numberOfBytes": "32" + }, + "t_array(t_struct(FacetCut)679_storage)dyn_storage": { + "base": "t_struct(FacetCut)679_storage", + "encoding": "dynamic_array", + "label": "struct IDiamondCut.FacetCut[]", + "numberOfBytes": "32" + }, + "t_bytes4": { + "encoding": "inplace", + "label": "bytes4", + "numberOfBytes": "4" + }, + "t_enum(FacetCutAction)671": { + "encoding": "inplace", + "label": "enum IDiamondCut.FacetCutAction", + "numberOfBytes": "1" + }, + "t_struct(FacetCut)679_storage": { + "encoding": "inplace", + "label": "struct IDiamondCut.FacetCut", + "members": [ + { + "astId": 673, + "contract": "solc_0.7/diamond/Diamantaire.sol:Diamantaire", + "label": "facetAddress", + "offset": 0, + "slot": "0", + "type": "t_address" + }, + { + "astId": 675, + "contract": "solc_0.7/diamond/Diamantaire.sol:Diamantaire", + "label": "action", + "offset": 20, + "slot": "0", + "type": "t_enum(FacetCutAction)671" + }, + { + "astId": 678, + "contract": "solc_0.7/diamond/Diamantaire.sol:Diamantaire", + "label": "functionSelectors", + "offset": 0, + "slot": "1", + "type": "t_array(t_bytes4)dyn_storage" + } + ], + "numberOfBytes": "64" + } + } + } +} diff --git a/deployments/polygon_mumbai/EscrowBeaconFactory.json b/deployments/polygon_mumbai/EscrowBeaconFactory.json new file mode 100644 index 000000000..ca5759ead --- /dev/null +++ b/deployments/polygon_mumbai/EscrowBeaconFactory.json @@ -0,0 +1,286 @@ +{ + "address": "0xa49e48c4486275CA15eDdB86f5f30E02D04Ef68a", + "abi": [ + { + "inputs": [ + { + "internalType": "address payable", + "name": "proxyAddress_", + "type": "address" + }, + { + "internalType": "address", + "name": "implementation_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "implementation", + "type": "address" + } + ], + "name": "Upgraded", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes", + "name": "initData", + "type": "bytes" + } + ], + "name": "cloneProxy", + "outputs": [ + { + "internalType": "address payable", + "name": "proxy_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "implementation", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "proxyAddress", + "outputs": [ + { + "internalType": "contract InitializeableBeaconProxy", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "renounceOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newImplementation", + "type": "address" + } + ], + "name": "upgradeTo", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "UpgradeableBeaconFactory", + "transactionHash": "0xcc8d946faaf06693b9586021b18cf5f729985508358753b9bd551fbc3025bf67", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0xa49e48c4486275CA15eDdB86f5f30E02D04Ef68a", + "transactionIndex": 0, + "gasUsed": "481877", + "logsBloom": "0x00000000000000000000000000008000000000000000000000800000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000800101000000000000000100000000004000000000020000000000000000000800400000000000000080000000000000400000000000000000000000000000000000000000000080000000000200000000200000000000000000000000000000000000000000000000000000000000004000000000000100000001000000000000000000000000000000100040000020000000000000000000000000000000000000000000000000000000040000100000", + "blockHash": "0x411f3ebf2c00aec9db09768127dd39b53c9eeb117a3ccf3d436f369bd70ecf63", + "transactionHash": "0xcc8d946faaf06693b9586021b18cf5f729985508358753b9bd551fbc3025bf67", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692419, + "transactionHash": "0xcc8d946faaf06693b9586021b18cf5f729985508358753b9bd551fbc3025bf67", + "address": "0xa49e48c4486275CA15eDdB86f5f30E02D04Ef68a", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 0, + "blockHash": "0x411f3ebf2c00aec9db09768127dd39b53c9eeb117a3ccf3d436f369bd70ecf63" + }, + { + "transactionIndex": 0, + "blockNumber": 15692419, + "transactionHash": "0xcc8d946faaf06693b9586021b18cf5f729985508358753b9bd551fbc3025bf67", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000be188d6641e8b680743a4815dfa0f6208038960f" + ], + "data": "0x00000000000000000000000000000000000000000000000000335beff6501c0000000000000000000000000000000000000000000000000041b06aaf6a33ec0000000000000000000000000000000000000000000000007e567eba8a80034950000000000000000000000000000000000000000000000000417d0ebf73e3d00000000000000000000000000000000000000000000000007e56b2167a76536550", + "logIndex": 1, + "blockHash": "0x411f3ebf2c00aec9db09768127dd39b53c9eeb117a3ccf3d436f369bd70ecf63" + } + ], + "blockNumber": 15692419, + "cumulativeGasUsed": "481877", + "status": 1, + "byzantium": true + }, + "args": [ + "0xbC71607119F3daf4A7F3baDd7bBA9A1fd072D9B1", + "0xf442C6d5e6545DeC716b6b25Ef2aC420759E5d89" + ], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address payable\",\"name\":\"proxyAddress_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"implementation_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"initData\",\"type\":\"bytes\"}],\"name\":\"cloneProxy\",\"outputs\":[{\"internalType\":\"address payable\",\"name\":\"proxy_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"implementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxyAddress\",\"outputs\":[{\"internalType\":\"contract InitializeableBeaconProxy\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their implementation contract, which is where they will delegate all function calls. An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\",\"events\":{\"Upgraded(address)\":{\"details\":\"Emitted when the implementation returned by the beacon is changed.\"}},\"kind\":\"dev\",\"methods\":{\"cloneProxy(bytes)\":{\"params\":{\"initData\":\"the data to initialize after the proxy is cloned\"},\"returns\":{\"proxy_\":\"the cloned proxy\"}},\"constructor\":{\"details\":\"Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the beacon.\"},\"implementation()\":{\"details\":\"Returns the current implementation address.\"},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"},\"upgradeTo(address)\":{\"details\":\"Upgrades the beacon to a new implementation. Emits an {Upgraded} event. Requirements: - msg.sender must be the owner of the contract. - `newImplementation` must be a contract.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"cloneProxy(bytes)\":{\"notice\":\"it clones the proxy contract at an address\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":\"UpgradeableBeaconFactory\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "details": "This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their implementation contract, which is where they will delegate all function calls. An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.", + "events": { + "Upgraded(address)": { + "details": "Emitted when the implementation returned by the beacon is changed." + } + }, + "kind": "dev", + "methods": { + "cloneProxy(bytes)": { + "params": { + "initData": "the data to initialize after the proxy is cloned" + }, + "returns": { + "proxy_": "the cloned proxy" + } + }, + "constructor": { + "details": "Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the beacon." + }, + "implementation()": { + "details": "Returns the current implementation address." + }, + "owner()": { + "details": "Returns the address of the current owner." + }, + "renounceOwnership()": { + "details": "Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner." + }, + "transferOwnership(address)": { + "details": "Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner." + }, + "upgradeTo(address)": { + "details": "Upgrades the beacon to a new implementation. Emits an {Upgraded} event. Requirements: - msg.sender must be the owner of the contract. - `newImplementation` must be a contract." + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "cloneProxy(bytes)": { + "notice": "it clones the proxy contract at an address" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [ + { + "astId": 3103, + "contract": "contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol:UpgradeableBeaconFactory", + "label": "_owner", + "offset": 0, + "slot": "0", + "type": "t_address" + }, + { + "astId": 25428, + "contract": "contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol:UpgradeableBeaconFactory", + "label": "_implementation", + "offset": 0, + "slot": "1", + "type": "t_address" + }, + { + "astId": 25431, + "contract": "contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol:UpgradeableBeaconFactory", + "label": "proxyAddress", + "offset": 0, + "slot": "2", + "type": "t_contract(InitializeableBeaconProxy)25414" + } + ], + "types": { + "t_address": { + "encoding": "inplace", + "label": "address", + "numberOfBytes": "20" + }, + "t_contract(InitializeableBeaconProxy)25414": { + "encoding": "inplace", + "label": "contract InitializeableBeaconProxy", + "numberOfBytes": "20" + } + } + } +} diff --git a/deployments/polygon_mumbai/InitializeableBeaconProxy.json b/deployments/polygon_mumbai/InitializeableBeaconProxy.json new file mode 100644 index 000000000..d8b96a90c --- /dev/null +++ b/deployments/polygon_mumbai/InitializeableBeaconProxy.json @@ -0,0 +1,93 @@ +{ + "address": "0xbC71607119F3daf4A7F3baDd7bBA9A1fd072D9B1", + "abi": [ + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "beacon", + "type": "address" + }, + { + "internalType": "bytes", + "name": "data", + "type": "bytes" + } + ], + "name": "initialize", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "stateMutability": "payable", + "type": "receive" + } + ], + "artifactName": "InitializeableBeaconProxy", + "transactionHash": "0xd55ed951de5d8057133796c7f0f60244adc9ee5bcd826765dfc4ce3413f81b24", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0xbC71607119F3daf4A7F3baDd7bBA9A1fd072D9B1", + "transactionIndex": 0, + "gasUsed": "349024", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000800100000000000000000100000000004000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000080000000000000000000200000000000000000000000000000000000000000000000000000000000004000000000000100000001000000000000000000000000000000100040000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0x10cfe3473d34e8ee4f064af2313b76fcde438d7b4fbd7a9ea8723f638449c924", + "transactionHash": "0xd55ed951de5d8057133796c7f0f60244adc9ee5bcd826765dfc4ce3413f81b24", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692416, + "transactionHash": "0xd55ed951de5d8057133796c7f0f60244adc9ee5bcd826765dfc4ce3413f81b24", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000be188d6641e8b680743a4815dfa0f6208038960f" + ], + "data": "0x000000000000000000000000000000000000000000000000002533107a24800000000000000000000000000000000000000000000000000041d59dbfe4586c0000000000000000000000000000000000000000000000007e56574a7eb7a9695000000000000000000000000000000000000000000000000041b06aaf6a33ec0000000000000000000000000000000000000000000000007e567c7d8f31cde950", + "logIndex": 0, + "blockHash": "0x10cfe3473d34e8ee4f064af2313b76fcde438d7b4fbd7a9ea8723f638449c924" + } + ], + "blockNumber": 15692416, + "cumulativeGasUsed": "349024", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"details\":\"This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}. The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't conflict with the storage layout of the implementation behind the proxy. _Available since v3.4._\",\"kind\":\"dev\",\"methods\":{\"initialize(address,bytes)\":{\"details\":\"Initializes the proxy with `beacon`. If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity constructor. Requirements: - `beacon` must be a contract with the interface {IBeacon}.\"}},\"stateVariables\":{\"_BEACON_SLOT\":{\"details\":\"The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy. This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":\"InitializeableBeaconProxy\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "details": "This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}. The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't conflict with the storage layout of the implementation behind the proxy. _Available since v3.4._", + "kind": "dev", + "methods": { + "initialize(address,bytes)": { + "details": "Initializes the proxy with `beacon`. If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity constructor. Requirements: - `beacon` must be a contract with the interface {IBeacon}." + } + }, + "stateVariables": { + "_BEACON_SLOT": { + "details": "The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy. This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor." + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/LendingFacet.json b/deployments/polygon_mumbai/LendingFacet.json new file mode 100644 index 000000000..58833307e --- /dev/null +++ b/deployments/polygon_mumbai/LendingFacet.json @@ -0,0 +1,167 @@ +{ + "address": "0x50a0DE2C69Ca270F8FBB4732EEA85552B89D7A5b", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "LendingFacet", + "transactionHash": "0xa0104a15f2b9916b8abe8d1fcdfdeeccda9f7f269b7bc483b92816698ac2e036", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x50a0DE2C69Ca270F8FBB4732EEA85552B89D7A5b", + "transactionIndex": 0, + "gasUsed": "815713", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000800100000000000000000100000000004000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000080000000000000000000200000000000000000000000000000000000000000000000000000000000004000000000000100000001000000000000000000000000000000100040000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0xee224d060c3dc659e0f6b40a7638f3e663a2bcf80ab685f57e744443e0e30b5a", + "transactionHash": "0xa0104a15f2b9916b8abe8d1fcdfdeeccda9f7f269b7bc483b92816698ac2e036", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692464, + "transactionHash": "0xa0104a15f2b9916b8abe8d1fcdfdeeccda9f7f269b7bc483b92816698ac2e036", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000be188d6641e8b680743a4815dfa0f6208038960f" + ], + "data": "0x0000000000000000000000000000000000000000000000000056f0997c1c2c000000000000000000000000000000000000000000000000003e4bcef3c60dd00000000000000000000000000000000000000000000000007e5a30701c943191500000000000000000000000000000000000000000000000003df4de5a49f1a40000000000000000000000000000000000000000000000007e5a8760b6104dbd50", + "logIndex": 0, + "blockHash": "0xee224d060c3dc659e0f6b40a7638f3e663a2bcf80ab685f57e744443e0e30b5a" + } + ], + "blockNumber": 15692464, + "cumulativeGasUsed": "815713", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"LendingPoolInitialized\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"getTTokenFor\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"tToken_\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"initLendingPool\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"lendingPoolDeposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"LendingPoolInitialized(address,address)\":{\"params\":{\"asset\":\"Token address the pool was initialized for.\",\"sender\":\"address.\"}}},\"kind\":\"dev\",\"methods\":{\"getTTokenFor(address)\":{\"params\":{\"asset\":\"Address to get a Teller Token for.\"}},\"initLendingPool(address)\":{\"params\":{\"asset\":\"Token address to initialize the lending pool for.\"}},\"lendingPoolDeposit(address,uint256)\":{\"details\":\"the user must call ERC20.approve function previously.If the cToken is available (not 0x0), it deposits the lending asset amount into Compound directly.\",\"params\":{\"amount\":\"Amount of {asset} to deposit in the pool.\",\"asset\":\"Token address to deposit into the lending pool.\"}}},\"version\":1},\"userdoc\":{\"events\":{\"LendingPoolInitialized(address,address)\":{\"notice\":\"This event is emitted when a new lending pool is initialized.\"}},\"kind\":\"user\",\"methods\":{\"getTTokenFor(address)\":{\"notice\":\"Get the Teller Token address for an underlying asset.\"},\"initLendingPool(address)\":{\"notice\":\"It initializes a new lending pool for the respective token\"},\"lendingPoolDeposit(address,uint256)\":{\"notice\":\"It allows users to deposit tokens into the pool.\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/lending/LendingFacet.sol\":\"LendingFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\nimport \\\"../../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20Upgradeable {\\n using AddressUpgradeable for address;\\n\\n function safeTransfer(IERC20Upgradeable token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20Upgradeable token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20Upgradeable token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0xc28d9f2ac7088d478d86ec6c0e1dadd48af1b2d0c1f6d497f9b652339e3002ec\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/reentry/ReentryMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nabstract contract ReentryMods {\\n modifier nonReentry(bytes32 id) {\\n AccessControlStorage storage s = AccessControlStorageLib.store();\\n require(!s.entered[id], \\\"AccessControl: reentered\\\");\\n s.entered[id] = true;\\n _;\\n s.entered[id] = false;\\n }\\n}\\n\",\"keccak256\":\"0x033c1164af25ef7d35a38a60973bf379b1cc603596914ffd85dcbcf0acdb6970\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n /**\\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\\n * @param dappAddress address of the target contract address\\n * @param dappData encoded abi of the function in our contract we want to call\\n * @return the called data in bytes\\n */\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n /**\\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\\n * @param token address of the respective ERC20 token to approve for the spender\\n * @param spender address of the respective spender who is approved by the token contract\\n */\\n function setTokenAllowance(address token, address spender) external;\\n\\n /**\\n * @notice it allows user to claim their escrow tokens\\n * @dev only the owner (TellerDiamond) can make this call on behalf of the users\\n * @param token address of the respective token contract to claim tokens from\\n * @param to address where the tokens should be transferred to\\n * @param amount uint256 amount of tokens to be claimed\\n */\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xaf67fc4454ffaa4d2f7e46fe7101876e8ebdb1a5426c30f87b8e18cc573ac019\",\"license\":\"MIT\"},\"contracts/lending/LendingFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\nimport {\\n ReentryMods\\n} from \\\"../contexts2/access-control/reentry/ReentryMods.sol\\\";\\nimport { RolesMods } from \\\"../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../shared/roles.sol\\\";\\n\\n// Interfaces\\nimport { ITToken } from \\\"./ttoken/ITToken.sol\\\";\\n\\n// Libraries\\nimport {\\n IERC20,\\n SafeERC20\\n} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport {\\n SafeERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\\\";\\nimport { MaxTVLLib } from \\\"../settings/asset/libraries/MaxTVLLib.sol\\\";\\nimport { LendingLib } from \\\"./libraries/LendingLib.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract LendingFacet is RolesMods, ReentryMods, PausableMods {\\n /**\\n * @notice This event is emitted when a new lending pool is initialized.\\n * @param sender address.\\n * @param asset Token address the pool was initialized for.\\n */\\n event LendingPoolInitialized(address indexed sender, address asset);\\n\\n /**\\n * @notice Get the Teller Token address for an underlying asset.\\n * @param asset Address to get a Teller Token for.\\n */\\n function getTTokenFor(address asset)\\n external\\n view\\n returns (address tToken_)\\n {\\n tToken_ = address(LendingLib.tToken(asset));\\n }\\n\\n /**\\n * @notice It allows users to deposit tokens into the pool.\\n * @dev the user must call ERC20.approve function previously.\\n * @dev If the cToken is available (not 0x0), it deposits the lending asset amount into Compound directly.\\n * @param asset Token address to deposit into the lending pool.\\n * @param amount Amount of {asset} to deposit in the pool.\\n */\\n function lendingPoolDeposit(address asset, uint256 amount)\\n external\\n paused(LendingLib.ID, false)\\n authorized(AUTHORIZED, msg.sender)\\n nonReentry(LendingLib.ID)\\n {\\n ITToken tToken = LendingLib.tToken(asset);\\n require(\\n address(tToken) != address(0),\\n \\\"Teller: lending pool not initialized\\\"\\n );\\n\\n require(\\n tToken.currentTVL() + amount <= MaxTVLLib.get(asset),\\n \\\"Teller: deposit TVL exceeded\\\"\\n );\\n\\n // Transfer tokens from lender\\n SafeERC20.safeTransferFrom(\\n IERC20(asset),\\n msg.sender,\\n address(this),\\n amount\\n );\\n // Set allowance for Teller token to pull funds to mint\\n SafeERC20.safeIncreaseAllowance(IERC20(asset), address(tToken), amount);\\n // Mint Teller tokens, then transfer to lender\\n SafeERC20Upgradeable.safeTransfer(\\n tToken,\\n msg.sender,\\n // Minting returns the amount of Teller tokens minted\\n tToken.mint(amount)\\n );\\n }\\n\\n /**\\n * @notice It initializes a new lending pool for the respective token\\n * @param asset Token address to initialize the lending pool for.\\n */\\n function initLendingPool(address asset)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n require(\\n address(LendingLib.tToken(asset)) == address(0),\\n \\\"Teller: lending pool already initialized\\\"\\n );\\n\\n // Create a new Teller Token\\n address tToken = AppStorageLib.store().tTokenBeacon.cloneProxy(\\\"\\\");\\n // Set the Teller Token to the asset mapping\\n LendingLib.s().tTokens[asset] = ITToken(tToken);\\n // Initialize the Teller Token\\n LendingLib.s().tTokens[asset].initialize(msg.sender, asset);\\n\\n // Emit event\\n emit LendingPoolInitialized(msg.sender, asset);\\n }\\n}\\n\",\"keccak256\":\"0xd736149e487fdd3573d1864c1e7bc509b686d755b832404aa0c810638f178f3f\",\"license\":\"MIT\"},\"contracts/lending/libraries/LendingLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\n\\n// Interfaces\\nimport { ITToken } from \\\"../ttoken/ITToken.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LendingLib {\\n bytes32 internal constant ID = keccak256(\\\"LENDING\\\");\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function tToken(address asset) internal view returns (ITToken tToken_) {\\n tToken_ = s().tTokens[asset];\\n }\\n}\",\"keccak256\":\"0xc396ed8e9815696bf409386b4d99ea04168659e0f895ce1e4bd7453749924e1c\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when a user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when a user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n * @return ERC20 token\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n * @return balance_ the balance of the account\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice It calculates the total supply of the underlying asset.\\n * @return totalSupply_ the total supply denoted in the underlying asset.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given market.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n \\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfill the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n * @return mintAmount_ the amount minted of the specified token\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n * @return address of the strategy contract\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n * @param state boolean value that resembles the platform's state\\n */\\n function restrict(bool state) external virtual;\\n\\n /**\\n * @notice it initializes the Teller Token\\n * @param admin address of the admin to the respective Teller Token\\n * @param underlying address of the ERC20 token\\n */\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xf30ac4ef491851477ff9a3dd04974ebe74b529c37a3ef4e05798c3f734ceeb3d\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n /**\\n * @notice it initializes an escrow\\n * @param tokenAddress the address of the collateral token to be stored\\n * @param isWETH check if it's wrapped Ethereum\\n */\\n function init(address tokenAddress, bool isWETH) external;\\n\\n /**\\n * @notice it deposits an amount of the respective collateral token into the escrow\\n * @param loanID the ID of the loan\\n * @param amount the amount of collateral tokens to be deposited\\n */\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n /**\\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\\n * @dev only the TellerDiamond can make this call on behalf of the borrower\\n * @param loanID identifier of the loan\\n * @param amount number of collateral tokens to send\\n * @param receiver payable address to transfer money to\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n /**\\n * @notice it returns the supply of the respective loan\\n * @param loanID the respective loan ID\\n * @return supply_ the amount in collateral of the respective loan\\n */\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n /**\\n * @notice it returns the total supply of the collateral token held by the contract\\n * @return supply_ the total amount of collateral\\n */\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x900fed2311f919ba1451a6583ddbf9f3bc8afa8f5189500fff51f0c049258ed3\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x417b75f5d92be67993efc54db7d453be5b5058a9a54d8916380e0281d3299526\",\"license\":\"MIT\"},\"contracts/settings/asset/libraries/MaxTVLLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n CacheLib,\\n Cache,\\n CacheType\\n} from \\\"../../../shared/libraries/CacheLib.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library of inline functions for MaxDebtRatio asset setting.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary MaxTVLLib {\\n bytes32 private constant NAME = keccak256(\\\"MaxTVL\\\");\\n\\n function s(address asset) private view returns (Cache storage) {\\n return AppStorageLib.store().assetSettings[asset];\\n }\\n\\n function get(address asset) internal view returns (uint256) {\\n return s(asset).uints[NAME];\\n }\\n\\n function set(address asset, uint256 newValue) internal {\\n s(asset).uints[NAME] = newValue;\\n }\\n}\\n\",\"keccak256\":\"0x7ee0cef332ce56b76d23da67d1ea7d5a7cf6cd4fe1330516bd8339bbcfaf7006\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\nabstract contract PausableMods {\\n /**\\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\\n * @param id id of the facet to check if is paused.\\n * @param state Boolean that the protocol AND facet should be in.\\n */\\n modifier paused(bytes32 id, bool state) {\\n require(\\n __isPaused(\\\"\\\") == state && __isPaused(id) == state,\\n __pausedMessage(state)\\n );\\n _;\\n }\\n\\n /**\\n * @dev Checks if the given id is paused.\\n * @param id Encoded id of the facet to check if is paused.\\n * @return the bool to tell us if the facet is paused (true) or not (false)\\n */\\n function __isPaused(bytes32 id) private view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n\\n /**\\n * @dev Gets the message that should be reverted with given a state it should be in.\\n * @param state Boolean that an id should be in.\\n * @return a message stating whether the facet is paused or not\\n */\\n function __pausedMessage(bool state) private pure returns (string memory) {\\n return state ? \\\"Pausable: not paused\\\" : \\\"Pausable: paused\\\";\\n }\\n}\\n\",\"keccak256\":\"0x2d3f848ee56ae5fa365539c2509c03c167affc89c89f98bb98cb9b83fbe8ae4c\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"NFTInterestRate\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getNFTInterestRate() internal view returns (uint16 value_) {\\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0x44294be1af9f913b2ed391a40cd4b646537a4b463b8d5ff1fac8ead3988966c1\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for loans taken out with an NFT.\\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\\n */\\nbytes32 constant NFT_INTEREST_RATE = keccak256(\\\"NFTInterestRate\\\");\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xd68a7df42b2bbba6f935d5890b7b37997c1432e25ae113827b8bde87f94fd86f\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n /**\\n * @notice it returns the absolute number of a specified parameter\\n * @param self the number to be returned in it's absolute\\n * @return the absolute number\\n */\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0x4f750cde25d4b1db919abf3192d58ed6aef617d03637e1e9e2dc31b70dcc32a3\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n address wrappedNativeToken;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4504c5c460972a25cd1f0e6eb1d8dd84a668be75a3aeb89a47a49c2327c12923\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\n// DEPRECATED\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\nstruct LoanRequest {\\n LoanUserRequest request;\\n LoanConsensusResponse[] responses;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanUserRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanConsensusResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) _loanTerms; // DEPRECATED: DO NOT REMOVE\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb7e05aeec806b5621512def93f4a389b4ef88c50ef9fe7115a33f57db2f2304b\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "events": { + "LendingPoolInitialized(address,address)": { + "params": { + "asset": "Token address the pool was initialized for.", + "sender": "address." + } + } + }, + "kind": "dev", + "methods": { + "getTTokenFor(address)": { + "params": { + "asset": "Address to get a Teller Token for." + } + }, + "initLendingPool(address)": { + "params": { + "asset": "Token address to initialize the lending pool for." + } + }, + "lendingPoolDeposit(address,uint256)": { + "details": "the user must call ERC20.approve function previously.If the cToken is available (not 0x0), it deposits the lending asset amount into Compound directly.", + "params": { + "amount": "Amount of {asset} to deposit in the pool.", + "asset": "Token address to deposit into the lending pool." + } + } + }, + "version": 1 + }, + "userdoc": { + "events": { + "LendingPoolInitialized(address,address)": { + "notice": "This event is emitted when a new lending pool is initialized." + } + }, + "kind": "user", + "methods": { + "getTTokenFor(address)": { + "notice": "Get the Teller Token address for an underlying asset." + }, + "initLendingPool(address)": { + "notice": "It initializes a new lending pool for the respective token" + }, + "lendingPoolDeposit(address,uint256)": { + "notice": "It allows users to deposit tokens into the pool." + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/LoanDataFacet.json b/deployments/polygon_mumbai/LoanDataFacet.json new file mode 100644 index 000000000..cde1052af --- /dev/null +++ b/deployments/polygon_mumbai/LoanDataFacet.json @@ -0,0 +1,453 @@ +{ + "address": "0x802ff89ABeEe5F98eDDF38E20eF17F246F2c5d36", + "abi": [ + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + } + ], + "artifactName": "LoanDataFacet", + "transactionHash": "0xda8a9784e53d4fd08ddae2e35dd1295fb094fd643bddf890d2c7c1380175e0d0", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x802ff89ABeEe5F98eDDF38E20eF17F246F2c5d36", + "transactionIndex": 0, + "gasUsed": "927884", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000800100000000000000000100000000004000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000080000000000000000000200000000000000000000000000000000000000000000000000000000000004000000000000100000001000000000000000000000000000000100040000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0xc381d5ad5e864f84e56ec103344fdb06c6382e14368f3df0d9164eafdece9deb", + "transactionHash": "0xda8a9784e53d4fd08ddae2e35dd1295fb094fd643bddf890d2c7c1380175e0d0", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692475, + "transactionHash": "0xda8a9784e53d4fd08ddae2e35dd1295fb094fd643bddf890d2c7c1380175e0d0", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000be188d6641e8b680743a4815dfa0f6208038960f" + ], + "data": "0x0000000000000000000000000000000000000000000000000062e52ade6210000000000000000000000000000000000000000000000000003c493743d1ef200000000000000000000000000000000000000000000000007e5c8816b6407525500000000000000000000000000000000000000000000000003be65218f38d100000000000000000000000000000000000000000000000007e5ceafbe11ed73550", + "logIndex": 0, + "blockHash": "0xc381d5ad5e864f84e56ec103344fdb06c6382e14368f3df0d9164eafdece9deb" + } + ], + "blockNumber": 15692475, + "cumulativeGasUsed": "927884", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"}],\"name\":\"getBorrowerLoans\",\"outputs\":[{\"internalType\":\"uint128[]\",\"name\":\"loanIDs\",\"type\":\"uint128[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getCollateralNeededInfo\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"neededInLendingTokens\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"neededInCollateralTokens\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"escrowLoanValue\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getDebtOwed\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"principalOwed\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"interestOwed\",\"type\":\"uint256\"}],\"internalType\":\"struct LoanDebt\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getEscrowTokens\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountBorrow\",\"type\":\"uint256\"}],\"name\":\"getInterestOwedFor\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLoan\",\"outputs\":[{\"components\":[{\"internalType\":\"address payable\",\"name\":\"borrower\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"lendingToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"collateralToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"borrowedAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint128\",\"name\":\"id\",\"type\":\"uint128\"},{\"internalType\":\"uint32\",\"name\":\"duration\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"loanStartTime\",\"type\":\"uint32\"},{\"internalType\":\"uint16\",\"name\":\"interestRate\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"collateralRatio\",\"type\":\"uint16\"},{\"internalType\":\"enum LoanStatus\",\"name\":\"status\",\"type\":\"uint8\"}],\"internalType\":\"struct Loan\",\"name\":\"loan_\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLoanEscrow\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"escrow_\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLoanEscrowValue\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLoanTerms\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"maxLoanAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint32\",\"name\":\"termsExpiry\",\"type\":\"uint32\"}],\"internalType\":\"struct LoanTerms\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getTotalOwed\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"getBorrowerLoans(address)\":{\"params\":{\"borrower\":\"The account to get loan IDs for.\"},\"returns\":{\"loanIDs\":\"The IDs for loans created by the {borrower}\"}},\"getCollateralNeededInfo(uint256)\":{\"params\":{\"loanID\":\"the identifier of the loan ID to retrieve collateral from\"},\"returns\":{\"escrowLoanValue\":\"total collateral needed in loan value\",\"neededInCollateralTokens\":\"total collateral needed in collateral tokens\",\"neededInLendingTokens\":\"total collateral needed in lending tokens\"}},\"getDebtOwed(uint256)\":{\"params\":{\"loanID\":\"The loan ID to get the total amount owed.\"},\"returns\":{\"_0\":\"LoanDebt The principal and interest owed amount.\"}},\"getEscrowTokens(uint256)\":{\"params\":{\"loanID\":\"the identifier of the respective escrow's loan\"},\"returns\":{\"tokens_\":\"the tokens held at the escrow loan\"}},\"getInterestOwedFor(uint256,uint256)\":{\"params\":{\"amountBorrow\":\"The principal of the loan to take out.\",\"loanID\":\"The loan ID to get the owed interest.\"},\"returns\":{\"_0\":\"uint256 The interest owed.\"}},\"getLoan(uint256)\":{\"params\":{\"loanID\":\"The loan ID to get information for.\"},\"returns\":{\"loan_\":\"The loan data.\"}},\"getLoanEscrow(uint256)\":{\"params\":{\"loanID\":\"the identifier of the respective escrow's loan\"},\"returns\":{\"escrow_\":\"the typed address of the returned ILoanEscrow\"}},\"getLoanEscrowValue(uint256)\":{\"params\":{\"loanID\":\"the identifier of the respective escrow's loan\"},\"returns\":{\"_0\":\"the total value of the loan escrow\"}},\"getLoanTerms(uint256)\":{\"params\":{\"loanID\":\"The loan ID to get the total amount owed.\"},\"returns\":{\"_0\":\"LoanTerms The terms that the loan weer created with.\"}},\"getTotalOwed(uint256)\":{\"params\":{\"loanID\":\"The loan ID to get the total amount owed.\"},\"returns\":{\"_0\":\"uint256 The total owed amount.\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"getBorrowerLoans(address)\":{\"notice\":\"Returns the loan IDs created by the {borrower} account.\"},\"getCollateralNeededInfo(uint256)\":{\"notice\":\"it returns the collateral needed for a loan\"},\"getDebtOwed(uint256)\":{\"notice\":\"Returns the debt owed for a specified loan.\"},\"getEscrowTokens(uint256)\":{\"notice\":\"it returns the total escrow tokens held by an escrow\"},\"getInterestOwedFor(uint256,uint256)\":{\"notice\":\"Returns the amount of interest owed for a given loan and loan amount.\"},\"getLoan(uint256)\":{\"notice\":\"Returns the information about the given {loanID}.\"},\"getLoanEscrow(uint256)\":{\"notice\":\"it returns the typed address of a loan escrow\"},\"getLoanEscrowValue(uint256)\":{\"notice\":\"it returns the escrow's total value by calculating the value all the escrow tokens\"},\"getLoanTerms(uint256)\":{\"notice\":\"DEPRECATEDReturns the terms for a specified loan.\"},\"getTotalOwed(uint256)\":{\"notice\":\"Returns the total amount owed for a specified loan.\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/market/LoanDataFacet.sol\":\"LoanDataFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../../../shared/interfaces/IAToken.sol\\\";\\nimport {\\n IAaveLendingPool\\n} from \\\"../../../shared/interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../../../shared/interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xd05e3E715d945B59290df0ae8eF85c1BdB684744 // Polygon mainnet\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x4c18d46f924a3a24d596971d39857477b618dad13dee55decc271bdccf915ee5\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n /**\\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\\n * @param dappAddress address of the target contract address\\n * @param dappData encoded abi of the function in our contract we want to call\\n * @return the called data in bytes\\n */\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n /**\\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\\n * @param token address of the respective ERC20 token to approve for the spender\\n * @param spender address of the respective spender who is approved by the token contract\\n */\\n function setTokenAllowance(address token, address spender) external;\\n\\n /**\\n * @notice it allows user to claim their escrow tokens\\n * @dev only the owner (TellerDiamond) can make this call on behalf of the users\\n * @param token address of the respective token contract to claim tokens from\\n * @param to address where the tokens should be transferred to\\n * @param amount uint256 amount of tokens to be claimed\\n */\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xaf67fc4454ffaa4d2f7e46fe7101876e8ebdb1a5426c30f87b8e18cc573ac019\",\"license\":\"MIT\"},\"contracts/escrow/libraries/LibEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibDapps } from \\\"../dapps/libraries/LibDapps.sol\\\";\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibEscrow {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\\n e_ = s().loanEscrows[loanID];\\n }\\n\\n /**\\n * @notice It returns a list of tokens owned by a loan escrow\\n * @param loanID uint256 index used to return our token list\\n * @return t_ which is a list of tokens \\n */\\n function getEscrowTokens(uint256 loanID)\\n internal\\n view\\n returns (EnumerableSet.AddressSet storage t_)\\n {\\n t_ = s().escrowTokens[loanID];\\n }\\n\\n /**\\n * @notice It returns the balance of a respective token in a loan escrow\\n * @param loanID uint256 index used to point to our loan escrow\\n * @param token address of respective token to give us the balance of in our loan escrow\\n * @return uint256 balance of respective token returned in an escrow loan\\n */\\n function balanceOf(uint256 loanID, address token)\\n internal\\n view\\n returns (uint256)\\n {\\n return IERC20(token).balanceOf(address(e(loanID)));\\n }\\n\\n /**\\n * @notice Adds or removes tokens held by the Escrow contract\\n * @param loanID The loan ID to update the token list for\\n * @param tokenAddress The token address to be added or removed\\n */\\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\\n // Skip if is lending token\\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\\n\\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\\n if (balanceOf(loanID, tokenAddress) > 0) {\\n if (!contains) {\\n EnumerableSet.add(tokens, tokenAddress);\\n }\\n } else if (contains) {\\n EnumerableSet.remove(tokens, tokenAddress);\\n }\\n }\\n\\n /**\\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\\n * @param loanID The loan ID to calculate value for\\n * @return value_ Escrow total value denoted in the lending token.\\n */\\n function calculateTotalValue(uint256 loanID)\\n internal\\n view\\n returns (uint256 value_)\\n {\\n address lendingToken = LibLoans.loan(loanID).lendingToken;\\n value_ += balanceOf(loanID, lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\\n if (EnumerableSet.length(tokens) > 0) {\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n uint256 tokenBal =\\n balanceOf(loanID, EnumerableSet.at(tokens, i));\\n value_ += PriceAggLib.valueFor(\\n EnumerableSet.at(tokens, i),\\n lendingToken,\\n tokenBal\\n );\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x17a7c6b11d6f280948e320525d1e131b89c23f80216918aa070df437a851d915\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when a user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when a user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n * @return ERC20 token\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n * @return balance_ the balance of the account\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice It calculates the total supply of the underlying asset.\\n * @return totalSupply_ the total supply denoted in the underlying asset.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given market.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n \\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfill the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n * @return mintAmount_ the amount minted of the specified token\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n * @return address of the strategy contract\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n * @param state boolean value that resembles the platform's state\\n */\\n function restrict(bool state) external virtual;\\n\\n /**\\n * @notice it initializes the Teller Token\\n * @param admin address of the admin to the respective Teller Token\\n * @param underlying address of the ERC20 token\\n */\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xf30ac4ef491851477ff9a3dd04974ebe74b529c37a3ef4e05798c3f734ceeb3d\",\"license\":\"MIT\"},\"contracts/market/LoanDataFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { Loan, LoanDebt, LoanTerms } from \\\"../storage/market.sol\\\";\\n\\ncontract LoanDataFacet {\\n /**\\n * @notice Returns the information about the given {loanID}.\\n * @param loanID The loan ID to get information for.\\n * @return loan_ The loan data.\\n */\\n function getLoan(uint256 loanID) external view returns (Loan memory loan_) {\\n loan_ = LibLoans.s().loans[loanID];\\n }\\n\\n /**\\n * @notice DEPRECATED\\n * @notice Returns the terms for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanTerms The terms that the loan weer created with.\\n */\\n function getLoanTerms(uint256 loanID)\\n external\\n view\\n returns (LoanTerms memory)\\n {\\n return LibLoans.terms(loanID);\\n }\\n\\n /**\\n * @notice Returns the loan IDs created by the {borrower} account.\\n * @param borrower The account to get loan IDs for.\\n * @return loanIDs The IDs for loans created by the {borrower}\\n */\\n function getBorrowerLoans(address borrower)\\n external\\n view\\n returns (uint128[] memory loanIDs)\\n {\\n return LibLoans.s().borrowerLoans[borrower];\\n }\\n\\n /**\\n * @notice Returns the debt owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanDebt The principal and interest owed amount.\\n */\\n function getDebtOwed(uint256 loanID)\\n external\\n view\\n returns (LoanDebt memory)\\n {\\n return LibLoans.debt(loanID);\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) external view returns (uint256) {\\n return LibLoans.getTotalOwed(loanID);\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n external\\n view\\n returns (uint256)\\n {\\n return LibLoans.getInterestOwedFor(loanID, amountBorrow);\\n }\\n\\n /**\\n * @notice it returns the collateral needed for a loan\\n * @param loanID the identifier of the loan ID to retrieve collateral from\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n external\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n return LibLoans.getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the typed address of a loan escrow\\n * @param loanID the identifier of the respective escrow's loan\\n * @return escrow_ the typed address of the returned ILoanEscrow\\n */\\n function getLoanEscrow(uint256 loanID)\\n external\\n view\\n returns (address escrow_)\\n {\\n escrow_ = address(LibLoans.s().loanEscrows[loanID]);\\n }\\n\\n /**\\n * @notice it returns the escrow's total value by calculating the value all the escrow tokens\\n * @param loanID the identifier of the respective escrow's loan\\n * @return the total value of the loan escrow\\n */\\n function getLoanEscrowValue(uint256 loanID)\\n external\\n view\\n returns (uint256)\\n {\\n return LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n /**\\n * @notice it returns the total escrow tokens held by an escrow\\n * @param loanID the identifier of the respective escrow's loan\\n * @return tokens_ the tokens held at the escrow loan\\n */\\n function getEscrowTokens(uint256 loanID)\\n external\\n view\\n returns (address[] memory tokens_)\\n {\\n EnumerableSet.AddressSet storage escrowTokens =\\n LibEscrow.getEscrowTokens(loanID);\\n tokens_ = new address[](EnumerableSet.length(escrowTokens));\\n for (uint256 i; i < tokens_.length; i++) {\\n tokens_[i] = EnumerableSet.at(escrowTokens, i);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xbf39ea599f556eb6c0ea2e9aef435fe8edc258c63511667506923f54f6200bba\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n /**\\n * @notice it initializes an escrow\\n * @param tokenAddress the address of the collateral token to be stored\\n * @param isWETH check if it's wrapped Ethereum\\n */\\n function init(address tokenAddress, bool isWETH) external;\\n\\n /**\\n * @notice it deposits an amount of the respective collateral token into the escrow\\n * @param loanID the ID of the loan\\n * @param amount the amount of collateral tokens to be deposited\\n */\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n /**\\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\\n * @dev only the TellerDiamond can make this call on behalf of the borrower\\n * @param loanID identifier of the loan\\n * @param amount number of collateral tokens to send\\n * @param receiver payable address to transfer money to\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n /**\\n * @notice it returns the supply of the respective loan\\n * @param loanID the respective loan ID\\n * @return supply_ the amount in collateral of the respective loan\\n */\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n /**\\n * @notice it returns the total supply of the collateral token held by the contract\\n * @return supply_ the total amount of collateral\\n */\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x900fed2311f919ba1451a6583ddbf9f3bc8afa8f5189500fff51f0c049258ed3\",\"license\":\"MIT\"},\"contracts/market/libraries/LibLoans.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibEscrow } from \\\"../../escrow/libraries/LibEscrow.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus,\\n LoanDebt,\\n LoanTerms\\n} from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibLoans {\\n using NumbersLib for int256;\\n using NumbersLib for uint256;\\n\\n bytes32 internal constant ID = keccak256(\\\"LOANS\\\");\\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n * @notice it returns the loan\\n * @param loanID the ID of the respective loan\\n * @return l_ the loan\\n */\\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\\n l_ = s().loans[loanID];\\n }\\n\\n /**\\n * @notice it returns the loan debt from a respective loan\\n * @param loanID the ID of the respective loan\\n * @return d_ the loan debt from a respective loan\\n */\\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\\n d_ = s().loanDebt[loanID];\\n }\\n\\n // DEPRECATED\\n function terms(uint256 loanID)\\n internal\\n view\\n returns (LoanTerms storage t_)\\n {\\n t_ = s()._loanTerms[loanID];\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return owed_ uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID)\\n internal\\n view\\n returns (uint256 owed_)\\n {\\n if (loan(loanID).status == LoanStatus.Active) {\\n owed_ = debt(loanID).principalOwed + (debt(loanID).interestOwed);\\n }\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n internal\\n view\\n returns (uint256)\\n {\\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\\n }\\n\\n function getCollateralNeeded(uint256 loanID)\\n internal\\n view\\n returns (uint256 _needed)\\n {\\n (, _needed, ) = getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the total collateral needed in lending tokens, in collateral tokens and in escrowed loan values\\n * @param loanID the loanID to get the total collateral needed\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n internal\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\\n loanID\\n );\\n\\n // check if needed lending tokens is zero. if true, then needed collateral tokens is zero. else,\\n if (neededInLendingTokens == 0) {\\n neededInCollateralTokens = 0;\\n } else {\\n neededInCollateralTokens = PriceAggLib.valueFor(\\n loan(loanID).lendingToken,\\n loan(loanID).collateralToken,\\n neededInLendingTokens\\n );\\n }\\n }\\n\\n /**\\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\\n * @param loanID The loan ID to get needed collateral info for.\\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\\n */\\n function getCollateralNeededInTokens(uint256 loanID)\\n internal\\n view\\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\\n {\\n if (loan(loanID).collateralRatio == 0) {\\n return (0, 0);\\n }\\n\\n /*\\n The collateral to principal owed ratio is the sum of:\\n * collateral buffer percent\\n * loan interest rate\\n * liquidation reward percent\\n * X factor of additional collateral\\n */\\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n neededInLendingTokens = loan(loanID).borrowedAmount.percent(\\n loan(loanID).collateralRatio\\n );\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n uint16 requiredRatio =\\n loan(loanID).collateralRatio -\\n getInterestRatio(loanID) -\\n uint16(PlatformSettingsLib.getCollateralBufferValue());\\n\\n neededInLendingTokens =\\n debt(loanID).principalOwed +\\n debt(loanID).interestOwed;\\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\\n if (\\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\\n ) {\\n neededInLendingTokens -= escrowLoanValue;\\n }\\n neededInLendingTokens = neededInLendingTokens.percent(\\n requiredRatio\\n );\\n }\\n }\\n\\n /**\\n * @notice check if a loan can go to end of auction with a collateral ratio\\n * @return bool checking if collateralRatio is >= the over collateralized buffer value\\n */\\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\\n internal\\n view\\n returns (bool)\\n {\\n return\\n collateralRatio >=\\n PlatformSettingsLib.getOverCollateralizedBufferValue();\\n }\\n\\n /**\\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\\n * @notice There is a minimum threshold of 1%.\\n * @dev The interest rate is APY (annual percentage yield).\\n * @param loanID The loan ID to get the interest rate for.\\n */\\n function getInterestRatio(uint256 loanID)\\n internal\\n view\\n returns (uint16 ratio_)\\n {\\n ratio_ = uint16(\\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\\n SECONDS_PER_YEAR\\n );\\n\\n if (ratio_ == 0) {\\n ratio_ = 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0xaabb82718f6948669e5c984d7bdc0d0ae4806e3b17beba4dd60e771d67444c07\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x417b75f5d92be67993efc54db7d453be5b5058a9a54d8916380e0281d3299526\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param amount Amount of the source token to convert into the destination token.\\n * @param exchangeRate The calculated exchange rate between the tokens.\\n * @return uint256 Value of the source token amount given an exchange rate peg.\\n */\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n /**\\n * @notice it returns 10^{numberOfDecimals} for a token\\n * @param token the address to calculate the decimals for\\n * @return 10^number of decimals used to calculate the price and value of different token pairs\\n */\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @notice It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @notice it tries to calculate a price from Compound and Chainlink.\\n * @dev if no price is found on compound, then calculate it on chainlink\\n * @param src the token address to calculate the price for in dst\\n * @param dst the token address to retrieve the price of src\\n * @return price_ the price of src in dst\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n * @param src the address of the src token\\n * @param dst the address of the dst token\\n * @return the price of the src token in dst token\\n\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n * @param src the source token to calculate price for with chainlink\\n * @param dst the destination token to calculate price for with chainlink\\n * @param cRate the compound rate to multiply with the price of the dst token\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @notice Scales the {value} by the difference in decimal values.\\n * @param value the the value of the src in dst\\n * @param srcDecimals src token decimals\\n * @param dstDecimals dst token decimals\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @notice it tries to calculate the price of {src} in {dst}\\n * @param src address of source token\\n * @param dst address of destination token\\n * @return the price of src token in dst\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address wrappedNativeToken =\\n AppStorageLib.store().wrappedNativeToken;\\n if (dst != wrappedNativeToken) {\\n int256 price1 = _priceFor(src, wrappedNativeToken);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, wrappedNativeToken);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice it checks if a token is a cToken. If it is, then get the underlying address\\n * @param token address of the token\\n * @return isCToken boolean whether it's a cToken\\n * @return underlying the address of the cToken\\n */\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xcf6280e2d36fdedbca4c0b94e413832f4bb267202de235bfc1cf6fda26c780ec\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { PriceAggFacet } from \\\"./PriceAggFacet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\n/**\\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\\n */\\nlibrary PriceAggLib {\\n /**\\n * @notice It calculates the value of one token amount into another\\n * @param src the source token\\n * @param dst the destination token\\n * @param srcAmount the amount of source token\\n * @return value_ the returned value of src in dst\\n */\\n function valueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) internal view returns (uint256 value_) {\\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\\n }\\n\\n /**\\n * @notice It returns the price of the token pair as given from Compound.\\n * @dev if no compound price is calculated, then it checks Chainlink price Aggregator\\n * @param src the address of the source token\\n * @param dst the address of the desitnation token\\n * @return price_ gets the price of src in dst\\n */\\n function priceFor(address src, address dst)\\n internal\\n view\\n returns (int256 price_)\\n {\\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\\n }\\n}\\n\",\"keccak256\":\"0xff59eee567fa4a7f5cac432e31d918be92834f04614f49572d3984a5b030ac79\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"NFTInterestRate\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getNFTInterestRate() internal view returns (uint16 value_) {\\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0x44294be1af9f913b2ed391a40cd4b646537a4b463b8d5ff1fac8ead3988966c1\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for loans taken out with an NFT.\\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\\n */\\nbytes32 constant NFT_INTEREST_RATE = keccak256(\\\"NFTInterestRate\\\");\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xd68a7df42b2bbba6f935d5890b7b37997c1432e25ae113827b8bde87f94fd86f\",\"license\":\"MIT\"},\"contracts/shared/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n /**\\n * @notice Checks if the account should be allowed to mint tokens in the given market\\n * @param cToken The market to verify the mint against\\n * @param minter The account which would get the minted tokens\\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates mint and reverts on rejection. May emit logs.\\n * @param cToken Asset being minted\\n * @param minter The address minting the tokens\\n * @param mintAmount The amount of the underlying asset being minted\\n * @param mintTokens The number of tokens being minted\\n */\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to redeem tokens in the given market\\n * @param cToken The market to verify the redeem against\\n * @param redeemer The account which would redeem the tokens\\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates redeem and reverts on rejection. May emit logs.\\n * @param cToken Asset being redeemed\\n * @param redeemer The address redeeming the tokens\\n * @param redeemAmount The amount of the underlying asset being redeemed\\n * @param redeemTokens The number of tokens being redeemed\\n */\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\\n * @param cToken The market to verify the borrow against\\n * @param borrower The account which would borrow the asset\\n * @param borrowAmount The amount of underlying the account would borrow\\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates borrow and reverts on rejection. May emit logs.\\n * @param cToken Asset whose underlying is being borrowed\\n * @param borrower The address borrowing the underlying\\n * @param borrowAmount The amount of the underlying asset requested to borrow\\n */\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to repay a borrow in the given market\\n * @param cToken The market to verify the repay against\\n * @param payer The account which would repay the asset\\n * @param borrower The account which would borrowed the asset\\n * @param repayAmount The amount of the underlying asset the account would repay\\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\\n * @param cToken Asset being repaid\\n * @param payer The address repaying the borrow\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param borrowerIndex the index of the borrower\\n */\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n /**\\n * @notice Checks if the liquidation should be allowed to occur\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n */\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the seizing of assets should be allowed to occur\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates seize and reverts on rejection. May emit logs.\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to transfer tokens in the given market\\n * @param cToken The market to verify the transfer against\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates transfer and reverts on rejection. May emit logs.\\n * @param cToken Asset being transferred\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n */\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in all markets\\n * @param holder The address to claim COMP for\\n */\\n function claimComp(address holder) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in the specified markets\\n * @param holder The address to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n */\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n /**\\n * @notice Claim all comp accrued by the holders\\n * @param holders The addresses to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n * @param borrowers Whether or not to claim COMP earned by borrowing\\n * @param suppliers Whether or not to claim COMP earned by supplying\\n */\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n /**\\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\\n * @param cTokenBorrowed The address of the borrowed cToken\\n * @param cTokenCollateral The address of the collateral cToken\\n * @param repayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\\n */\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n /**\\n * @notice Return the address of the COMP token\\n * @return The address of COMP\\n */\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x38a824a4a21ce9370fa581a616d1bb9d311f27d8982a6b96ebeba90bd5fd0adb\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n\\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x208769886b3db8f03ef1fa26f1caee189038dfc744b9a499402fc4e4c0090c38\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @dev CETH is the only Compound token that does not support the {underlying} function.\\n * @param cToken address of the compound token\\n * @return address of the underlying cToken\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x99206384c27b0e68b1ec7b82260f6a47965f611875c018bc076ff8a688a6c6d7\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n /**\\n * @notice it returns the absolute number of a specified parameter\\n * @param self the number to be returned in it's absolute\\n * @return the absolute number\\n */\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0x4f750cde25d4b1db919abf3192d58ed6aef617d03637e1e9e2dc31b70dcc32a3\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n address wrappedNativeToken;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4504c5c460972a25cd1f0e6eb1d8dd84a668be75a3aeb89a47a49c2327c12923\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\n// DEPRECATED\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\nstruct LoanRequest {\\n LoanUserRequest request;\\n LoanConsensusResponse[] responses;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanUserRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanConsensusResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) _loanTerms; // DEPRECATED: DO NOT REMOVE\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb7e05aeec806b5621512def93f4a389b4ef88c50ef9fe7115a33f57db2f2304b\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "kind": "dev", + "methods": { + "getBorrowerLoans(address)": { + "params": { + "borrower": "The account to get loan IDs for." + }, + "returns": { + "loanIDs": "The IDs for loans created by the {borrower}" + } + }, + "getCollateralNeededInfo(uint256)": { + "params": { + "loanID": "the identifier of the loan ID to retrieve collateral from" + }, + "returns": { + "escrowLoanValue": "total collateral needed in loan value", + "neededInCollateralTokens": "total collateral needed in collateral tokens", + "neededInLendingTokens": "total collateral needed in lending tokens" + } + }, + "getDebtOwed(uint256)": { + "params": { + "loanID": "The loan ID to get the total amount owed." + }, + "returns": { + "_0": "LoanDebt The principal and interest owed amount." + } + }, + "getEscrowTokens(uint256)": { + "params": { + "loanID": "the identifier of the respective escrow's loan" + }, + "returns": { + "tokens_": "the tokens held at the escrow loan" + } + }, + "getInterestOwedFor(uint256,uint256)": { + "params": { + "amountBorrow": "The principal of the loan to take out.", + "loanID": "The loan ID to get the owed interest." + }, + "returns": { + "_0": "uint256 The interest owed." + } + }, + "getLoan(uint256)": { + "params": { + "loanID": "The loan ID to get information for." + }, + "returns": { + "loan_": "The loan data." + } + }, + "getLoanEscrow(uint256)": { + "params": { + "loanID": "the identifier of the respective escrow's loan" + }, + "returns": { + "escrow_": "the typed address of the returned ILoanEscrow" + } + }, + "getLoanEscrowValue(uint256)": { + "params": { + "loanID": "the identifier of the respective escrow's loan" + }, + "returns": { + "_0": "the total value of the loan escrow" + } + }, + "getLoanTerms(uint256)": { + "params": { + "loanID": "The loan ID to get the total amount owed." + }, + "returns": { + "_0": "LoanTerms The terms that the loan weer created with." + } + }, + "getTotalOwed(uint256)": { + "params": { + "loanID": "The loan ID to get the total amount owed." + }, + "returns": { + "_0": "uint256 The total owed amount." + } + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "getBorrowerLoans(address)": { + "notice": "Returns the loan IDs created by the {borrower} account." + }, + "getCollateralNeededInfo(uint256)": { + "notice": "it returns the collateral needed for a loan" + }, + "getDebtOwed(uint256)": { + "notice": "Returns the debt owed for a specified loan." + }, + "getEscrowTokens(uint256)": { + "notice": "it returns the total escrow tokens held by an escrow" + }, + "getInterestOwedFor(uint256,uint256)": { + "notice": "Returns the amount of interest owed for a given loan and loan amount." + }, + "getLoan(uint256)": { + "notice": "Returns the information about the given {loanID}." + }, + "getLoanEscrow(uint256)": { + "notice": "it returns the typed address of a loan escrow" + }, + "getLoanEscrowValue(uint256)": { + "notice": "it returns the escrow's total value by calculating the value all the escrow tokens" + }, + "getLoanTerms(uint256)": { + "notice": "DEPRECATEDReturns the terms for a specified loan." + }, + "getTotalOwed(uint256)": { + "notice": "Returns the total amount owed for a specified loan." + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/LoansEscrow_V1.json b/deployments/polygon_mumbai/LoansEscrow_V1.json new file mode 100644 index 000000000..ab97a15cb --- /dev/null +++ b/deployments/polygon_mumbai/LoansEscrow_V1.json @@ -0,0 +1,191 @@ +{ + "address": "0xf442C6d5e6545DeC716b6b25Ef2aC420759E5d89", + "abi": [ + { + "inputs": [ + { + "internalType": "address", + "name": "dappAddress", + "type": "address" + }, + { + "internalType": "bytes", + "name": "dappData", + "type": "bytes" + } + ], + "name": "callDapp", + "outputs": [ + { + "internalType": "bytes", + "name": "resData_", + "type": "bytes" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "claimToken", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "address", + "name": "spender", + "type": "address" + } + ], + "name": "setTokenAllowance", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "LoansEscrow_V1", + "transactionHash": "0xb7a99e5a0023218ea2b0fb0d4c25446ba1f51ab94a1d36ca3b9267ea42882c57", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0xf442C6d5e6545DeC716b6b25Ef2aC420759E5d89", + "transactionIndex": 0, + "gasUsed": "480950", + "logsBloom": "0x00000000000000020000000000008000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000800100000000000000000100000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000020000000000000000001000000000000000000000000004000000000000100000001000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0x6e202cfd1cf8f9e539b64639fe3c8046433aa8467ff295be945389d98e4d9326", + "transactionHash": "0xb7a99e5a0023218ea2b0fb0d4c25446ba1f51ab94a1d36ca3b9267ea42882c57", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692413, + "transactionHash": "0xb7a99e5a0023218ea2b0fb0d4c25446ba1f51ab94a1d36ca3b9267ea42882c57", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000c26880a0af2ea0c7e8130e6ec47af756465452e8" + ], + "data": "0x000000000000000000000000000000000000000000000000003342a4f12448000000000000000000000000000000000000000000000000004208e064d57cb4000000000000000000000000000000000000000000000000aea1cbfc1fd57f845700000000000000000000000000000000000000000000000041d59dbfe4586c000000000000000000000000000000000000000000000000aea1ff3ec4c6a3cc57", + "logIndex": 0, + "blockHash": "0x6e202cfd1cf8f9e539b64639fe3c8046433aa8467ff295be945389d98e4d9326" + } + ], + "blockNumber": 15692413, + "cumulativeGasUsed": "480950", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"dappAddress\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"dappData\",\"type\":\"bytes\"}],\"name\":\"callDapp\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"resData_\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"claimToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"init\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"setTokenAllowance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"callDapp(address,bytes)\":{\"params\":{\"dappAddress\":\"address of the target contract address\",\"dappData\":\"encoded abi of the function in our contract we want to call\"},\"returns\":{\"resData_\":\"the called data in\"}},\"claimToken(address,address,uint256)\":{\"details\":\"only the owner (TellerDiamond) can make this call on behalf of their users\",\"params\":{\"amount\":\"uint256 amount of tokens to be claimed\",\"to\":\"address where the tokens should be transferred to\",\"token\":\"address of the respective token contract to claim tokens from\"}},\"setTokenAllowance(address,address)\":{\"params\":{\"spender\":\"address of the respective spender who is approved by the token contract\",\"token\":\"address of the respective ERC20 token to approve for the spender\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"callDapp(address,bytes)\":{\"notice\":\"it calls a dapp like YearnFinance at a target contract address with specified calldata\"},\"claimToken(address,address,uint256)\":{\"notice\":\"it allows user to claim their escrow tokens\"},\"setTokenAllowance(address,address)\":{\"notice\":\"it approves the spender to spend a maximum amount of a respective token from a token address\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/escrow/escrow/LoansEscrow_V1.sol\":\"LoansEscrow_V1\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n /**\\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\\n * @param dappAddress address of the target contract address\\n * @param dappData encoded abi of the function in our contract we want to call\\n * @return the called data in bytes\\n */\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n /**\\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\\n * @param token address of the respective ERC20 token to approve for the spender\\n * @param spender address of the respective spender who is approved by the token contract\\n */\\n function setTokenAllowance(address token, address spender) external;\\n\\n /**\\n * @notice it allows user to claim their escrow tokens\\n * @dev only the owner (TellerDiamond) can make this call on behalf of the users\\n * @param token address of the respective token contract to claim tokens from\\n * @param to address where the tokens should be transferred to\\n * @param amount uint256 amount of tokens to be claimed\\n */\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xaf67fc4454ffaa4d2f7e46fe7101876e8ebdb1a5426c30f87b8e18cc573ac019\",\"license\":\"MIT\"},\"contracts/escrow/escrow/LoansEscrow_V1.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"./ILoansEscrow.sol\\\";\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ICErc20 } from \\\"../../shared/interfaces/ICErc20.sol\\\";\\n\\n// Libraries\\nimport {\\n SafeERC20\\n} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Address } from \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n// Proxy\\nimport {\\n InitializeableBeaconProxy\\n} from \\\"../../shared/proxy/beacon/InitializeableBeaconProxy.sol\\\";\\nimport { IBeacon } from \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\n\\ncontract LoansEscrow_V1 is ILoansEscrow {\\n address public owner;\\n\\n modifier onlyOwner {\\n require(owner == msg.sender, \\\"Teller: loan escrow not owner\\\");\\n _;\\n }\\n\\n function init() external override {\\n require(owner == address(0), \\\"Teller: loan escrow already initialized\\\");\\n owner = msg.sender;\\n }\\n\\n /**\\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\\n * @param dappAddress address of the target contract address\\n * @param dappData encoded abi of the function in our contract we want to call\\n * @return resData_ the called data in\\n */\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n override\\n onlyOwner\\n returns (bytes memory resData_)\\n {\\n resData_ = Address.functionCall(\\n dappAddress,\\n dappData,\\n \\\"Teller: dapp call failed\\\"\\n );\\n }\\n\\n /**\\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\\n * @param token address of the respective ERC20 token to approve for the spender\\n * @param spender address of the respective spender who is approved by the token contract\\n */\\n function setTokenAllowance(address token, address spender)\\n external\\n override\\n onlyOwner\\n {\\n IERC20(token).approve(spender, type(uint256).max);\\n }\\n\\n /**\\n * @notice it allows user to claim their escrow tokens\\n * @dev only the owner (TellerDiamond) can make this call on behalf of their users\\n * @param token address of the respective token contract to claim tokens from\\n * @param to address where the tokens should be transferred to\\n * @param amount uint256 amount of tokens to be claimed\\n */\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external override onlyOwner {\\n SafeERC20.safeTransfer(IERC20(token), to, amount);\\n }\\n}\\n\",\"keccak256\":\"0xf996bf433786ec3b6420dca25e574a78974006f1b0b984f4eddc5af34fceda69\",\"license\":\"MIT\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n /**\\n * @notice Checks if the account should be allowed to mint tokens in the given market\\n * @param cToken The market to verify the mint against\\n * @param minter The account which would get the minted tokens\\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates mint and reverts on rejection. May emit logs.\\n * @param cToken Asset being minted\\n * @param minter The address minting the tokens\\n * @param mintAmount The amount of the underlying asset being minted\\n * @param mintTokens The number of tokens being minted\\n */\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to redeem tokens in the given market\\n * @param cToken The market to verify the redeem against\\n * @param redeemer The account which would redeem the tokens\\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates redeem and reverts on rejection. May emit logs.\\n * @param cToken Asset being redeemed\\n * @param redeemer The address redeeming the tokens\\n * @param redeemAmount The amount of the underlying asset being redeemed\\n * @param redeemTokens The number of tokens being redeemed\\n */\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\\n * @param cToken The market to verify the borrow against\\n * @param borrower The account which would borrow the asset\\n * @param borrowAmount The amount of underlying the account would borrow\\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates borrow and reverts on rejection. May emit logs.\\n * @param cToken Asset whose underlying is being borrowed\\n * @param borrower The address borrowing the underlying\\n * @param borrowAmount The amount of the underlying asset requested to borrow\\n */\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to repay a borrow in the given market\\n * @param cToken The market to verify the repay against\\n * @param payer The account which would repay the asset\\n * @param borrower The account which would borrowed the asset\\n * @param repayAmount The amount of the underlying asset the account would repay\\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\\n * @param cToken Asset being repaid\\n * @param payer The address repaying the borrow\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param borrowerIndex the index of the borrower\\n */\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n /**\\n * @notice Checks if the liquidation should be allowed to occur\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n */\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the seizing of assets should be allowed to occur\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates seize and reverts on rejection. May emit logs.\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to transfer tokens in the given market\\n * @param cToken The market to verify the transfer against\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates transfer and reverts on rejection. May emit logs.\\n * @param cToken Asset being transferred\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n */\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in all markets\\n * @param holder The address to claim COMP for\\n */\\n function claimComp(address holder) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in the specified markets\\n * @param holder The address to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n */\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n /**\\n * @notice Claim all comp accrued by the holders\\n * @param holders The addresses to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n * @param borrowers Whether or not to claim COMP earned by borrowing\\n * @param suppliers Whether or not to claim COMP earned by supplying\\n */\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n /**\\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\\n * @param cTokenBorrowed The address of the borrowed cToken\\n * @param cTokenCollateral The address of the collateral cToken\\n * @param repayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\\n */\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n /**\\n * @notice Return the address of the COMP token\\n * @return The address of COMP\\n */\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x38a824a4a21ce9370fa581a616d1bb9d311f27d8982a6b96ebeba90bd5fd0adb\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "kind": "dev", + "methods": { + "callDapp(address,bytes)": { + "params": { + "dappAddress": "address of the target contract address", + "dappData": "encoded abi of the function in our contract we want to call" + }, + "returns": { + "resData_": "the called data in" + } + }, + "claimToken(address,address,uint256)": { + "details": "only the owner (TellerDiamond) can make this call on behalf of their users", + "params": { + "amount": "uint256 amount of tokens to be claimed", + "to": "address where the tokens should be transferred to", + "token": "address of the respective token contract to claim tokens from" + } + }, + "setTokenAllowance(address,address)": { + "params": { + "spender": "address of the respective spender who is approved by the token contract", + "token": "address of the respective ERC20 token to approve for the spender" + } + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "callDapp(address,bytes)": { + "notice": "it calls a dapp like YearnFinance at a target contract address with specified calldata" + }, + "claimToken(address,address,uint256)": { + "notice": "it allows user to claim their escrow tokens" + }, + "setTokenAllowance(address,address)": { + "notice": "it approves the spender to spend a maximum amount of a respective token from a token address" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [ + { + "astId": 10741, + "contract": "contracts/escrow/escrow/LoansEscrow_V1.sol:LoansEscrow_V1", + "label": "owner", + "offset": 0, + "slot": "0", + "type": "t_address" + } + ], + "types": { + "t_address": { + "encoding": "inplace", + "label": "address", + "numberOfBytes": "20" + } + } + } +} diff --git a/deployments/polygon_mumbai/NFTFacet.json b/deployments/polygon_mumbai/NFTFacet.json new file mode 100644 index 000000000..880768535 --- /dev/null +++ b/deployments/polygon_mumbai/NFTFacet.json @@ -0,0 +1,137 @@ +{ + "address": "0xf98880D3d29c0337fb457d2adc1443849e4C0d59", + "abi": [ + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "NFTFacet", + "transactionHash": "0xf500fac0f565ad9da4c860f00545226ac1bd28cf13401065afc841366599196e", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0xf98880D3d29c0337fb457d2adc1443849e4C0d59", + "transactionIndex": 0, + "gasUsed": "431850", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000002000000000000000000000000000000000000000000000000000800100000000000000040100000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000040000000004000000000000100000001000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0x37c8a310348cf76d02beae285dddf78859b5315670f1121c21c5835240aedc60", + "transactionHash": "0xf500fac0f565ad9da4c860f00545226ac1bd28cf13401065afc841366599196e", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692485, + "transactionHash": "0xf500fac0f565ad9da4c860f00545226ac1bd28cf13401065afc841366599196e", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000c275dc8be39f50d12f66b6a63629c39da5bae5bd" + ], + "data": "0x000000000000000000000000000000000000000000000000002e06f5676338000000000000000000000000000000000000000000000000003b006964d34664000000000000000000000000000000000000000000000000b416e8b4ada65e2dd50000000000000000000000000000000000000000000000003ad2626f6be32c000000000000000000000000000000000000000000000000b41716bba30dc165d5", + "logIndex": 0, + "blockHash": "0x37c8a310348cf76d02beae285dddf78859b5315670f1121c21c5835240aedc60" + } + ], + "blockNumber": 15692485, + "cumulativeGasUsed": "431850", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLoanNFTs\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"loanNFTs\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"nftOwner\",\"type\":\"address\"}],\"name\":\"getStakedNFTs\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"staked_\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256[]\",\"name\":\"nftIDs\",\"type\":\"uint256[]\"}],\"name\":\"stakeNFTs\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"getLoanNFTs(uint256)\":{\"params\":{\"loanID\":\"the identifier of the respective loan to get the loan NFTs from\"},\"returns\":{\"loanNFTs\":\"the loan NFTs mapped to a loan ID\"}},\"getStakedNFTs(address)\":{\"returns\":{\"staked_\":\"the returned staked NFTs mapped to an owner's address\"}},\"stakeNFTs(uint256[])\":{\"params\":{\"nftIDs\":\"IDs of Teller NFTs to stake.\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"getLoanNFTs(uint256)\":{\"notice\":\"it returns the NFTs mapped to a loan\"},\"getStakedNFTs(address)\":{\"notice\":\"it gets the staked NFTs mapped to an owner's address\"},\"stakeNFTs(uint256[])\":{\"notice\":\"Transfers multiple Teller NFTs to Diamond and applies user stake.\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/nft/NFTFacet.sol\":\"NFTFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Trees proofs.\\n *\\n * The proofs can be generated using the JavaScript library\\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\\n *\\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n bytes32 computedHash = leaf;\\n\\n for (uint256 i = 0; i < proof.length; i++) {\\n bytes32 proofElement = proof[i];\\n\\n if (computedHash <= proofElement) {\\n // Hash(current computed hash + current element of the proof)\\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\\n } else {\\n // Hash(current element of the proof + current computed hash)\\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\\n }\\n }\\n\\n // Check if the computed hash (root) is equal to the provided root\\n return computedHash == root;\\n }\\n}\\n\",\"keccak256\":\"0xeee34bfb413657b6cd6c8e1e15c2080ba5ebaac479578515922804346fb63f7c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/nft/IStakeableNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IStakeableNFT {\\n function tokenBaseLoanSize(uint256 tokenId) external view returns (uint256);\\n\\n function tokenURIHash(uint256 tokenId)\\n external\\n view\\n returns (string memory);\\n\\n function tokenContributionAsset(uint256 tokenId)\\n external\\n view\\n returns (address);\\n\\n function tokenContributionSize(uint256 tokenId)\\n external\\n view\\n returns (uint256);\\n\\n function tokenContributionMultiplier(uint256 tokenId)\\n external\\n view\\n returns (uint8);\\n}\\n\",\"keccak256\":\"0xfbf44350ad91a54de26f39195d714580d7dade556ea4c7991a51eef5aa839105\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/NFTFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\nimport { RolesMods } from \\\"../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../shared/roles.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport { NFTLib } from \\\"./libraries/NFTLib.sol\\\";\\nimport { RolesLib } from \\\"../contexts2/access-control/roles/RolesLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\ncontract NFTFacet is RolesMods {\\n /**\\n * @notice it gets the staked NFTs mapped to an owner's address\\n * @return staked_ the returned staked NFTs mapped to an owner's address\\n */\\n function getStakedNFTs(address nftOwner)\\n public\\n view\\n returns (uint256[] memory staked_)\\n {\\n staked_ = NFTLib.stakedNFTs(nftOwner);\\n }\\n\\n /**\\n * @notice it returns the NFTs mapped to a loan\\n * @param loanID the identifier of the respective loan to get the loan NFTs from\\n * @return loanNFTs the loan NFTs mapped to a loan ID\\n */\\n function getLoanNFTs(uint256 loanID)\\n external\\n view\\n returns (uint256[] memory loanNFTs)\\n {\\n EnumerableSet.UintSet storage nfts = NFTLib.s().loanNFTs[loanID];\\n loanNFTs = new uint256[](EnumerableSet.length(nfts));\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n loanNFTs[i] = EnumerableSet.at(nfts, i);\\n }\\n }\\n\\n /**\\n * @notice Transfers multiple Teller NFTs to Diamond and applies user stake.\\n * @param nftIDs IDs of Teller NFTs to stake.\\n */\\n function stakeNFTs(uint256[] calldata nftIDs) external {\\n for (uint256 i; i < nftIDs.length; i++) {\\n // Stake NFT and transfer into diamond\\n NFTLib.stake(nftIDs[i], msg.sender);\\n }\\n // Give the caller authorization to protocol\\n RolesLib.grantRole(AUTHORIZED, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0xedb9de48f63b5e43484554602d74c90d0a55de6c04fbc945af7b75d83e511308\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x417b75f5d92be67993efc54db7d453be5b5058a9a54d8916380e0281d3299526\",\"license\":\"MIT\"},\"contracts/nft/TellerNFTDictionary.sol\":{\"content\":\"/**\\n * @notice TellerNFTDictionary Version 1.02\\n *\\n * @notice This contract is used to gather data for TellerV1 NFTs more efficiently.\\n * @notice This contract has data which must be continuously synchronized with the TellerV1 NFT data\\n *\\n * @author develop@teller.finance\\n */\\n\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Interfaces\\nimport \\\"./IStakeableNFT.sol\\\";\\n\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFTDictionary is IStakeableNFT, AccessControlUpgradeable {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n mapping(uint256 => uint256) public baseLoanSizes;\\n mapping(uint256 => string[]) public hashes;\\n mapping(uint256 => address) public contributionAssets;\\n mapping(uint256 => uint256) public contributionSizes;\\n mapping(uint256 => uint8) public contributionMultipliers;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n\\n /* State Variables */\\n\\n mapping(uint256 => uint256) public _tokenTierMappingCompressed;\\n bool public _tokenTierMappingCompressedSet;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFTDictionary: not admin\\\");\\n _;\\n }\\n\\n function initialize(address initialAdmin) public {\\n _setupRole(ADMIN, initialAdmin);\\n _setRoleAdmin(ADMIN, ADMIN);\\n\\n __AccessControl_init();\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTierIndex(uint256 tokenId)\\n public\\n view\\n returns (uint8 index_)\\n {\\n //32 * 8 = 256 - each uint256 holds the data of 32 tokens . 8 bits each.\\n\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 compressedRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n //use 31 instead of 32 to account for the '0x' in the start.\\n //the '31 -' reverses our bytes order which is necessary\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint8 tierIndex = uint8((compressedRegister >> offset));\\n\\n return tierIndex;\\n }\\n\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory)\\n {\\n return hashes[tierIndex];\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTier(uint256 index, Tier memory newTier)\\n external\\n onlyAdmin\\n returns (bool)\\n {\\n baseLoanSizes[index] = newTier.baseLoanSize;\\n hashes[index] = newTier.hashes;\\n contributionAssets[index] = newTier.contributionAsset;\\n contributionSizes[index] = newTier.contributionSize;\\n contributionMultipliers[index] = newTier.contributionMultiplier;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param tiersMapping Information about the new tiers to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setAllTokenTierMappings(uint256[] memory tiersMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n require(\\n !_tokenTierMappingCompressedSet,\\n \\\"TellerNFTDictionary: token tier mapping already set\\\"\\n );\\n for (uint256 i = 0; i < tiersMapping.length; i++) {\\n _tokenTierMappingCompressed[i] = tiersMapping[i];\\n }\\n\\n _tokenTierMappingCompressedSet = true;\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param index the mapping row, each holds data for 32 tokens\\n * @param tierMapping Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierMapping(uint256 index, uint256 tierMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n _tokenTierMappingCompressed[index] = tierMapping;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenIds the NFT token Ids for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenIds(\\n uint256[] calldata tokenIds,\\n uint256 tokenTier\\n ) public onlyAdmin returns (bool) {\\n for (uint256 i; i < tokenIds.length; i++) {\\n setTokenTierForTokenId(tokenIds[i], tokenTier);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenId the NFT token Id for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenId(uint256 tokenId, uint256 tokenTier)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 existingRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint256 updateMaskShifted =\\n 0x00000000000000000000000000000000000000000000000000000000000000FF <<\\n offset;\\n\\n uint256 updateMaskShiftedNegated = ~updateMaskShifted;\\n\\n uint256 tokenTierShifted =\\n ((0x0000000000000000000000000000000000000000000000000000000000000000 |\\n tokenTier) << offset);\\n\\n uint256 existingRegisterClearedWithMask =\\n existingRegister & updateMaskShiftedNegated;\\n\\n uint256 updatedRegister =\\n existingRegisterClearedWithMask | tokenTierShifted;\\n\\n _tokenTierMappingCompressed[mappingIndex] = updatedRegister;\\n\\n return true;\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(IStakeableNFT).interfaceId ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n New methods for the dictionary\\n */\\n\\n /**\\n * @notice It returns Base Loan Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenBaseLoanSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return baseLoanSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Token URI Hash for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenURIHash(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n string[] memory tierImageHashes = hashes[tokenTier];\\n return tierImageHashes[tokenId % (tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice It returns Contribution Asset for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionAsset(uint256 tokenId)\\n public\\n view\\n override\\n returns (address)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionAssets[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Multiplier for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionMultiplier(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint8)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionMultipliers[tokenTier];\\n }\\n}\\n\",\"keccak256\":\"0xf33e3fa1f609fdd2abb3b5fb9c232269d13363a3e4fa5697ea96269e361e74fa\"},\"contracts/nft/libraries/NFTLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../TellerNFT.sol\\\";\\n\\n// Libraries\\nimport {\\n MerkleProof\\n} from \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\nimport { NFTStorageLib, NFTStorage } from \\\"../../storage/nft.sol\\\";\\n\\nlibrary NFTLib {\\n function s() internal pure returns (NFTStorage storage s_) {\\n s_ = NFTStorageLib.store();\\n }\\n\\n function nft() internal view returns (TellerNFT nft_) {\\n nft_ = AppStorageLib.store().nft;\\n }\\n\\n /**s\\n * @notice it transfers the NFT from the sender to the diamond to stake then adds the NFTID to the list of the owner's stakedNFTs\\n * @param nftID the ID of the NFT to stake\\n * @param owner the owner of the NFT who will stake the NFT\\n */\\n function stake(uint256 nftID, address owner) internal {\\n // Transfer to diamond\\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\\n // Add NFT ID to user set\\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\\n }\\n\\n /**\\n * @notice it unstakes the NFT by removing the NFT ID from the list of the user's staked NFTs\\n * @param nftID the ID of the NFT to remove from the list of the user's staked NFTs\\n * @return success_ the boolean value telling us if the user has unsuccessfully unstaked the NFT\\n */\\n function unstake(uint256 nftID) internal returns (bool success_) {\\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\\n }\\n\\n /**\\n * @notice it gets the list of staked NFTs from the owner\\n * @param nftOwner the owner of the staked NFTs to pull from\\n * @return staked_ the array of the staked NFTs owned by the user\\n */\\n function stakedNFTs(address nftOwner)\\n internal\\n view\\n returns (uint256[] memory staked_)\\n {\\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\\n staked_ = new uint256[](EnumerableSet.length(nfts));\\n for (uint256 i; i < staked_.length; i++) {\\n staked_[i] = EnumerableSet.at(nfts, i);\\n }\\n }\\n\\n /**\\n * @notice if the user fails to pay his loan, then we liquidate the all the NFTs associated with the loan\\n * @param loanID the identifier of the loan to liquidate the NFTs from\\n */\\n function liquidateNFT(uint256 loanID) internal {\\n // Check if NFTs are linked\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n NFTLib.nft().transferFrom(\\n address(this),\\n AppStorageLib.store().nftLiquidationController,\\n EnumerableSet.at(nfts, i)\\n );\\n }\\n }\\n\\n /**\\n * @notice it unstakes an NFT and verifies the proof in order to apply the proof to a loan\\n * @param loanID the identifier of the loan\\n * @param nftID the NFT ID to apply to the loan\\n */\\n function applyToLoan(uint256 loanID, uint256 nftID) internal {\\n // NFT must be currently staked\\n // Remove NFT from being staked - returns bool\\n require(unstake(nftID), \\\"Teller: borrower nft not staked\\\");\\n\\n // Apply NFT to loan\\n EnumerableSet.add(s().loanNFTs[loanID], nftID);\\n }\\n\\n /**\\n * @notice it finds the loan's NFTs and adds them back to the owner's list of staked NFTs\\n * @param loanID the identifier of the respective loan to add the NFTs back to the user's staked NFTs\\n * @param owner the owner to add the unstaked NFTs back to the staked pile\\n */\\n function restakeLinked(uint256 loanID, address owner) internal {\\n // Get linked NFT\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n // Restake the NFT\\n EnumerableSet.add(s().stakedNFTs[owner], EnumerableSet.at(nfts, i));\\n }\\n }\\n}\\n\",\"keccak256\":\"0xccbd35c6e8d0130b38f5025ee81c47d55e4fa48c8fcb8bec6f70c21061e0ce61\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"NFTInterestRate\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getNFTInterestRate() internal view returns (uint16 value_) {\\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0x44294be1af9f913b2ed391a40cd4b646537a4b463b8d5ff1fac8ead3988966c1\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for loans taken out with an NFT.\\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\\n */\\nbytes32 constant NFT_INTEREST_RATE = keccak256(\\\"NFTInterestRate\\\");\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xd68a7df42b2bbba6f935d5890b7b37997c1432e25ae113827b8bde87f94fd86f\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n address wrappedNativeToken;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4504c5c460972a25cd1f0e6eb1d8dd84a668be75a3aeb89a47a49c2327c12923\",\"license\":\"MIT\"},\"contracts/storage/nft.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"../nft/TellerNFTDictionary.sol\\\";\\n\\n// Utils\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct NFTStorage {\\n // Maps NFT owner to set of token IDs owned\\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\\n // Maps loanID to NFT IDs indicating NFT being used for the loan\\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\\n // Merkle root used for verifying nft IDs to base loan size\\n TellerNFTDictionary nftDictionary;\\n}\\n\\nbytes32 constant NFT_STORAGE_POS = keccak256(\\\"teller.staking.storage\\\");\\n\\nlibrary NFTStorageLib {\\n function store() internal pure returns (NFTStorage storage s) {\\n bytes32 pos = NFT_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd44f213be3125ea2e2de120c241832f1861be18b3ff2fd4c3baa52ea20b94812\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "0x608060405234801561001057600080fd5b50600436106100415760003560e01c80630f48a482146100465780636f70d2121461005b578063a7baf6fc14610084575b600080fd5b6100596100543660046105b1565b610097565b005b61006e61006936600461058a565b610113565b60405161007b9190610639565b60405180910390f35b61006e610092366004610621565b610124565b60005b818110156100e4576100d28383838181106100c557634e487b7160e01b600052603260045260246000fd5b9050602002013533610200565b806100dc8161067d565b91505061009a565b5061010f7f50e75b23f8ec51bbcb044fe377457e835f3b5ccc7ebf69e80906452015dff607336102a3565b5050565b606061011e82610320565b92915050565b606060006101306103f5565b600084815260019190910160205260409020905061014d8161041e565b67ffffffffffffffff81111561017357634e487b7160e01b600052604160045260246000fd5b60405190808252806020026020018201604052801561019c578160200160208202803683370190505b50915060005b6101ab8261041e565b8110156101f9576101bc8282610428565b8382815181106101dc57634e487b7160e01b600052603260045260246000fd5b6020908102919091010152806101f18161067d565b9150506101a2565b5050919050565b6006546001600160a01b03166040516323b872dd60e01b8152336004820152306024820152604481018490526001600160a01b0391909116906323b872dd90606401600060405180830381600087803b15801561025c57600080fd5b505af1158015610270573d6000803e3d6000fd5b5050505061029e61027f6103f5565b6001600160a01b0383166000908152602091909152604090208361043b565b505050565b6102ad8282610447565b156102b75761010f565b60016102c161047b565b6000848152602091825260408082206001600160a01b0386168084529352808220805460ff1916941515949094179093559151339285917f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d9190a45050565b6060600061032c6103f5565b6001600160a01b03841660009081526020919091526040902090506103508161041e565b67ffffffffffffffff81111561037657634e487b7160e01b600052604160045260246000fd5b60405190808252806020026020018201604052801561039f578160200160208202803683370190505b50915060005b82518110156101f9576103b88282610428565b8382815181106103d857634e487b7160e01b600052603260045260246000fd5b6020908102919091010152806103ed8161067d565b9150506103a5565b60007f36ec560bcbaf142f58499b90035254e32b3f3563174bc96dc2b2724bafa4c2a75b905090565b600061011e825490565b600061043483836104a3565b9392505050565b6000610434838361053b565b600061045161047b565b6000938452602090815260408085206001600160a01b039490941685529290525090205460ff1690565b60007f7b305b6be5f275f648d05716597c483d754c2a242bd605feba3c64fb85360534610419565b815460009082106105055760405162461bcd60e51b815260206004820152602260248201527f456e756d657261626c655365743a20696e646578206f7574206f6620626f756e604482015261647360f01b606482015260840160405180910390fd5b82600001828154811061052857634e487b7160e01b600052603260045260246000fd5b9060005260206000200154905092915050565b60008181526001830160205260408120546105825750815460018181018455600084815260208082209093018490558454848252828601909352604090209190915561011e565b50600061011e565b60006020828403121561059b578081fd5b81356001600160a01b0381168114610434578182fd5b600080602083850312156105c3578081fd5b823567ffffffffffffffff808211156105da578283fd5b818501915085601f8301126105ed578283fd5b8135818111156105fb578384fd5b8660208260051b850101111561060f578384fd5b60209290920196919550909350505050565b600060208284031215610632578081fd5b5035919050565b6020808252825182820181905260009190848201906040850190845b8181101561067157835183529284019291840191600101610655565b50909695505050505050565b600060001982141561069d57634e487b7160e01b81526011600452602481fd5b506001019056fea2646970667358221220ad1d06847ffc1034e0f67812b7fbe36a1d498582a90c9eb4411d829d1e6c18f364736f6c63430008030033", + "devdoc": { + "kind": "dev", + "methods": { + "getLoanNFTs(uint256)": { + "params": { + "loanID": "the identifier of the respective loan to get the loan NFTs from" + }, + "returns": { + "loanNFTs": "the loan NFTs mapped to a loan ID" + } + }, + "getStakedNFTs(address)": { + "returns": { + "staked_": "the returned staked NFTs mapped to an owner's address" + } + }, + "stakeNFTs(uint256[])": { + "params": { + "nftIDs": "IDs of Teller NFTs to stake." + } + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "getLoanNFTs(uint256)": { + "notice": "it returns the NFTs mapped to a loan" + }, + "getStakedNFTs(address)": { + "notice": "it gets the staked NFTs mapped to an owner's address" + }, + "stakeNFTs(uint256[])": { + "notice": "Transfers multiple Teller NFTs to Diamond and applies user stake." + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/PausableFacet.json b/deployments/polygon_mumbai/PausableFacet.json new file mode 100644 index 000000000..52faa4b74 --- /dev/null +++ b/deployments/polygon_mumbai/PausableFacet.json @@ -0,0 +1,164 @@ +{ + "address": "0xAb5ABA751Fb9ff85b66B107BDC745882aA49B930", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "PausableFacet", + "transactionHash": "0x571de2d623e4c5b0d48d4b00e7d17115195683e7210d01ae08cb0341135456da", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0xAb5ABA751Fb9ff85b66B107BDC745882aA49B930", + "transactionIndex": 1, + "gasUsed": "186367", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000800100000000000000000100000000004000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000080000000000000000000200000000000000000000000000000000000000000000000000000000000004000000000000100000001000000000000000000000000000000100040000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0x647d6a9ca056877562ca87191d25106a5e957b4a90e0b7cb1d37a6eb9fd02934", + "transactionHash": "0x571de2d623e4c5b0d48d4b00e7d17115195683e7210d01ae08cb0341135456da", + "logs": [ + { + "transactionIndex": 1, + "blockNumber": 15692452, + "transactionHash": "0x571de2d623e4c5b0d48d4b00e7d17115195683e7210d01ae08cb0341135456da", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000be188d6641e8b680743a4815dfa0f6208038960f" + ], + "data": "0x0000000000000000000000000000000000000000000000000013dcfe74fc54000000000000000000000000000000000000000000000000003eee9e66fe5c900000000000000000000000000000000000000000000000007e597c8e57d32311500000000000000000000000000000000000000000000000003edac16889603c0000000000000000000000000000000000000000000000007e59906b56481f6550", + "logIndex": 2, + "blockHash": "0x647d6a9ca056877562ca87191d25106a5e957b4a90e0b7cb1d37a6eb9fd02934" + } + ], + "blockNumber": 15692452, + "cumulativeGasUsed": "340013", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"id\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"Paused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"id\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"UnPaused\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"id\",\"type\":\"bytes32\"}],\"name\":\"isPaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"id\",\"type\":\"bytes32\"},{\"internalType\":\"bool\",\"name\":\"state\",\"type\":\"bool\"}],\"name\":\"pause\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"Paused(bytes32,address)\":{\"details\":\"Emitted when an {id} is paused by {sender}.\"},\"UnPaused(bytes32,address)\":{\"details\":\"Emitted when an {id} is unpaused by {sender}.\"}},\"kind\":\"dev\",\"methods\":{\"isPaused(bytes32)\":{\"details\":\"A blank id (\\\"\\\") is equivalent to the whole protocol. If a specific facet should be paused, pass its encoded id.\",\"params\":{\"id\":\"Encoded id of a facet to {pause}.\"},\"returns\":{\"_0\":\"The state that {id} is in.\"}},\"pause(bytes32,bool)\":{\"details\":\"A blank id (\\\"\\\") is equivalent to the whole protocol. If a specific facet should be paused, pass its encoded id.\",\"params\":{\"id\":\"Encoded id of a facet to {pause}.\",\"state\":\"The new state that {id} should be in. Requirements: - Sender must have the PAUSER role.\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"isPaused(bytes32)\":{\"notice\":\"Checks if an id is paused.\"},\"pause(bytes32,bool)\":{\"notice\":\"Puts an id in the given state.\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/settings/pausable/PausableFacet.sol\":\"PausableFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x417b75f5d92be67993efc54db7d453be5b5058a9a54d8916380e0281d3299526\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { PAUSER } from \\\"../../shared/roles.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\ncontract PausableFacet is RolesMods {\\n /**\\n * @dev Emitted when an {id} is paused by {sender}.\\n */\\n event Paused(bytes32 indexed id, address sender);\\n\\n /**\\n * @dev Emitted when an {id} is unpaused by {sender}.\\n */\\n event UnPaused(bytes32 indexed id, address sender);\\n\\n /**\\n * @notice Puts an id in the given state.\\n * @dev A blank id (\\\"\\\") is equivalent to the whole protocol. If a specific facet should be paused, pass its encoded id.\\n * @param id Encoded id of a facet to {pause}.\\n * @param state The new state that {id} should be in.\\n *\\n * Requirements:\\n * - Sender must have the PAUSER role.\\n */\\n function pause(bytes32 id, bool state)\\n external\\n authorized(PAUSER, msg.sender)\\n {\\n if (isPaused(id) == state) return;\\n AppStorageLib.store().paused[id] = state;\\n if (state) {\\n emit Paused(id, msg.sender);\\n } else {\\n emit UnPaused(id, msg.sender);\\n }\\n }\\n\\n /**\\n * @notice Checks if an id is paused.\\n * @dev A blank id (\\\"\\\") is equivalent to the whole protocol. If a specific facet should be paused, pass its encoded id.\\n * @param id Encoded id of a facet to {pause}.\\n * @return The state that {id} is in.\\n */\\n function isPaused(bytes32 id) public view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n}\\n\",\"keccak256\":\"0x7a87506d63931d9868ae623c427a72ac0c98007bab3cf6ec5b07598972945301\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"NFTInterestRate\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getNFTInterestRate() internal view returns (uint16 value_) {\\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0x44294be1af9f913b2ed391a40cd4b646537a4b463b8d5ff1fac8ead3988966c1\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for loans taken out with an NFT.\\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\\n */\\nbytes32 constant NFT_INTEREST_RATE = keccak256(\\\"NFTInterestRate\\\");\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xd68a7df42b2bbba6f935d5890b7b37997c1432e25ae113827b8bde87f94fd86f\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n address wrappedNativeToken;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4504c5c460972a25cd1f0e6eb1d8dd84a668be75a3aeb89a47a49c2327c12923\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "0x608060405234801561001057600080fd5b50610268806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c8063241b71bb1461003b578063bb14516c14610072575b600080fd5b61005e6100493660046101e7565b60009081526001602052604090205460ff1690565b604051901515815260200160405180910390f35b6100856100803660046101ff565b610087565b005b3360008181527fb32d41810776708843448dcc935e07e988acfd3e00fa4a776d726de0bee64cde60205260409020547f539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c919060ff1661012c5760405162461bcd60e51b815260206004820152601d60248201527f416363657373436f6e74726f6c3a206e6f7420617574686f72697a6564000000604482015260640160405180910390fd5b60008481526001602052604090205460ff161515831515141561014e576101e1565b6000848152600160205260409020805460ff191684158015919091179091556101ab5760405133815284907f3744e75c880ad028c816826c1d28654b9ac6656a7fd918d5057b186e145972849060200160405180910390a26101e1565b60405133815284907f393dbcd8056aa1c43e019ad6037a649932275b1d616f1417a4974d6e7951a9f99060200160405180910390a25b50505050565b6000602082840312156101f8578081fd5b5035919050565b60008060408385031215610211578081fd5b8235915060208301358015158114610227578182fd5b80915050925092905056fea2646970667358221220ea47a50375975cd294e27ef44b7a4a52c75be9fe5bb2df7aeceaed8612b976d064736f6c63430008030033", + "deployedBytecode": "0x608060405234801561001057600080fd5b50600436106100365760003560e01c8063241b71bb1461003b578063bb14516c14610072575b600080fd5b61005e6100493660046101e7565b60009081526001602052604090205460ff1690565b604051901515815260200160405180910390f35b6100856100803660046101ff565b610087565b005b3360008181527fb32d41810776708843448dcc935e07e988acfd3e00fa4a776d726de0bee64cde60205260409020547f539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c919060ff1661012c5760405162461bcd60e51b815260206004820152601d60248201527f416363657373436f6e74726f6c3a206e6f7420617574686f72697a6564000000604482015260640160405180910390fd5b60008481526001602052604090205460ff161515831515141561014e576101e1565b6000848152600160205260409020805460ff191684158015919091179091556101ab5760405133815284907f3744e75c880ad028c816826c1d28654b9ac6656a7fd918d5057b186e145972849060200160405180910390a26101e1565b60405133815284907f393dbcd8056aa1c43e019ad6037a649932275b1d616f1417a4974d6e7951a9f99060200160405180910390a25b50505050565b6000602082840312156101f8578081fd5b5035919050565b60008060408385031215610211578081fd5b8235915060208301358015158114610227578182fd5b80915050925092905056fea2646970667358221220ea47a50375975cd294e27ef44b7a4a52c75be9fe5bb2df7aeceaed8612b976d064736f6c63430008030033", + "devdoc": { + "events": { + "Paused(bytes32,address)": { + "details": "Emitted when an {id} is paused by {sender}." + }, + "UnPaused(bytes32,address)": { + "details": "Emitted when an {id} is unpaused by {sender}." + } + }, + "kind": "dev", + "methods": { + "isPaused(bytes32)": { + "details": "A blank id (\"\") is equivalent to the whole protocol. If a specific facet should be paused, pass its encoded id.", + "params": { + "id": "Encoded id of a facet to {pause}." + }, + "returns": { + "_0": "The state that {id} is in." + } + }, + "pause(bytes32,bool)": { + "details": "A blank id (\"\") is equivalent to the whole protocol. If a specific facet should be paused, pass its encoded id.", + "params": { + "id": "Encoded id of a facet to {pause}.", + "state": "The new state that {id} should be in. Requirements: - Sender must have the PAUSER role." + } + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "isPaused(bytes32)": { + "notice": "Checks if an id is paused." + }, + "pause(bytes32,bool)": { + "notice": "Puts an id in the given state." + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/PlatformSettingsFacet.json b/deployments/polygon_mumbai/PlatformSettingsFacet.json new file mode 100644 index 000000000..5f9e40da4 --- /dev/null +++ b/deployments/polygon_mumbai/PlatformSettingsFacet.json @@ -0,0 +1,369 @@ +{ + "address": "0x23Ba2174906E6668FF841829F923cFAEf2Ee228e", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "PlatformSettingsFacet", + "transactionHash": "0x4ff5caff063a4c19b3dc0d9cc3babc1698071ce7af9a4d046f209357b9401444", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x23Ba2174906E6668FF841829F923cFAEf2Ee228e", + "transactionIndex": 0, + "gasUsed": "507771", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000800100000000000000000100000000004000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000080000000000000000000200000000000000000000000000000000000000000000000000000000000004000000000000100000001000000000000000000000000000000100040000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0xe329919c5ef61bf02f7822193edba10d1de348a775389430cfa5a94909f9fb78", + "transactionHash": "0x4ff5caff063a4c19b3dc0d9cc3babc1698071ce7af9a4d046f209357b9401444", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692442, + "transactionHash": "0x4ff5caff063a4c19b3dc0d9cc3babc1698071ce7af9a4d046f209357b9401444", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000be188d6641e8b680743a4815dfa0f6208038960f" + ], + "data": "0x00000000000000000000000000000000000000000000000000361e737677a4000000000000000000000000000000000000000000000000003f859aca4f827c0000000000000000000000000000000000000000000000007e58d0b7c8fc097d500000000000000000000000000000000000000000000000003f4f7c56d90ad80000000000000000000000000000000000000000000000007e5906d63c72812150", + "logIndex": 0, + "blockHash": "0xe329919c5ef61bf02f7822193edba10d1de348a775389430cfa5a94909f9fb78" + } + ], + "blockNumber": 15692442, + "cumulativeGasUsed": "507771", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"settingName\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldMin\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldMax\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newMin\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newMax\",\"type\":\"uint256\"}],\"name\":\"PlatformSettingBoundariesUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"settingName\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"minValue\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"maxValue\",\"type\":\"uint256\"}],\"name\":\"PlatformSettingCreated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"settingName\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldValue\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newValue\",\"type\":\"uint256\"}],\"name\":\"PlatformSettingUpdated\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"name\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"min\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"max\",\"type\":\"uint256\"}],\"name\":\"createPlatformSetting\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"name\",\"type\":\"bytes32\"}],\"name\":\"getPlatformSetting\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"min\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"max\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"exists\",\"type\":\"bool\"}],\"internalType\":\"struct PlatformSetting\",\"name\":\"setting_\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"name\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"newValue\",\"type\":\"uint256\"}],\"name\":\"updatePlatformSetting\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"oldValue\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"name\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"min\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"max\",\"type\":\"uint256\"}],\"name\":\"updatePlatformSettingBoundaries\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"develop@teller.finance\",\"events\":{\"PlatformSettingBoundariesUpdated(bytes32,address,uint256,uint256,uint256,uint256)\":{\"params\":{\"newMax\":\"New maximum boundary.\",\"newMin\":\"New minimum boundary.\",\"oldMax\":\"Previous minimum boundary.\",\"oldMin\":\"Previous minimum boundary.\",\"sender\":\"address that removed it.\",\"settingName\":\"setting name removed.\"}},\"PlatformSettingCreated(bytes32,address,uint256,uint256,uint256)\":{\"params\":{\"maxValue\":\"Maximum boundary for the new setting.\",\"minValue\":\"Minimum boundary for the new setting.\",\"sender\":\"Address that created it.\",\"settingName\":\"New setting name.\",\"value\":\"Value for the new setting.\"}},\"PlatformSettingUpdated(bytes32,address,uint256,uint256)\":{\"params\":{\"newValue\":\"New value for the setting.\",\"oldValue\":\"Previous value for the setting.\",\"sender\":\"Address that updated it.\",\"settingName\":\"Keccak'ed settings name.\"}}},\"kind\":\"dev\",\"methods\":{\"createPlatformSetting(bytes32,uint256,uint256,uint256)\":{\"params\":{\"max\":\"Maximum value allowed for the setting.\",\"min\":\"Minimum value allowed for the setting.\",\"name\":\"Keccak'ed name for the setting.\",\"value\":\"Initial value for the setting.\"}},\"getPlatformSetting(bytes32)\":{\"params\":{\"name\":\"The keccak'ed name for a setting.\"},\"returns\":{\"setting_\":\"Values for the setting {name}\"}},\"updatePlatformSetting(bytes32,uint256)\":{\"params\":{\"name\":\"Keccak'ed name for the setting.\",\"newValue\":\"the new value to set in the platform setting. Requirements: - New value is equal to the current value. - New value is grater than the max value. - New value is less than the min value\"}},\"updatePlatformSettingBoundaries(bytes32,uint256,uint256)\":{\"params\":{\"max\":\"New maximum boundary for the setting.\",\"min\":\"New minimum boundary for the setting.\",\"name\":\"Keccak'ed name for the setting.\"}}},\"version\":1},\"userdoc\":{\"events\":{\"PlatformSettingBoundariesUpdated(bytes32,address,uint256,uint256,uint256,uint256)\":{\"notice\":\"This event is emitted when a current platform setting is removed.\"},\"PlatformSettingCreated(bytes32,address,uint256,uint256,uint256)\":{\"notice\":\"This event is emitted when a new platform setting is created.\"},\"PlatformSettingUpdated(bytes32,address,uint256,uint256)\":{\"notice\":\"This event is emitted when a platform setting is updated.\"}},\"kind\":\"user\",\"methods\":{\"createPlatformSetting(bytes32,uint256,uint256,uint256)\":{\"notice\":\"It creates a new platform setting given a name, min and max values.\"},\"getPlatformSetting(bytes32)\":{\"notice\":\"Gets the values for a platform setting name.\"},\"updatePlatformSetting(bytes32,uint256)\":{\"notice\":\"It updates a current platform setting.\"},\"updatePlatformSettingBoundaries(bytes32,uint256,uint256)\":{\"notice\":\"Updates the boundary (min & max) values for a platform setting.\"}},\"notice\":\"Utility library of inline functions on the PlatformSetting struct.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/settings/platform/PlatformSettingsFacet.sol\":\"PlatformSettingsFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x417b75f5d92be67993efc54db7d453be5b5058a9a54d8916380e0281d3299526\",\"license\":\"MIT\"},\"contracts/settings/platform/PlatformSettingsFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../shared/roles.sol\\\";\\n\\n// Libraries\\nimport {\\n PlatformSettingsLib,\\n PlatformSetting\\n} from \\\"./libraries/PlatformSettingsLib.sol\\\";\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\ncontract PlatformSettingsFacet is RolesMods {\\n /**\\n * @notice This event is emitted when a new platform setting is created.\\n * @param settingName New setting name.\\n * @param sender Address that created it.\\n * @param value Value for the new setting.\\n * @param minValue Minimum boundary for the new setting.\\n * @param maxValue Maximum boundary for the new setting.\\n */\\n event PlatformSettingCreated(\\n bytes32 indexed settingName,\\n address indexed sender,\\n uint256 value,\\n uint256 minValue,\\n uint256 maxValue\\n );\\n\\n /**\\n * @notice This event is emitted when a platform setting is updated.\\n * @param settingName Keccak'ed settings name.\\n * @param sender Address that updated it.\\n * @param oldValue Previous value for the setting.\\n * @param newValue New value for the setting.\\n */\\n event PlatformSettingUpdated(\\n bytes32 indexed settingName,\\n address indexed sender,\\n uint256 oldValue,\\n uint256 newValue\\n );\\n\\n /**\\n * @notice This event is emitted when a current platform setting is removed.\\n * @param settingName setting name removed.\\n * @param sender address that removed it.\\n * @param oldMin Previous minimum boundary.\\n * @param oldMax Previous minimum boundary.\\n * @param newMin New minimum boundary.\\n * @param newMax New maximum boundary.\\n */\\n event PlatformSettingBoundariesUpdated(\\n bytes32 indexed settingName,\\n address indexed sender,\\n uint256 oldMin,\\n uint256 oldMax,\\n uint256 newMin,\\n uint256 newMax\\n );\\n\\n /**\\n * @notice Gets the values for a platform setting name.\\n * @param name The keccak'ed name for a setting.\\n * @return setting_ Values for the setting {name}\\n */\\n function getPlatformSetting(bytes32 name)\\n external\\n view\\n returns (PlatformSetting memory setting_)\\n {\\n setting_ = PlatformSettingsLib.s(name);\\n }\\n\\n /**\\n * @notice It creates a new platform setting given a name, min and max values.\\n * @param name Keccak'ed name for the setting.\\n * @param value Initial value for the setting.\\n * @param min Minimum value allowed for the setting.\\n * @param max Maximum value allowed for the setting.\\n */\\n function createPlatformSetting(\\n bytes32 name,\\n uint256 value,\\n uint256 min,\\n uint256 max\\n ) external authorized(ADMIN, msg.sender) {\\n require(\\n !PlatformSettingsLib.s(name).exists,\\n \\\"Teller: platform setting already exists\\\"\\n );\\n require(value >= min, \\\"Teller: platform setting value less than min\\\");\\n require(\\n value <= max,\\n \\\"Teller: platform setting value greater than max\\\"\\n );\\n\\n PlatformSettingsLib.s(name).value = value;\\n PlatformSettingsLib.s(name).min = min;\\n PlatformSettingsLib.s(name).max = max;\\n PlatformSettingsLib.s(name).exists = true;\\n\\n emit PlatformSettingCreated(name, msg.sender, value, min, max);\\n }\\n\\n /**\\n * @notice It updates a current platform setting.\\n * @param name Keccak'ed name for the setting.\\n * @param newValue the new value to set in the platform setting.\\n *\\n * Requirements:\\n * - New value is equal to the current value.\\n * - New value is grater than the max value.\\n * - New value is less than the min value\\n */\\n function updatePlatformSetting(bytes32 name, uint256 newValue)\\n external\\n authorized(ADMIN, msg.sender)\\n returns (uint256 oldValue)\\n {\\n require(\\n PlatformSettingsLib.s(name).exists,\\n \\\"Teller: platform setting not exists\\\"\\n );\\n require(\\n PlatformSettingsLib.s(name).value != newValue,\\n \\\"Teller: new platform setting not different\\\"\\n );\\n require(\\n newValue >= PlatformSettingsLib.s(name).min,\\n \\\"Teller: new platform setting less than min\\\"\\n );\\n require(\\n newValue <= PlatformSettingsLib.s(name).max,\\n \\\"Teller: new platform setting greater than max\\\"\\n );\\n\\n oldValue = PlatformSettingsLib.s(name).value;\\n PlatformSettingsLib.s(name).value = newValue;\\n\\n emit PlatformSettingUpdated(name, msg.sender, oldValue, newValue);\\n }\\n\\n /**\\n * @notice Updates the boundary (min & max) values for a platform setting.\\n * @param name Keccak'ed name for the setting.\\n * @param min New minimum boundary for the setting.\\n * @param max New maximum boundary for the setting.\\n */\\n function updatePlatformSettingBoundaries(\\n bytes32 name,\\n uint256 min,\\n uint256 max\\n ) external authorized(ADMIN, msg.sender) {\\n require(\\n PlatformSettingsLib.s(name).exists,\\n \\\"Teller: platform setting not exists\\\"\\n );\\n\\n emit PlatformSettingBoundariesUpdated(\\n name,\\n msg.sender,\\n PlatformSettingsLib.s(name).min,\\n PlatformSettingsLib.s(name).max,\\n min,\\n max\\n );\\n\\n PlatformSettingsLib.s(name).min = min;\\n PlatformSettingsLib.s(name).max = max;\\n }\\n}\\n\",\"keccak256\":\"0xb8b4d08d132a2c7b5abed5acb97928413eccf3d79715f7b54111d17c869951a0\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"NFTInterestRate\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getNFTInterestRate() internal view returns (uint16 value_) {\\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0x44294be1af9f913b2ed391a40cd4b646537a4b463b8d5ff1fac8ead3988966c1\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for loans taken out with an NFT.\\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\\n */\\nbytes32 constant NFT_INTEREST_RATE = keccak256(\\\"NFTInterestRate\\\");\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xd68a7df42b2bbba6f935d5890b7b37997c1432e25ae113827b8bde87f94fd86f\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n address wrappedNativeToken;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4504c5c460972a25cd1f0e6eb1d8dd84a668be75a3aeb89a47a49c2327c12923\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "author": "develop@teller.finance", + "events": { + "PlatformSettingBoundariesUpdated(bytes32,address,uint256,uint256,uint256,uint256)": { + "params": { + "newMax": "New maximum boundary.", + "newMin": "New minimum boundary.", + "oldMax": "Previous minimum boundary.", + "oldMin": "Previous minimum boundary.", + "sender": "address that removed it.", + "settingName": "setting name removed." + } + }, + "PlatformSettingCreated(bytes32,address,uint256,uint256,uint256)": { + "params": { + "maxValue": "Maximum boundary for the new setting.", + "minValue": "Minimum boundary for the new setting.", + "sender": "Address that created it.", + "settingName": "New setting name.", + "value": "Value for the new setting." + } + }, + "PlatformSettingUpdated(bytes32,address,uint256,uint256)": { + "params": { + "newValue": "New value for the setting.", + "oldValue": "Previous value for the setting.", + "sender": "Address that updated it.", + "settingName": "Keccak'ed settings name." + } + } + }, + "kind": "dev", + "methods": { + "createPlatformSetting(bytes32,uint256,uint256,uint256)": { + "params": { + "max": "Maximum value allowed for the setting.", + "min": "Minimum value allowed for the setting.", + "name": "Keccak'ed name for the setting.", + "value": "Initial value for the setting." + } + }, + "getPlatformSetting(bytes32)": { + "params": { + "name": "The keccak'ed name for a setting." + }, + "returns": { + "setting_": "Values for the setting {name}" + } + }, + "updatePlatformSetting(bytes32,uint256)": { + "params": { + "name": "Keccak'ed name for the setting.", + "newValue": "the new value to set in the platform setting. Requirements: - New value is equal to the current value. - New value is grater than the max value. - New value is less than the min value" + } + }, + "updatePlatformSettingBoundaries(bytes32,uint256,uint256)": { + "params": { + "max": "New maximum boundary for the setting.", + "min": "New minimum boundary for the setting.", + "name": "Keccak'ed name for the setting." + } + } + }, + "version": 1 + }, + "userdoc": { + "events": { + "PlatformSettingBoundariesUpdated(bytes32,address,uint256,uint256,uint256,uint256)": { + "notice": "This event is emitted when a current platform setting is removed." + }, + "PlatformSettingCreated(bytes32,address,uint256,uint256,uint256)": { + "notice": "This event is emitted when a new platform setting is created." + }, + "PlatformSettingUpdated(bytes32,address,uint256,uint256)": { + "notice": "This event is emitted when a platform setting is updated." + } + }, + "kind": "user", + "methods": { + "createPlatformSetting(bytes32,uint256,uint256,uint256)": { + "notice": "It creates a new platform setting given a name, min and max values." + }, + "getPlatformSetting(bytes32)": { + "notice": "Gets the values for a platform setting name." + }, + "updatePlatformSetting(bytes32,uint256)": { + "notice": "It updates a current platform setting." + }, + "updatePlatformSettingBoundaries(bytes32,uint256,uint256)": { + "notice": "Updates the boundary (min & max) values for a platform setting." + } + }, + "notice": "Utility library of inline functions on the PlatformSetting struct.", + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/PoolTogetherFacet.json b/deployments/polygon_mumbai/PoolTogetherFacet.json new file mode 100644 index 000000000..76437b318 --- /dev/null +++ b/deployments/polygon_mumbai/PoolTogetherFacet.json @@ -0,0 +1,254 @@ +{ + "address": "0x76F35684665469FB1Bce0F2Abe0F34e3791ee3c9", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "ticketAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokenBalance", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "creditBalanceAfter", + "type": "uint256" + } + ], + "name": "PoolTogetherDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "ticketAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokenBalance", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "creditBalanceAfter", + "type": "uint256" + } + ], + "name": "PoolTogetherWithdrawal", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "poolTogetherDepositTicket", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "poolTogetherWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "poolTogetherWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "PoolTogetherFacet", + "transactionHash": "0x2bfea9f6379ac5518c41eeade5a76b30a1cad9b627cd47499a60274e190696a5", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x76F35684665469FB1Bce0F2Abe0F34e3791ee3c9", + "transactionIndex": 0, + "gasUsed": "1031146", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000002000000000000000000000000000000000000000000000000000800100000000000000040100000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000040000000004000000000000100000001000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0x7ab35d063b79db79c8307e89d8f0427c2a0155b60885c9baeff7efc2ee27d476", + "transactionHash": "0x2bfea9f6379ac5518c41eeade5a76b30a1cad9b627cd47499a60274e190696a5", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692493, + "transactionHash": "0x2bfea9f6379ac5518c41eeade5a76b30a1cad9b627cd47499a60274e190696a5", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000c275dc8be39f50d12f66b6a63629c39da5bae5bd" + ], + "data": "0x000000000000000000000000000000000000000000000000006de6a79b3f38000000000000000000000000000000000000000000000000003a597b935e5360000000000000000000000000000000000000000000000000b417945677a7fa59d500000000000000000000000000000000000000000000000039eb94ebc31428000000000000000000000000000000000000000000000000b418023d1f433991d5", + "logIndex": 0, + "blockHash": "0x7ab35d063b79db79c8307e89d8f0427c2a0155b60885c9baeff7efc2ee27d476" + } + ], + "blockNumber": 15692493, + "cumulativeGasUsed": "1031146", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"ticketAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokenBalance\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"creditBalanceAfter\",\"type\":\"uint256\"}],\"name\":\"PoolTogetherDeposited\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"ticketAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokenBalance\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"creditBalanceAfter\",\"type\":\"uint256\"}],\"name\":\"PoolTogetherWithdrawal\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"poolTogetherDepositTicket\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"poolTogetherWithdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"}],\"name\":\"poolTogetherWithdrawAll\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"PoolTogetherDeposited(address,address,uint256,uint256,uint256)\":{\"params\":{\"amount\":\"amount of tokens deposited.\",\"creditBalanceAfter\":\"pool together credit after depositing.\",\"ticketAddress\":\"pool ticket token address.\",\"tokenAddress\":\"address of the underlying token.\",\"tokenBalance\":\"underlying token balance after depositing.\"}},\"PoolTogetherWithdrawal(address,address,uint256,uint256,uint256)\":{\"params\":{\"amount\":\"amount of tokens to Redeem.\",\"creditBalanceAfter\":\"pool together credit after depositing.\",\"ticketAddress\":\"pool ticket token address.\",\"tokenAddress\":\"address of the underlying token.\",\"tokenBalance\":\"underlying token balance after Redeem.\"}}},\"kind\":\"dev\",\"methods\":{\"poolTogetherDepositTicket(uint256,address,uint256)\":{\"params\":{\"amount\":\"of tokens to deposit.\",\"loanID\":\"id of the loan being used in the dapp\",\"tokenAddress\":\"address of the token.\"}},\"poolTogetherWithdraw(uint256,address,uint256)\":{\"params\":{\"amount\":\"The amount of tokens to withdraw.\",\"loanID\":\"id of the loan being used in the dapp\",\"tokenAddress\":\"address of the token.\"}},\"poolTogetherWithdrawAll(uint256,address)\":{\"params\":{\"loanID\":\"id of the loan being used in the dapp\",\"tokenAddress\":\"address of the token.\"}}},\"version\":1},\"userdoc\":{\"events\":{\"PoolTogetherDeposited(address,address,uint256,uint256,uint256)\":{\"notice\":\"This event is emitted every time Pool Together depositTo is invoked successfully.\"},\"PoolTogetherWithdrawal(address,address,uint256,uint256,uint256)\":{\"notice\":\"This event is emitted every time Pool Together withdrawInstantlyFrom is invoked successfully.\"}},\"kind\":\"user\",\"methods\":{\"poolTogetherDepositTicket(uint256,address,uint256)\":{\"notice\":\"This function deposits the users funds into a Pool Together Prize Pool for a ticket.\"},\"poolTogetherWithdraw(uint256,address,uint256)\":{\"notice\":\"This function withdraws the users funds from a Pool Together Prize Pool.\"},\"poolTogetherWithdrawAll(uint256,address)\":{\"notice\":\"This function withdraws the users funds from a Pool Together Prize Pool.\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/escrow/dapps/PoolTogetherFacet.sol\":\"PoolTogetherFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/dapps/DappMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\n\\nabstract contract DappMods {\\n /**\\n * @notice it checks if the caller to a respective loan escrow is the borrower\\n * @param loanID uint256 of the respective loan escrow\\n */\\n modifier onlyBorrower(uint256 loanID) {\\n require(\\n msg.sender == LibLoans.loan(loanID).borrower,\\n \\\"Teller: dapp not loan borrower\\\"\\n );\\n _;\\n }\\n \\n /**\\n * @notice checks if the respective loan escrow is secure\\n * @param loanID uint256 of the respective loan escrow\\n */\\n modifier onlySecured(uint256 loanID) {\\n require(\\n LibLoans.loan(loanID).collateralRatio >=\\n PlatformSettingsLib.getCollateralBufferValue(),\\n \\\"Teller: dapp loan not secured\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x11be4385bca09e22c5dd9ced04e779302f3cc4f8102742abd0b5de5a6029ac85\",\"license\":\"MIT\"},\"contracts/escrow/dapps/PoolTogetherFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Storage\\nimport { DappMods } from \\\"./DappMods.sol\\\";\\nimport { PausableMods } from \\\"../../settings/pausable/PausableMods.sol\\\";\\nimport { LibDapps } from \\\"./libraries/LibDapps.sol\\\";\\nimport { LibEscrow } from \\\"../libraries/LibEscrow.sol\\\";\\nimport { AssetPPoolLib } from \\\"../../settings/asset/libraries/AssetPPoolLib.sol\\\";\\nimport { PoolTogetherLib } from \\\"./libraries/PoolTogetherLib.sol\\\";\\nimport { PrizePoolInterface } from \\\"./interfaces/PrizePoolInterface.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\ncontract PoolTogetherFacet is PausableMods, DappMods {\\n using SafeERC20 for IERC20;\\n /**\\n * @notice This event is emitted every time Pool Together depositTo is invoked successfully.\\n * @param tokenAddress address of the underlying token.\\n * @param ticketAddress pool ticket token address.\\n * @param amount amount of tokens deposited.\\n * @param tokenBalance underlying token balance after depositing.\\n * @param creditBalanceAfter pool together credit after depositing.\\n */\\n event PoolTogetherDeposited(\\n address indexed tokenAddress,\\n address indexed ticketAddress,\\n uint256 amount,\\n uint256 tokenBalance,\\n uint256 creditBalanceAfter\\n );\\n\\n /**\\n * @notice This event is emitted every time Pool Together withdrawInstantlyFrom is invoked successfully.\\n * @param tokenAddress address of the underlying token.\\n * @param ticketAddress pool ticket token address.\\n * @param amount amount of tokens to Redeem.\\n * @param tokenBalance underlying token balance after Redeem.\\n * @param creditBalanceAfter pool together credit after depositing.\\n */\\n event PoolTogetherWithdrawal(\\n address indexed tokenAddress,\\n address indexed ticketAddress,\\n uint256 amount,\\n uint256 tokenBalance,\\n uint256 creditBalanceAfter\\n );\\n\\n /**\\n * @notice This function deposits the users funds into a Pool Together Prize Pool for a ticket.\\n * @param loanID id of the loan being used in the dapp\\n * @param tokenAddress address of the token.\\n * @param amount of tokens to deposit.\\n */\\n function poolTogetherDepositTicket(\\n uint256 loanID,\\n address tokenAddress,\\n uint256 amount\\n ) public paused(\\\"\\\", false) onlyBorrower(loanID) {\\n require(\\n LibEscrow.balanceOf(loanID, tokenAddress) >= amount,\\n \\\"POOL_INSUFFICIENT_UNDERLYING\\\"\\n );\\n\\n PrizePoolInterface prizePool = AssetPPoolLib.get(tokenAddress);\\n\\n address ticketAddress = PoolTogetherLib.getTicketAddress(tokenAddress);\\n uint256 balanceBefore = LibEscrow.balanceOf(loanID, ticketAddress);\\n\\n // Set token allowance to Prize Pool\\n LibEscrow.e(loanID).setTokenAllowance(tokenAddress, address(prizePool));\\n bytes memory callData = abi.encodeWithSelector(\\n PrizePoolInterface.depositTo.selector,\\n address(LibEscrow.e(loanID)), // Tickets sent to Escrow\\n amount,\\n ticketAddress,\\n address(this) // Referrer is the Teller Diamond\\n );\\n LibDapps.s().loanEscrows[loanID].callDapp(address(prizePool), callData);\\n uint256 balanceAfter = LibEscrow.balanceOf(loanID, ticketAddress);\\n require(balanceAfter > balanceBefore, \\\"DEPOSIT_ERROR\\\");\\n\\n LibEscrow.tokenUpdated(loanID, address(ticketAddress));\\n LibEscrow.tokenUpdated(loanID, tokenAddress);\\n\\n emit PoolTogetherDeposited(\\n tokenAddress,\\n ticketAddress,\\n amount,\\n balanceBefore,\\n balanceAfter\\n );\\n }\\n\\n /**\\n * @notice This function withdraws the users funds from a Pool Together Prize Pool.\\n * @param loanID id of the loan being used in the dapp\\n * @param tokenAddress address of the token.\\n * @param amount The amount of tokens to withdraw.\\n */\\n function poolTogetherWithdraw(\\n uint256 loanID,\\n address tokenAddress,\\n uint256 amount\\n ) public paused(\\\"\\\", false) onlyBorrower(loanID) {\\n PrizePoolInterface prizePool = AssetPPoolLib.get(tokenAddress);\\n\\n address ticketAddress = PoolTogetherLib.getTicketAddress(tokenAddress);\\n uint256 balanceBefore = LibEscrow.balanceOf(loanID, ticketAddress);\\n\\n bytes memory callData = abi.encodeWithSelector(\\n PrizePoolInterface.withdrawInstantlyFrom.selector,\\n address(LibEscrow.e(loanID)),\\n amount,\\n ticketAddress,\\n 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF // max exit fee\\n );\\n LibDapps.s().loanEscrows[loanID].callDapp(address(prizePool), callData);\\n\\n uint256 balanceAfter = LibEscrow.balanceOf(loanID, ticketAddress);\\n require(balanceAfter < balanceBefore, \\\"WITHDRAW_ERROR\\\");\\n\\n LibEscrow.tokenUpdated(loanID, address(ticketAddress));\\n LibEscrow.tokenUpdated(loanID, tokenAddress);\\n\\n emit PoolTogetherWithdrawal(\\n tokenAddress,\\n ticketAddress,\\n amount,\\n balanceBefore,\\n balanceAfter\\n );\\n }\\n\\n /**\\n * @notice This function withdraws the users funds from a Pool Together Prize Pool.\\n * @param loanID id of the loan being used in the dapp\\n * @param tokenAddress address of the token.\\n */\\n function poolTogetherWithdrawAll(uint256 loanID, address tokenAddress)\\n public\\n paused(\\\"\\\", false)\\n onlyBorrower(loanID)\\n {\\n PrizePoolInterface prizePool = AssetPPoolLib.get(tokenAddress);\\n\\n address ticketAddress = PoolTogetherLib.getTicketAddress(tokenAddress);\\n uint256 balanceBefore = LibEscrow.balanceOf(loanID, ticketAddress);\\n\\n bytes memory callData = abi.encodeWithSelector(\\n PrizePoolInterface.withdrawInstantlyFrom.selector,\\n address(LibEscrow.e(loanID)),\\n balanceBefore,\\n ticketAddress,\\n 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF\\n );\\n LibDapps.s().loanEscrows[loanID].callDapp(address(prizePool), callData);\\n\\n uint256 balanceAfter = LibEscrow.balanceOf(loanID, ticketAddress);\\n require(balanceAfter < balanceBefore, \\\"WITHDRAW_ERROR\\\");\\n\\n LibEscrow.tokenUpdated(loanID, address(ticketAddress));\\n LibEscrow.tokenUpdated(loanID, tokenAddress);\\n\\n emit PoolTogetherWithdrawal(\\n tokenAddress,\\n ticketAddress,\\n balanceBefore,\\n LibEscrow.balanceOf(loanID, tokenAddress),\\n balanceAfter\\n );\\n }\\n}\\n\",\"keccak256\":\"0x86812c1731ae3589fd0de08e8f93b705a8df2554e85a099d8b178e15c76c3b38\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/PrizePoolInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/// @title Escrows assets and deposits them into a yield source. Exposes interest to Prize Strategy. Users deposit and withdraw from this contract to participate in Prize Pool.\\n/// @notice Accounting is managed using Controlled Tokens, whose mint and burn functions can only be called by this contract.\\n/// @dev Must be inherited to provide specific yield-bearing asset control, such as Compound cTokens\\ninterface PrizePoolInterface {\\n /// @notice Deposit assets into the Prize Pool in exchange for tokens\\n /// @param to The address receiving the newly minted tokens\\n /// @param amount The amount of assets to deposit\\n /// @param controlledToken The address of the type of token the user is minting\\n /// @param referrer The referrer of the deposit\\n function depositTo(\\n address to,\\n uint256 amount,\\n address controlledToken,\\n address referrer\\n ) external;\\n\\n /// @notice Withdraw assets from the Prize Pool instantly. A fairness fee may be charged for an early exit.\\n /// @param from The address to redeem tokens from.\\n /// @param amount The amount of tokens to redeem for assets.\\n /// @param controlledToken The address of the token to redeem (i.e. ticket or sponsorship)\\n /// @param maximumExitFee The maximum exit fee the caller is willing to pay. This should be pre-calculated by the calculateExitFee() fxn.\\n /// @return The actual exit fee paid\\n function withdrawInstantlyFrom(\\n address from,\\n uint256 amount,\\n address controlledToken,\\n uint256 maximumExitFee\\n ) external returns (uint256);\\n\\n /// @notice Returns the balance that is available to award.\\n /// @dev captureAwardBalance() should be called first\\n /// @return The total amount of assets to be awarded for the current prize\\n function awardBalance() external view returns (uint256);\\n\\n /// @notice Calculates the early exit fee for the given amount\\n /// @param from The user who is withdrawing\\n /// @param controlledToken The type of collateral being withdrawn\\n /// @param amount The amount of collateral to be withdrawn\\n /// @return exitFee The exit fee\\n /// @return burnedCredit The user's credit that was burned\\n function calculateEarlyExitFee(\\n address from,\\n address controlledToken,\\n uint256 amount\\n ) external returns (uint256 exitFee, uint256 burnedCredit);\\n\\n /// @notice Estimates the amount of time it will take for a given amount of funds to accrue the given amount of credit.\\n /// @param _principal The principal amount on which interest is accruing\\n /// @param _interest The amount of interest that must accrue\\n /// @return durationSeconds The duration of time it will take to accrue the given amount of interest, in seconds.\\n function estimateCreditAccrualTime(\\n address _controlledToken,\\n uint256 _principal,\\n uint256 _interest\\n ) external view returns (uint256 durationSeconds);\\n\\n /// @notice Returns the credit balance for a given user. Not that this includes both minted credit and pending credit.\\n /// @param user The user whose credit balance should be returned\\n /// @return The balance of the users credit\\n function balanceOfCredit(address user, address controlledToken)\\n external\\n returns (uint256);\\n\\n /// @notice Returns the credit rate of a controlled token\\n /// @param controlledToken The controlled token to retrieve the credit rates for\\n /// @return creditLimitMantissa The credit limit fraction. This number is used to calculate both the credit limit and early exit fee.\\n /// @return creditRateMantissa The credit rate. This is the amount of tokens that accrue per second.\\n function creditPlanOf(address controlledToken)\\n external\\n view\\n returns (uint128 creditLimitMantissa, uint128 creditRateMantissa);\\n\\n /// @dev Returns the address of the underlying ERC20 asset\\n /// @return The address of the asset\\n function token() external view returns (address);\\n\\n /// @notice An array of the Tokens controlled by the Prize Pool (ie. Tickets, Sponsorship)\\n /// @return An array of controlled token addresses\\n function tokens() external view returns (address[] memory);\\n\\n /// @notice The total of all controlled tokens and timelock.\\n /// @return The current total of all tokens and timelock.\\n function accountedBalance() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x050cea53e1d5563980c735230712fc81b1f31fc476f9cbd31dde6ce1a0bb3725\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../../../shared/interfaces/IAToken.sol\\\";\\nimport {\\n IAaveLendingPool\\n} from \\\"../../../shared/interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../../../shared/interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xd05e3E715d945B59290df0ae8eF85c1BdB684744 // Polygon mainnet\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x4c18d46f924a3a24d596971d39857477b618dad13dee55decc271bdccf915ee5\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/PoolTogetherLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport {\\n AssetPPoolLib\\n} from \\\"../../../settings/asset/libraries/AssetPPoolLib.sol\\\";\\n\\nlibrary PoolTogetherLib {\\n /**\\n * @notice Grabs the controlled ticket token address for the prize pool\\n * @notice The pool underlying address must match the supplied token address.\\n * @param tokenAddress The token address to get the cToken for.\\n * @return The address of the ticket token contract.\\n */\\n function getTicketAddress(address tokenAddress)\\n internal\\n view\\n returns (address)\\n {\\n return AssetPPoolLib.get(tokenAddress).tokens()[1];\\n }\\n}\\n\",\"keccak256\":\"0xd0e20f760a61505104cd45ea861407246d1ee13aea427e74528eff78f8428668\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n /**\\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\\n * @param dappAddress address of the target contract address\\n * @param dappData encoded abi of the function in our contract we want to call\\n * @return the called data in bytes\\n */\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n /**\\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\\n * @param token address of the respective ERC20 token to approve for the spender\\n * @param spender address of the respective spender who is approved by the token contract\\n */\\n function setTokenAllowance(address token, address spender) external;\\n\\n /**\\n * @notice it allows user to claim their escrow tokens\\n * @dev only the owner (TellerDiamond) can make this call on behalf of the users\\n * @param token address of the respective token contract to claim tokens from\\n * @param to address where the tokens should be transferred to\\n * @param amount uint256 amount of tokens to be claimed\\n */\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xaf67fc4454ffaa4d2f7e46fe7101876e8ebdb1a5426c30f87b8e18cc573ac019\",\"license\":\"MIT\"},\"contracts/escrow/libraries/LibEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibDapps } from \\\"../dapps/libraries/LibDapps.sol\\\";\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibEscrow {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\\n e_ = s().loanEscrows[loanID];\\n }\\n\\n /**\\n * @notice It returns a list of tokens owned by a loan escrow\\n * @param loanID uint256 index used to return our token list\\n * @return t_ which is a list of tokens \\n */\\n function getEscrowTokens(uint256 loanID)\\n internal\\n view\\n returns (EnumerableSet.AddressSet storage t_)\\n {\\n t_ = s().escrowTokens[loanID];\\n }\\n\\n /**\\n * @notice It returns the balance of a respective token in a loan escrow\\n * @param loanID uint256 index used to point to our loan escrow\\n * @param token address of respective token to give us the balance of in our loan escrow\\n * @return uint256 balance of respective token returned in an escrow loan\\n */\\n function balanceOf(uint256 loanID, address token)\\n internal\\n view\\n returns (uint256)\\n {\\n return IERC20(token).balanceOf(address(e(loanID)));\\n }\\n\\n /**\\n * @notice Adds or removes tokens held by the Escrow contract\\n * @param loanID The loan ID to update the token list for\\n * @param tokenAddress The token address to be added or removed\\n */\\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\\n // Skip if is lending token\\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\\n\\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\\n if (balanceOf(loanID, tokenAddress) > 0) {\\n if (!contains) {\\n EnumerableSet.add(tokens, tokenAddress);\\n }\\n } else if (contains) {\\n EnumerableSet.remove(tokens, tokenAddress);\\n }\\n }\\n\\n /**\\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\\n * @param loanID The loan ID to calculate value for\\n * @return value_ Escrow total value denoted in the lending token.\\n */\\n function calculateTotalValue(uint256 loanID)\\n internal\\n view\\n returns (uint256 value_)\\n {\\n address lendingToken = LibLoans.loan(loanID).lendingToken;\\n value_ += balanceOf(loanID, lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\\n if (EnumerableSet.length(tokens) > 0) {\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n uint256 tokenBal =\\n balanceOf(loanID, EnumerableSet.at(tokens, i));\\n value_ += PriceAggLib.valueFor(\\n EnumerableSet.at(tokens, i),\\n lendingToken,\\n tokenBal\\n );\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x17a7c6b11d6f280948e320525d1e131b89c23f80216918aa070df437a851d915\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when a user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when a user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n * @return ERC20 token\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n * @return balance_ the balance of the account\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice It calculates the total supply of the underlying asset.\\n * @return totalSupply_ the total supply denoted in the underlying asset.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given market.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n \\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfill the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n * @return mintAmount_ the amount minted of the specified token\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n * @return address of the strategy contract\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n * @param state boolean value that resembles the platform's state\\n */\\n function restrict(bool state) external virtual;\\n\\n /**\\n * @notice it initializes the Teller Token\\n * @param admin address of the admin to the respective Teller Token\\n * @param underlying address of the ERC20 token\\n */\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xf30ac4ef491851477ff9a3dd04974ebe74b529c37a3ef4e05798c3f734ceeb3d\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n /**\\n * @notice it initializes an escrow\\n * @param tokenAddress the address of the collateral token to be stored\\n * @param isWETH check if it's wrapped Ethereum\\n */\\n function init(address tokenAddress, bool isWETH) external;\\n\\n /**\\n * @notice it deposits an amount of the respective collateral token into the escrow\\n * @param loanID the ID of the loan\\n * @param amount the amount of collateral tokens to be deposited\\n */\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n /**\\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\\n * @dev only the TellerDiamond can make this call on behalf of the borrower\\n * @param loanID identifier of the loan\\n * @param amount number of collateral tokens to send\\n * @param receiver payable address to transfer money to\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n /**\\n * @notice it returns the supply of the respective loan\\n * @param loanID the respective loan ID\\n * @return supply_ the amount in collateral of the respective loan\\n */\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n /**\\n * @notice it returns the total supply of the collateral token held by the contract\\n * @return supply_ the total amount of collateral\\n */\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x900fed2311f919ba1451a6583ddbf9f3bc8afa8f5189500fff51f0c049258ed3\",\"license\":\"MIT\"},\"contracts/market/libraries/LibLoans.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibEscrow } from \\\"../../escrow/libraries/LibEscrow.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus,\\n LoanDebt,\\n LoanTerms\\n} from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibLoans {\\n using NumbersLib for int256;\\n using NumbersLib for uint256;\\n\\n bytes32 internal constant ID = keccak256(\\\"LOANS\\\");\\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n * @notice it returns the loan\\n * @param loanID the ID of the respective loan\\n * @return l_ the loan\\n */\\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\\n l_ = s().loans[loanID];\\n }\\n\\n /**\\n * @notice it returns the loan debt from a respective loan\\n * @param loanID the ID of the respective loan\\n * @return d_ the loan debt from a respective loan\\n */\\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\\n d_ = s().loanDebt[loanID];\\n }\\n\\n // DEPRECATED\\n function terms(uint256 loanID)\\n internal\\n view\\n returns (LoanTerms storage t_)\\n {\\n t_ = s()._loanTerms[loanID];\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return owed_ uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID)\\n internal\\n view\\n returns (uint256 owed_)\\n {\\n if (loan(loanID).status == LoanStatus.Active) {\\n owed_ = debt(loanID).principalOwed + (debt(loanID).interestOwed);\\n }\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n internal\\n view\\n returns (uint256)\\n {\\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\\n }\\n\\n function getCollateralNeeded(uint256 loanID)\\n internal\\n view\\n returns (uint256 _needed)\\n {\\n (, _needed, ) = getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the total collateral needed in lending tokens, in collateral tokens and in escrowed loan values\\n * @param loanID the loanID to get the total collateral needed\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n internal\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\\n loanID\\n );\\n\\n // check if needed lending tokens is zero. if true, then needed collateral tokens is zero. else,\\n if (neededInLendingTokens == 0) {\\n neededInCollateralTokens = 0;\\n } else {\\n neededInCollateralTokens = PriceAggLib.valueFor(\\n loan(loanID).lendingToken,\\n loan(loanID).collateralToken,\\n neededInLendingTokens\\n );\\n }\\n }\\n\\n /**\\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\\n * @param loanID The loan ID to get needed collateral info for.\\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\\n */\\n function getCollateralNeededInTokens(uint256 loanID)\\n internal\\n view\\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\\n {\\n if (loan(loanID).collateralRatio == 0) {\\n return (0, 0);\\n }\\n\\n /*\\n The collateral to principal owed ratio is the sum of:\\n * collateral buffer percent\\n * loan interest rate\\n * liquidation reward percent\\n * X factor of additional collateral\\n */\\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n neededInLendingTokens = loan(loanID).borrowedAmount.percent(\\n loan(loanID).collateralRatio\\n );\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n uint16 requiredRatio =\\n loan(loanID).collateralRatio -\\n getInterestRatio(loanID) -\\n uint16(PlatformSettingsLib.getCollateralBufferValue());\\n\\n neededInLendingTokens =\\n debt(loanID).principalOwed +\\n debt(loanID).interestOwed;\\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\\n if (\\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\\n ) {\\n neededInLendingTokens -= escrowLoanValue;\\n }\\n neededInLendingTokens = neededInLendingTokens.percent(\\n requiredRatio\\n );\\n }\\n }\\n\\n /**\\n * @notice check if a loan can go to end of auction with a collateral ratio\\n * @return bool checking if collateralRatio is >= the over collateralized buffer value\\n */\\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\\n internal\\n view\\n returns (bool)\\n {\\n return\\n collateralRatio >=\\n PlatformSettingsLib.getOverCollateralizedBufferValue();\\n }\\n\\n /**\\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\\n * @notice There is a minimum threshold of 1%.\\n * @dev The interest rate is APY (annual percentage yield).\\n * @param loanID The loan ID to get the interest rate for.\\n */\\n function getInterestRatio(uint256 loanID)\\n internal\\n view\\n returns (uint16 ratio_)\\n {\\n ratio_ = uint16(\\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\\n SECONDS_PER_YEAR\\n );\\n\\n if (ratio_ == 0) {\\n ratio_ = 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0xaabb82718f6948669e5c984d7bdc0d0ae4806e3b17beba4dd60e771d67444c07\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x417b75f5d92be67993efc54db7d453be5b5058a9a54d8916380e0281d3299526\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param amount Amount of the source token to convert into the destination token.\\n * @param exchangeRate The calculated exchange rate between the tokens.\\n * @return uint256 Value of the source token amount given an exchange rate peg.\\n */\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n /**\\n * @notice it returns 10^{numberOfDecimals} for a token\\n * @param token the address to calculate the decimals for\\n * @return 10^number of decimals used to calculate the price and value of different token pairs\\n */\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @notice It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @notice it tries to calculate a price from Compound and Chainlink.\\n * @dev if no price is found on compound, then calculate it on chainlink\\n * @param src the token address to calculate the price for in dst\\n * @param dst the token address to retrieve the price of src\\n * @return price_ the price of src in dst\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n * @param src the address of the src token\\n * @param dst the address of the dst token\\n * @return the price of the src token in dst token\\n\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n * @param src the source token to calculate price for with chainlink\\n * @param dst the destination token to calculate price for with chainlink\\n * @param cRate the compound rate to multiply with the price of the dst token\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @notice Scales the {value} by the difference in decimal values.\\n * @param value the the value of the src in dst\\n * @param srcDecimals src token decimals\\n * @param dstDecimals dst token decimals\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @notice it tries to calculate the price of {src} in {dst}\\n * @param src address of source token\\n * @param dst address of destination token\\n * @return the price of src token in dst\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address wrappedNativeToken =\\n AppStorageLib.store().wrappedNativeToken;\\n if (dst != wrappedNativeToken) {\\n int256 price1 = _priceFor(src, wrappedNativeToken);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, wrappedNativeToken);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice it checks if a token is a cToken. If it is, then get the underlying address\\n * @param token address of the token\\n * @return isCToken boolean whether it's a cToken\\n * @return underlying the address of the cToken\\n */\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xcf6280e2d36fdedbca4c0b94e413832f4bb267202de235bfc1cf6fda26c780ec\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { PriceAggFacet } from \\\"./PriceAggFacet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\n/**\\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\\n */\\nlibrary PriceAggLib {\\n /**\\n * @notice It calculates the value of one token amount into another\\n * @param src the source token\\n * @param dst the destination token\\n * @param srcAmount the amount of source token\\n * @return value_ the returned value of src in dst\\n */\\n function valueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) internal view returns (uint256 value_) {\\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\\n }\\n\\n /**\\n * @notice It returns the price of the token pair as given from Compound.\\n * @dev if no compound price is calculated, then it checks Chainlink price Aggregator\\n * @param src the address of the source token\\n * @param dst the address of the desitnation token\\n * @return price_ gets the price of src in dst\\n */\\n function priceFor(address src, address dst)\\n internal\\n view\\n returns (int256 price_)\\n {\\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\\n }\\n}\\n\",\"keccak256\":\"0xff59eee567fa4a7f5cac432e31d918be92834f04614f49572d3984a5b030ac79\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/asset/libraries/AssetPPoolLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n CacheLib,\\n Cache,\\n CacheType\\n} from \\\"../../../shared/libraries/CacheLib.sol\\\";\\nimport {\\n PrizePoolInterface\\n} from \\\"../../../escrow/dapps/interfaces/PrizePoolInterface.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library of inline functions for Pool together asset setting.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary AssetPPoolLib {\\n bytes32 private constant NAME = keccak256(\\\"pPool\\\");\\n\\n function s(address asset) private view returns (Cache storage) {\\n return AppStorageLib.store().assetSettings[asset];\\n }\\n\\n function get(address asset) internal view returns (PrizePoolInterface) {\\n return PrizePoolInterface(s(asset).addresses[NAME]);\\n }\\n\\n function set(address asset, address newValue) internal {\\n s(asset).addresses[NAME] = newValue;\\n }\\n}\\n\",\"keccak256\":\"0x2e4b07dc02548201148c45ce33291f91c759bea8291f29ca081424d9b9aaef12\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\nabstract contract PausableMods {\\n /**\\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\\n * @param id id of the facet to check if is paused.\\n * @param state Boolean that the protocol AND facet should be in.\\n */\\n modifier paused(bytes32 id, bool state) {\\n require(\\n __isPaused(\\\"\\\") == state && __isPaused(id) == state,\\n __pausedMessage(state)\\n );\\n _;\\n }\\n\\n /**\\n * @dev Checks if the given id is paused.\\n * @param id Encoded id of the facet to check if is paused.\\n * @return the bool to tell us if the facet is paused (true) or not (false)\\n */\\n function __isPaused(bytes32 id) private view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n\\n /**\\n * @dev Gets the message that should be reverted with given a state it should be in.\\n * @param state Boolean that an id should be in.\\n * @return a message stating whether the facet is paused or not\\n */\\n function __pausedMessage(bool state) private pure returns (string memory) {\\n return state ? \\\"Pausable: not paused\\\" : \\\"Pausable: paused\\\";\\n }\\n}\\n\",\"keccak256\":\"0x2d3f848ee56ae5fa365539c2509c03c167affc89c89f98bb98cb9b83fbe8ae4c\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"NFTInterestRate\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getNFTInterestRate() internal view returns (uint16 value_) {\\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0x44294be1af9f913b2ed391a40cd4b646537a4b463b8d5ff1fac8ead3988966c1\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for loans taken out with an NFT.\\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\\n */\\nbytes32 constant NFT_INTEREST_RATE = keccak256(\\\"NFTInterestRate\\\");\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xd68a7df42b2bbba6f935d5890b7b37997c1432e25ae113827b8bde87f94fd86f\",\"license\":\"MIT\"},\"contracts/shared/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n /**\\n * @notice Checks if the account should be allowed to mint tokens in the given market\\n * @param cToken The market to verify the mint against\\n * @param minter The account which would get the minted tokens\\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates mint and reverts on rejection. May emit logs.\\n * @param cToken Asset being minted\\n * @param minter The address minting the tokens\\n * @param mintAmount The amount of the underlying asset being minted\\n * @param mintTokens The number of tokens being minted\\n */\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to redeem tokens in the given market\\n * @param cToken The market to verify the redeem against\\n * @param redeemer The account which would redeem the tokens\\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates redeem and reverts on rejection. May emit logs.\\n * @param cToken Asset being redeemed\\n * @param redeemer The address redeeming the tokens\\n * @param redeemAmount The amount of the underlying asset being redeemed\\n * @param redeemTokens The number of tokens being redeemed\\n */\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\\n * @param cToken The market to verify the borrow against\\n * @param borrower The account which would borrow the asset\\n * @param borrowAmount The amount of underlying the account would borrow\\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates borrow and reverts on rejection. May emit logs.\\n * @param cToken Asset whose underlying is being borrowed\\n * @param borrower The address borrowing the underlying\\n * @param borrowAmount The amount of the underlying asset requested to borrow\\n */\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to repay a borrow in the given market\\n * @param cToken The market to verify the repay against\\n * @param payer The account which would repay the asset\\n * @param borrower The account which would borrowed the asset\\n * @param repayAmount The amount of the underlying asset the account would repay\\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\\n * @param cToken Asset being repaid\\n * @param payer The address repaying the borrow\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param borrowerIndex the index of the borrower\\n */\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n /**\\n * @notice Checks if the liquidation should be allowed to occur\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n */\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the seizing of assets should be allowed to occur\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates seize and reverts on rejection. May emit logs.\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to transfer tokens in the given market\\n * @param cToken The market to verify the transfer against\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates transfer and reverts on rejection. May emit logs.\\n * @param cToken Asset being transferred\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n */\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in all markets\\n * @param holder The address to claim COMP for\\n */\\n function claimComp(address holder) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in the specified markets\\n * @param holder The address to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n */\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n /**\\n * @notice Claim all comp accrued by the holders\\n * @param holders The addresses to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n * @param borrowers Whether or not to claim COMP earned by borrowing\\n * @param suppliers Whether or not to claim COMP earned by supplying\\n */\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n /**\\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\\n * @param cTokenBorrowed The address of the borrowed cToken\\n * @param cTokenCollateral The address of the collateral cToken\\n * @param repayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\\n */\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n /**\\n * @notice Return the address of the COMP token\\n * @return The address of COMP\\n */\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x38a824a4a21ce9370fa581a616d1bb9d311f27d8982a6b96ebeba90bd5fd0adb\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n\\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x208769886b3db8f03ef1fa26f1caee189038dfc744b9a499402fc4e4c0090c38\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @dev CETH is the only Compound token that does not support the {underlying} function.\\n * @param cToken address of the compound token\\n * @return address of the underlying cToken\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x99206384c27b0e68b1ec7b82260f6a47965f611875c018bc076ff8a688a6c6d7\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n /**\\n * @notice it returns the absolute number of a specified parameter\\n * @param self the number to be returned in it's absolute\\n * @return the absolute number\\n */\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0x4f750cde25d4b1db919abf3192d58ed6aef617d03637e1e9e2dc31b70dcc32a3\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n address wrappedNativeToken;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4504c5c460972a25cd1f0e6eb1d8dd84a668be75a3aeb89a47a49c2327c12923\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\n// DEPRECATED\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\nstruct LoanRequest {\\n LoanUserRequest request;\\n LoanConsensusResponse[] responses;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanUserRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanConsensusResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) _loanTerms; // DEPRECATED: DO NOT REMOVE\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb7e05aeec806b5621512def93f4a389b4ef88c50ef9fe7115a33f57db2f2304b\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "0x608060405234801561001057600080fd5b50600436106100415760003560e01c80631bb0a63e146100465780638d3900ba1461005b578063c9fe48fc1461006e575b600080fd5b610059610054366004610f94565b610081565b005b610059610069366004610fc3565b61034d565b61005961007c366004610fc3565b6106d8565b600080805260016020527fa6eef7e35abe7026729641147f7915573c7e97b47efa546f5f6e3230263bcb4954819060ff161580156100d3575060008281526001602052604090205460ff161515811515145b6100dc8261097e565b906101035760405162461bcd60e51b81526004016100fa9190611084565b60405180910390fd5b508361010e816109e7565b546001600160a01b031633146101365760405162461bcd60e51b81526004016100fa90611097565b600061014185610a17565b9050600061014e86610a60565b9050600061015c8883610b0e565b9050600063a016240b60e01b6101718a610ba6565b83856001600160801b0360405160240161018e9493929190611052565b60408051601f198184030181529190526020810180516001600160e01b03166001600160e01b03199093169290921790915290506101e97f0553069f1f0518e59f8623c18c83a1f987f2a0544d563e98dd803a7078142a8590565b60008a81526004918201602052604090819020549051632198fd3760e11b81526001600160a01b0390911691634331fa6e91610229918891869101611026565b600060405180830381600087803b15801561024357600080fd5b505af1158015610257573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f1916820160405261027f9190810190610eec565b50600061028c8a85610b0e565b90508281106102ce5760405162461bcd60e51b815260206004820152600e60248201526d2ba4aa24222920abafa2a92927a960911b60448201526064016100fa565b6102d88a85610be0565b6102e28a8a610be0565b836001600160a01b0316896001600160a01b03167f4325e49314a1abdcc73cc314d599904e92cc98f43edee4e7057ce1adba68f6df856103228e8e610b0e565b604080519283526020830191909152810185905260600160405180910390a350505050505050505050565b600080805260016020527fa6eef7e35abe7026729641147f7915573c7e97b47efa546f5f6e3230263bcb4954819060ff1615801561039f575060008281526001602052604090205460ff161515811515145b6103a88261097e565b906103c65760405162461bcd60e51b81526004016100fa9190611084565b50846103d1816109e7565b546001600160a01b031633146103f95760405162461bcd60e51b81526004016100fa90611097565b836104048787610b0e565b10156104525760405162461bcd60e51b815260206004820152601c60248201527f504f4f4c5f494e53554646494349454e545f554e4445524c59494e470000000060448201526064016100fa565b600061045d86610a17565b9050600061046a87610a60565b905060006104788983610b0e565b905061048389610ba6565b60405163124f493560e11b81526001600160a01b038a811660048301528581166024830152919091169063249e926a90604401600060405180830381600087803b1580156104d057600080fd5b505af11580156104e4573d6000803e3d6000fd5b50505050600063e323f82560e01b6104fb8b610ba6565b6040516001600160a01b039182166024820152604481018b9052908516606482015230608482015260a40160408051601f198184030181529190526020810180516001600160e01b03166001600160e01b03199093169290921790915290506105817f0553069f1f0518e59f8623c18c83a1f987f2a0544d563e98dd803a7078142a8590565b60008b81526004918201602052604090819020549051632198fd3760e11b81526001600160a01b0390911691634331fa6e916105c1918891869101611026565b600060405180830381600087803b1580156105db57600080fd5b505af11580156105ef573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526106179190810190610eec565b5060006106248b85610b0e565b90508281116106655760405162461bcd60e51b815260206004820152600d60248201526c2222a827a9a4aa2fa2a92927a960991b60448201526064016100fa565b61066f8b85610be0565b6106798b8b610be0565b604080518a8152602081018590529081018290526001600160a01b0380861691908c16907f90b96c1d485e859f17010282dca834881b962d3eea4dc562f2a4157518ca0de2906060015b60405180910390a35050505050505050505050565b600080805260016020527fa6eef7e35abe7026729641147f7915573c7e97b47efa546f5f6e3230263bcb4954819060ff1615801561072a575060008281526001602052604090205460ff161515811515145b6107338261097e565b906107515760405162461bcd60e51b81526004016100fa9190611084565b508461075c816109e7565b546001600160a01b031633146107845760405162461bcd60e51b81526004016100fa90611097565b600061078f86610a17565b9050600061079c87610a60565b905060006107aa8983610b0e565b9050600063a016240b60e01b6107bf8b610ba6565b89856001600160801b036040516024016107dc9493929190611052565b60408051601f198184030181529190526020810180516001600160e01b03166001600160e01b03199093169290921790915290506108377f0553069f1f0518e59f8623c18c83a1f987f2a0544d563e98dd803a7078142a8590565b60008b81526004918201602052604090819020549051632198fd3760e11b81526001600160a01b0390911691634331fa6e91610877918891869101611026565b600060405180830381600087803b15801561089157600080fd5b505af11580156108a5573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526108cd9190810190610eec565b5060006108da8b85610b0e565b905082811061091c5760405162461bcd60e51b815260206004820152600e60248201526d2ba4aa24222920abafa2a92927a960911b60448201526064016100fa565b6109268b85610be0565b6109308b8b610be0565b604080518a8152602081018590529081018290526001600160a01b0380861691908c16907f4325e49314a1abdcc73cc314d599904e92cc98f43edee4e7057ce1adba68f6df906060016106c3565b6060816109b3576040518060400160405280601081526020016f14185d5cd8589b194e881c185d5cd95960821b8152506109e1565b6040518060400160405280601481526020017314185d5cd8589b194e881b9bdd081c185d5cd95960621b8152505b92915050565b60009081527f0553069f1f0518e59f8623c18c83a1f987f2a0544d563e98dd803a7078142a866020526040902090565b6001600160a01b0390811660009081526003602090815260408083207fe085150958a532f3a64a7d9945e54fead733be0c2384f8022b0cd078b994c83a84529091529020541690565b6000610a6b82610a17565b6001600160a01b0316639d63848a6040518163ffffffff1660e01b815260040160006040518083038186803b158015610aa357600080fd5b505afa158015610ab7573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052610adf9190810190610e38565b600181518110610aff57634e487b7160e01b600052603260045260246000fd5b60200260200101519050919050565b6000816001600160a01b03166370a08231610b2885610ba6565b6040516001600160e01b031960e084901b1681526001600160a01b03909116600482015260240160206040518083038186803b158015610b6757600080fd5b505afa158015610b7b573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610b9f9190610f7c565b9392505050565b60009081527f0553069f1f0518e59f8623c18c83a1f987f2a0544d563e98dd803a7078142a8960205260409020546001600160a01b031690565b806001600160a01b0316610bf3836109e7565b600101546001600160a01b03161415610c0b57610c82565b60008281527f0553069f1f0518e59f8623c18c83a1f987f2a0544d563e98dd803a7078142a8a6020526040812090610c438284610c86565b90506000610c518585610b0e565b1115610c6d5780610c6857610c668284610ca8565b505b610c7f565b8015610c7f57610c7d8284610cbd565b505b50505b5050565b6001600160a01b03811660009081526001830160205260408120541515610b9f565b6000610b9f836001600160a01b038416610cd2565b6000610b9f836001600160a01b038416610d21565b6000818152600183016020526040812054610d19575081546001818101845560008481526020808220909301849055845484825282860190935260409020919091556109e1565b5060006109e1565b60008181526001830160205260408120548015610e2e576000610d456001836110ff565b8554909150600090610d59906001906110ff565b90506000866000018281548110610d8057634e487b7160e01b600052603260045260246000fd5b9060005260206000200154905080876000018481548110610db157634e487b7160e01b600052603260045260246000fd5b600091825260208083209091019290925582815260018901909152604090208490558654879080610df257634e487b7160e01b600052603160045260246000fd5b600190038181906000526020600020016000905590558660010160008781526020019081526020016000206000905560019450505050506109e1565b60009150506109e1565b60006020808385031215610e4a578182fd5b825167ffffffffffffffff80821115610e61578384fd5b818501915085601f830112610e74578384fd5b815181811115610e8657610e8661114e565b8060051b9150610e978483016110ce565b8181528481019084860184860187018a1015610eb1578788fd5b8795505b83861015610edf5780519450610eca85611164565b84835260019590950194918601918601610eb5565b5098975050505050505050565b600060208284031215610efd578081fd5b815167ffffffffffffffff80821115610f14578283fd5b818401915084601f830112610f27578283fd5b815181811115610f3957610f3961114e565b610f4c601f8201601f19166020016110ce565b9150808252856020828501011115610f62578384fd5b610f73816020840160208601611122565b50949350505050565b600060208284031215610f8d578081fd5b5051919050565b60008060408385031215610fa6578081fd5b823591506020830135610fb881611164565b809150509250929050565b600080600060608486031215610fd7578081fd5b833592506020840135610fe981611164565b929592945050506040919091013590565b60008151808452611012816020860160208601611122565b601f01601f19169290920160200192915050565b6001600160a01b038316815260406020820181905260009061104a90830184610ffa565b949350505050565b6001600160a01b0394851681526020810193909352921660408201526001600160801b03909116606082015260800190565b600060208252610b9f6020830184610ffa565b6020808252601e908201527f54656c6c65723a2064617070206e6f74206c6f616e20626f72726f7765720000604082015260600190565b604051601f8201601f1916810167ffffffffffffffff811182821017156110f7576110f761114e565b604052919050565b60008282101561111d57634e487b7160e01b81526011600452602481fd5b500390565b60005b8381101561113d578181015183820152602001611125565b83811115610c7f5750506000910152565b634e487b7160e01b600052604160045260246000fd5b6001600160a01b038116811461117957600080fd5b5056fea2646970667358221220dd128eeb4754e25b447c967f9688d914e73e975ed8ec8d18bb42bc349726efe064736f6c63430008030033", + "devdoc": { + "events": { + "PoolTogetherDeposited(address,address,uint256,uint256,uint256)": { + "params": { + "amount": "amount of tokens deposited.", + "creditBalanceAfter": "pool together credit after depositing.", + "ticketAddress": "pool ticket token address.", + "tokenAddress": "address of the underlying token.", + "tokenBalance": "underlying token balance after depositing." + } + }, + "PoolTogetherWithdrawal(address,address,uint256,uint256,uint256)": { + "params": { + "amount": "amount of tokens to Redeem.", + "creditBalanceAfter": "pool together credit after depositing.", + "ticketAddress": "pool ticket token address.", + "tokenAddress": "address of the underlying token.", + "tokenBalance": "underlying token balance after Redeem." + } + } + }, + "kind": "dev", + "methods": { + "poolTogetherDepositTicket(uint256,address,uint256)": { + "params": { + "amount": "of tokens to deposit.", + "loanID": "id of the loan being used in the dapp", + "tokenAddress": "address of the token." + } + }, + "poolTogetherWithdraw(uint256,address,uint256)": { + "params": { + "amount": "The amount of tokens to withdraw.", + "loanID": "id of the loan being used in the dapp", + "tokenAddress": "address of the token." + } + }, + "poolTogetherWithdrawAll(uint256,address)": { + "params": { + "loanID": "id of the loan being used in the dapp", + "tokenAddress": "address of the token." + } + } + }, + "version": 1 + }, + "userdoc": { + "events": { + "PoolTogetherDeposited(address,address,uint256,uint256,uint256)": { + "notice": "This event is emitted every time Pool Together depositTo is invoked successfully." + }, + "PoolTogetherWithdrawal(address,address,uint256,uint256,uint256)": { + "notice": "This event is emitted every time Pool Together withdrawInstantlyFrom is invoked successfully." + } + }, + "kind": "user", + "methods": { + "poolTogetherDepositTicket(uint256,address,uint256)": { + "notice": "This function deposits the users funds into a Pool Together Prize Pool for a ticket." + }, + "poolTogetherWithdraw(uint256,address,uint256)": { + "notice": "This function withdraws the users funds from a Pool Together Prize Pool." + }, + "poolTogetherWithdrawAll(uint256,address)": { + "notice": "This function withdraws the users funds from a Pool Together Prize Pool." + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/PriceAggFacet.json b/deployments/polygon_mumbai/PriceAggFacet.json new file mode 100644 index 000000000..175a88b88 --- /dev/null +++ b/deployments/polygon_mumbai/PriceAggFacet.json @@ -0,0 +1,138 @@ +{ + "address": "0x7339d372116d8A56A9984814Ce1175377C58Fd7E", + "abi": [ + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + } + ], + "artifactName": "PriceAggFacet", + "transactionHash": "0x28d13750ffac1b5e4c35f9314211e1d7ca6ed948ca2f196aecbae3fe703f61e7", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x7339d372116d8A56A9984814Ce1175377C58Fd7E", + "transactionIndex": 0, + "gasUsed": "746996", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000800100000000000000000100000000004000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000080000000000000000000200000000000000000000000000000000000000000000000000000000000004000000000000100000001000000000000000000000000000000100040000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0x7c1b82a773483e459bf4e6706a310eed02a94478d088a49d9f441d2e81449f79", + "transactionHash": "0x28d13750ffac1b5e4c35f9314211e1d7ca6ed948ca2f196aecbae3fe703f61e7", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692456, + "transactionHash": "0x28d13750ffac1b5e4c35f9314211e1d7ca6ed948ca2f196aecbae3fe703f61e7", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000be188d6641e8b680743a4815dfa0f6208038960f" + ], + "data": "0x000000000000000000000000000000000000000000000000004f9daac8dbf0000000000000000000000000000000000000000000000000003edac16889603c0000000000000000000000000000000000000000000000007e5994e54ce48a25500000000000000000000000000000000000000000000000003e8b23bdc0844c0000000000000000000000000000000000000000000000007e59e482f7ad661550", + "logIndex": 0, + "blockHash": "0x7c1b82a773483e459bf4e6706a310eed02a94478d088a49d9f441d2e81449f79" + } + ], + "blockNumber": 15692456, + "cumulativeGasUsed": "746996", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"src\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"dst\",\"type\":\"address\"}],\"name\":\"getPriceFor\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"src\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"dst\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"srcAmount\",\"type\":\"uint256\"}],\"name\":\"getValueFor\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"getPriceFor(address,address)\":{\"details\":\"It tries to use ETH as a pass through asset if the direct pair is not supported.\",\"params\":{\"dst\":\"Destination token address.\",\"src\":\"Source token address.\"},\"returns\":{\"_0\":\"int256 The latest answer as given from Chainlink.\"}},\"getValueFor(address,address,uint256)\":{\"params\":{\"dst\":\"Destination token address.\",\"src\":\"Source token address.\",\"srcAmount\":\"Amount of the source token to convert into the destination token.\"},\"returns\":{\"_0\":\"uint256 Value of the source token amount in destination tokens.\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"getPriceFor(address,address)\":{\"notice\":\"It returns the price of the token pair as given from the Chainlink Aggregator.\"},\"getValueFor(address,address,uint256)\":{\"notice\":\"It calculates the value of a token amount into another.\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/price-aggregator/PriceAggFacet.sol\":\"PriceAggFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x417b75f5d92be67993efc54db7d453be5b5058a9a54d8916380e0281d3299526\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param amount Amount of the source token to convert into the destination token.\\n * @param exchangeRate The calculated exchange rate between the tokens.\\n * @return uint256 Value of the source token amount given an exchange rate peg.\\n */\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n /**\\n * @notice it returns 10^{numberOfDecimals} for a token\\n * @param token the address to calculate the decimals for\\n * @return 10^number of decimals used to calculate the price and value of different token pairs\\n */\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @notice It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @notice it tries to calculate a price from Compound and Chainlink.\\n * @dev if no price is found on compound, then calculate it on chainlink\\n * @param src the token address to calculate the price for in dst\\n * @param dst the token address to retrieve the price of src\\n * @return price_ the price of src in dst\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n * @param src the address of the src token\\n * @param dst the address of the dst token\\n * @return the price of the src token in dst token\\n\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n * @param src the source token to calculate price for with chainlink\\n * @param dst the destination token to calculate price for with chainlink\\n * @param cRate the compound rate to multiply with the price of the dst token\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @notice Scales the {value} by the difference in decimal values.\\n * @param value the the value of the src in dst\\n * @param srcDecimals src token decimals\\n * @param dstDecimals dst token decimals\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @notice it tries to calculate the price of {src} in {dst}\\n * @param src address of source token\\n * @param dst address of destination token\\n * @return the price of src token in dst\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address wrappedNativeToken =\\n AppStorageLib.store().wrappedNativeToken;\\n if (dst != wrappedNativeToken) {\\n int256 price1 = _priceFor(src, wrappedNativeToken);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, wrappedNativeToken);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice it checks if a token is a cToken. If it is, then get the underlying address\\n * @param token address of the token\\n * @return isCToken boolean whether it's a cToken\\n * @return underlying the address of the cToken\\n */\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xcf6280e2d36fdedbca4c0b94e413832f4bb267202de235bfc1cf6fda26c780ec\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"NFTInterestRate\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getNFTInterestRate() internal view returns (uint16 value_) {\\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0x44294be1af9f913b2ed391a40cd4b646537a4b463b8d5ff1fac8ead3988966c1\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for loans taken out with an NFT.\\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\\n */\\nbytes32 constant NFT_INTEREST_RATE = keccak256(\\\"NFTInterestRate\\\");\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xd68a7df42b2bbba6f935d5890b7b37997c1432e25ae113827b8bde87f94fd86f\",\"license\":\"MIT\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n /**\\n * @notice Checks if the account should be allowed to mint tokens in the given market\\n * @param cToken The market to verify the mint against\\n * @param minter The account which would get the minted tokens\\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates mint and reverts on rejection. May emit logs.\\n * @param cToken Asset being minted\\n * @param minter The address minting the tokens\\n * @param mintAmount The amount of the underlying asset being minted\\n * @param mintTokens The number of tokens being minted\\n */\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to redeem tokens in the given market\\n * @param cToken The market to verify the redeem against\\n * @param redeemer The account which would redeem the tokens\\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates redeem and reverts on rejection. May emit logs.\\n * @param cToken Asset being redeemed\\n * @param redeemer The address redeeming the tokens\\n * @param redeemAmount The amount of the underlying asset being redeemed\\n * @param redeemTokens The number of tokens being redeemed\\n */\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\\n * @param cToken The market to verify the borrow against\\n * @param borrower The account which would borrow the asset\\n * @param borrowAmount The amount of underlying the account would borrow\\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates borrow and reverts on rejection. May emit logs.\\n * @param cToken Asset whose underlying is being borrowed\\n * @param borrower The address borrowing the underlying\\n * @param borrowAmount The amount of the underlying asset requested to borrow\\n */\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to repay a borrow in the given market\\n * @param cToken The market to verify the repay against\\n * @param payer The account which would repay the asset\\n * @param borrower The account which would borrowed the asset\\n * @param repayAmount The amount of the underlying asset the account would repay\\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\\n * @param cToken Asset being repaid\\n * @param payer The address repaying the borrow\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param borrowerIndex the index of the borrower\\n */\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n /**\\n * @notice Checks if the liquidation should be allowed to occur\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n */\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the seizing of assets should be allowed to occur\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates seize and reverts on rejection. May emit logs.\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to transfer tokens in the given market\\n * @param cToken The market to verify the transfer against\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates transfer and reverts on rejection. May emit logs.\\n * @param cToken Asset being transferred\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n */\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in all markets\\n * @param holder The address to claim COMP for\\n */\\n function claimComp(address holder) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in the specified markets\\n * @param holder The address to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n */\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n /**\\n * @notice Claim all comp accrued by the holders\\n * @param holders The addresses to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n * @param borrowers Whether or not to claim COMP earned by borrowing\\n * @param suppliers Whether or not to claim COMP earned by supplying\\n */\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n /**\\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\\n * @param cTokenBorrowed The address of the borrowed cToken\\n * @param cTokenCollateral The address of the collateral cToken\\n * @param repayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\\n */\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n /**\\n * @notice Return the address of the COMP token\\n * @return The address of COMP\\n */\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x38a824a4a21ce9370fa581a616d1bb9d311f27d8982a6b96ebeba90bd5fd0adb\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @dev CETH is the only Compound token that does not support the {underlying} function.\\n * @param cToken address of the compound token\\n * @return address of the underlying cToken\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x99206384c27b0e68b1ec7b82260f6a47965f611875c018bc076ff8a688a6c6d7\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n address wrappedNativeToken;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4504c5c460972a25cd1f0e6eb1d8dd84a668be75a3aeb89a47a49c2327c12923\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "kind": "dev", + "methods": { + "getPriceFor(address,address)": { + "details": "It tries to use ETH as a pass through asset if the direct pair is not supported.", + "params": { + "dst": "Destination token address.", + "src": "Source token address." + }, + "returns": { + "_0": "int256 The latest answer as given from Chainlink." + } + }, + "getValueFor(address,address,uint256)": { + "params": { + "dst": "Destination token address.", + "src": "Source token address.", + "srcAmount": "Amount of the source token to convert into the destination token." + }, + "returns": { + "_0": "uint256 Value of the source token amount in destination tokens." + } + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "getPriceFor(address,address)": { + "notice": "It returns the price of the token pair as given from the Chainlink Aggregator." + }, + "getValueFor(address,address,uint256)": { + "notice": "It calculates the value of a token amount into another." + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/RepayFacet.json b/deployments/polygon_mumbai/RepayFacet.json new file mode 100644 index 000000000..cef03d969 --- /dev/null +++ b/deployments/polygon_mumbai/RepayFacet.json @@ -0,0 +1,310 @@ +{ + "address": "0x4d046a028556D0404dE776B78EAC6e9E89ac3395", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "RepayFacet", + "transactionHash": "0xd1c8dbade616ddafb4389baf6aefaad21c4feb2fe9d5ee289c8ab33efe7a43fc", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x4d046a028556D0404dE776B78EAC6e9E89ac3395", + "transactionIndex": 0, + "gasUsed": "1914545", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000800100000000000000000100000000004000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000080000000000000000000200000000000000000000000000000000000000000000000000000000000004000000000000100000001000000000000000000000000000000100040000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0x18fc8f27aec9ebff82e4514e208ebbc140e857de126c4f0b0677995b20edf2e6", + "transactionHash": "0xd1c8dbade616ddafb4389baf6aefaad21c4feb2fe9d5ee289c8ab33efe7a43fc", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692479, + "transactionHash": "0xd1c8dbade616ddafb4389baf6aefaad21c4feb2fe9d5ee289c8ab33efe7a43fc", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000be188d6641e8b680743a4815dfa0f6208038960f" + ], + "data": "0x00000000000000000000000000000000000000000000000000cc0e0e56f1ec000000000000000000000000000000000000000000000000003be65218f38d100000000000000000000000000000000000000000000000007e5d12c26bcbb94b500000000000000000000000000000000000000000000000003b1a440a9c9b240000000000000000000000000000000000000000000000007e5dded07a22ab3750", + "logIndex": 0, + "blockHash": "0x18fc8f27aec9ebff82e4514e208ebbc140e857de126c4f0b0677995b20edf2e6" + } + ], + "blockNumber": 15692479, + "cumulativeGasUsed": "1914545", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"liquidator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"reward\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokensIn\",\"type\":\"uint256\"}],\"name\":\"LoanLiquidated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"borrower\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountPaid\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"totalOwed\",\"type\":\"uint256\"}],\"name\":\"LoanRepaid\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"}],\"name\":\"TokensClaimed\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"claimTokens\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"escrowRepay\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"getLiquidationReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"inLending_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"inCollateral_\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"}],\"name\":\"liquidateLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"loanID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"repayLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"params\":{\"borrower\":\"Account address of the borrower\",\"liquidator\":\"Account address of the liquidator\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"reward\":\"Value in lending token paid out to liquidator\",\"tokensIn\":\"Percentage of the collateral price paid by the liquidator to the lending pool\"}},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"params\":{\"amountPaid\":\"Amount of the loan paid back\",\"borrower\":\"Account address of the borrower\",\"loanID\":\"ID of loan from which collateral was withdrawn\",\"payer\":\"Account address of the payer\",\"totalOwed\":\"Total amount of the loan to be repaid\"}}},\"kind\":\"dev\",\"methods\":{\"claimTokens(uint256)\":{\"params\":{\"loanID\":\"The id of the loan being used.\"}},\"escrowRepay(uint256,uint256)\":{\"details\":\"If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\",\"params\":{\"amount\":\"The amount being repaid.\",\"loanID\":\"The id of the loan being used.\"}},\"getLiquidationReward(uint256)\":{\"params\":{\"loanID\":\"The loan ID to get the info.\"},\"returns\":{\"inCollateral_\":\"The value the liquidator will receive denoted in collateral tokens.\",\"inLending_\":\"The value the liquidator will receive denoted in lending tokens.\"}},\"liquidateLoan(uint256)\":{\"params\":{\"loanID\":\"The ID of the loan to be liquidated\"}},\"repayLoan(uint256,uint256)\":{\"params\":{\"amount\":\"The amount of tokens to pay back to the loan\",\"loanID\":\"The ID of the loan the payment is for\"}}},\"version\":1},\"userdoc\":{\"events\":{\"LoanLiquidated(uint256,address,address,uint256,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully liquidated\"},\"LoanRepaid(uint256,address,uint256,address,uint256)\":{\"notice\":\"This event is emitted when a loan has been successfully repaid\"},\"TokensClaimed(address)\":{\"notice\":\"Notifies when the Escrow's tokens have been claimed.\"}},\"kind\":\"user\",\"methods\":{\"claimTokens(uint256)\":{\"notice\":\"Sends the tokens owned by this escrow to the owner.\"},\"escrowRepay(uint256,uint256)\":{\"notice\":\"Repay this Escrow's loan.\"},\"getLiquidationReward(uint256)\":{\"notice\":\"It gets the current liquidation reward for a given loan.\"},\"liquidateLoan(uint256)\":{\"notice\":\"Liquidate a loan if it is expired or under collateralized\"},\"repayLoan(uint256,uint256)\":{\"notice\":\"Make a payment to a loan\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/market/RepayFacet.sol\":\"RepayFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorInterface {\\n function latestAnswer()\\n external\\n view\\n returns (\\n int256\\n );\\n \\n function latestTimestamp()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function latestRound()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n function getAnswer(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n int256\\n );\\n\\n function getTimestamp(\\n uint256 roundId\\n )\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n event AnswerUpdated(\\n int256 indexed current,\\n uint256 indexed roundId,\\n uint256 updatedAt\\n );\\n\\n event NewRound(\\n uint256 indexed roundId,\\n address indexed startedBy,\\n uint256 startedAt\\n );\\n}\\n\",\"keccak256\":\"0x1a5dc81544a6479f64437a8aca22c869769dd54ee3522c7ef5ebae0d329a28f0\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./AggregatorInterface.sol\\\";\\nimport \\\"./AggregatorV3Interface.sol\\\";\\n\\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\\n{\\n}\\n\",\"keccak256\":\"0xe8f8d98b515366730824d24269c7267eee7f0288cf737db8659acbb0c751eb53\",\"license\":\"MIT\"},\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n\\n function decimals()\\n external\\n view\\n returns (\\n uint8\\n );\\n\\n function description()\\n external\\n view\\n returns (\\n string memory\\n );\\n\\n function version()\\n external\\n view\\n returns (\\n uint256\\n );\\n\\n // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n // if they do not have data to report, instead of returning unset values\\n // which could be misinterpreted as actual reported values.\\n function getRoundData(\\n uint80 _roundId\\n )\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n function latestRoundData()\\n external\\n view\\n returns (\\n uint80 roundId,\\n int256 answer,\\n uint256 startedAt,\\n uint256 updatedAt,\\n uint80 answeredInRound\\n );\\n\\n}\\n\",\"keccak256\":\"0xe6f5ac8c47f3b9b6135051efb9216f9ba5b312a6ecc20209b4f66a780443c328\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Trees proofs.\\n *\\n * The proofs can be generated using the JavaScript library\\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\\n *\\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n bytes32 computedHash = leaf;\\n\\n for (uint256 i = 0; i < proof.length; i++) {\\n bytes32 proofElement = proof[i];\\n\\n if (computedHash <= proofElement) {\\n // Hash(current computed hash + current element of the proof)\\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\\n } else {\\n // Hash(current element of the proof + current computed hash)\\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\\n }\\n }\\n\\n // Check if the computed hash (root) is equal to the provided root\\n return computedHash == root;\\n }\\n}\\n\",\"keccak256\":\"0xeee34bfb413657b6cd6c8e1e15c2080ba5ebaac479578515922804346fb63f7c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value < 2**128, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value < 2**64, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value < 2**32, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value < 2**16, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value < 2**8, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128) {\\n require(value >= -2**127 && value < 2**127, \\\"SafeCast: value doesn\\\\'t fit in 128 bits\\\");\\n return int128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64) {\\n require(value >= -2**63 && value < 2**63, \\\"SafeCast: value doesn\\\\'t fit in 64 bits\\\");\\n return int64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32) {\\n require(value >= -2**31 && value < 2**31, \\\"SafeCast: value doesn\\\\'t fit in 32 bits\\\");\\n return int32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16) {\\n require(value >= -2**15 && value < 2**15, \\\"SafeCast: value doesn\\\\'t fit in 16 bits\\\");\\n return int16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits.\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8) {\\n require(value >= -2**7 && value < 2**7, \\\"SafeCast: value doesn\\\\'t fit in 8 bits\\\");\\n return int8(value);\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n require(value < 2**255, \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xc37d85b96c2a8d7bc09f25958e0a81394bf5780286444147ddf875fa628d53ce\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/reentry/ReentryMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nabstract contract ReentryMods {\\n modifier nonReentry(bytes32 id) {\\n AccessControlStorage storage s = AccessControlStorageLib.store();\\n require(!s.entered[id], \\\"AccessControl: reentered\\\");\\n s.entered[id] = true;\\n _;\\n s.entered[id] = false;\\n }\\n}\\n\",\"keccak256\":\"0x033c1164af25ef7d35a38a60973bf379b1cc603596914ffd85dcbcf0acdb6970\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/EscrowClaimTokens.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\n\\n// Interfaces\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, LoanStatus } from \\\"../storage/market.sol\\\";\\n\\n// Libraries\\nimport { LibLoans } from \\\"../market/libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"./libraries/LibEscrow.sol\\\";\\n\\n/**\\n * @notice Contains functionality to claim tokens that are in an escrow contract for a loan.\\n */\\ncontract EscrowClaimTokens is PausableMods {\\n /**\\n * @notice Notifies when the Escrow's tokens have been claimed.\\n * @param recipient address where the tokens where sent to.\\n */\\n event TokensClaimed(address recipient);\\n\\n /**\\n * @notice Sends the tokens owned by this escrow to the owner.\\n * @param loanID The id of the loan being used.\\n */\\n function claimTokens(uint256 loanID) external paused(\\\"\\\", false) {\\n require(\\n LibLoans.loan(loanID).borrower == msg.sender,\\n \\\"Teller: claim not borrower\\\"\\n );\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Closed,\\n \\\"Teller: loan not closed\\\"\\n );\\n\\n __claimEscrowTokens(loanID);\\n }\\n\\n function __claimEscrowTokens(uint256 loanID) internal {\\n __claimToken(loanID, LibLoans.loan(loanID).lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n __claimToken(loanID, EnumerableSet.at(tokens, i));\\n }\\n\\n emit TokensClaimed(msg.sender);\\n }\\n\\n function __claimToken(uint256 loanID, address token) private {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n if (balance > 0) {\\n LibEscrow.e(loanID).claimToken(\\n token,\\n LibLoans.loan(loanID).borrower,\\n balance\\n );\\n }\\n }\\n}\\n\",\"keccak256\":\"0xae189ea2a13c10f013f255f98ec50f34466c375bd7503275587d6abe5d25696c\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../../../shared/interfaces/IAToken.sol\\\";\\nimport {\\n IAaveLendingPool\\n} from \\\"../../../shared/interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../../../shared/interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xd05e3E715d945B59290df0ae8eF85c1BdB684744 // Polygon mainnet\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x4c18d46f924a3a24d596971d39857477b618dad13dee55decc271bdccf915ee5\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n /**\\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\\n * @param dappAddress address of the target contract address\\n * @param dappData encoded abi of the function in our contract we want to call\\n * @return the called data in bytes\\n */\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n /**\\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\\n * @param token address of the respective ERC20 token to approve for the spender\\n * @param spender address of the respective spender who is approved by the token contract\\n */\\n function setTokenAllowance(address token, address spender) external;\\n\\n /**\\n * @notice it allows user to claim their escrow tokens\\n * @dev only the owner (TellerDiamond) can make this call on behalf of the users\\n * @param token address of the respective token contract to claim tokens from\\n * @param to address where the tokens should be transferred to\\n * @param amount uint256 amount of tokens to be claimed\\n */\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xaf67fc4454ffaa4d2f7e46fe7101876e8ebdb1a5426c30f87b8e18cc573ac019\",\"license\":\"MIT\"},\"contracts/escrow/libraries/LibEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibDapps } from \\\"../dapps/libraries/LibDapps.sol\\\";\\nimport { LibLoans } from \\\"../../market/libraries/LibLoans.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibEscrow {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\\n e_ = s().loanEscrows[loanID];\\n }\\n\\n /**\\n * @notice It returns a list of tokens owned by a loan escrow\\n * @param loanID uint256 index used to return our token list\\n * @return t_ which is a list of tokens \\n */\\n function getEscrowTokens(uint256 loanID)\\n internal\\n view\\n returns (EnumerableSet.AddressSet storage t_)\\n {\\n t_ = s().escrowTokens[loanID];\\n }\\n\\n /**\\n * @notice It returns the balance of a respective token in a loan escrow\\n * @param loanID uint256 index used to point to our loan escrow\\n * @param token address of respective token to give us the balance of in our loan escrow\\n * @return uint256 balance of respective token returned in an escrow loan\\n */\\n function balanceOf(uint256 loanID, address token)\\n internal\\n view\\n returns (uint256)\\n {\\n return IERC20(token).balanceOf(address(e(loanID)));\\n }\\n\\n /**\\n * @notice Adds or removes tokens held by the Escrow contract\\n * @param loanID The loan ID to update the token list for\\n * @param tokenAddress The token address to be added or removed\\n */\\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\\n // Skip if is lending token\\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\\n\\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\\n if (balanceOf(loanID, tokenAddress) > 0) {\\n if (!contains) {\\n EnumerableSet.add(tokens, tokenAddress);\\n }\\n } else if (contains) {\\n EnumerableSet.remove(tokens, tokenAddress);\\n }\\n }\\n\\n /**\\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\\n * @param loanID The loan ID to calculate value for\\n * @return value_ Escrow total value denoted in the lending token.\\n */\\n function calculateTotalValue(uint256 loanID)\\n internal\\n view\\n returns (uint256 value_)\\n {\\n address lendingToken = LibLoans.loan(loanID).lendingToken;\\n value_ += balanceOf(loanID, lendingToken);\\n\\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\\n if (EnumerableSet.length(tokens) > 0) {\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n uint256 tokenBal =\\n balanceOf(loanID, EnumerableSet.at(tokens, i));\\n value_ += PriceAggLib.valueFor(\\n EnumerableSet.at(tokens, i),\\n lendingToken,\\n tokenBal\\n );\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x17a7c6b11d6f280948e320525d1e131b89c23f80216918aa070df437a851d915\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when a user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when a user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n * @return ERC20 token\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n * @return balance_ the balance of the account\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice It calculates the total supply of the underlying asset.\\n * @return totalSupply_ the total supply denoted in the underlying asset.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given market.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n \\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfill the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n * @return mintAmount_ the amount minted of the specified token\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n * @return address of the strategy contract\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n * @param state boolean value that resembles the platform's state\\n */\\n function restrict(bool state) external virtual;\\n\\n /**\\n * @notice it initializes the Teller Token\\n * @param admin address of the admin to the respective Teller Token\\n * @param underlying address of the ERC20 token\\n */\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xf30ac4ef491851477ff9a3dd04974ebe74b529c37a3ef4e05798c3f734ceeb3d\",\"license\":\"MIT\"},\"contracts/market/LoanDataFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { Loan, LoanDebt, LoanTerms } from \\\"../storage/market.sol\\\";\\n\\ncontract LoanDataFacet {\\n /**\\n * @notice Returns the information about the given {loanID}.\\n * @param loanID The loan ID to get information for.\\n * @return loan_ The loan data.\\n */\\n function getLoan(uint256 loanID) external view returns (Loan memory loan_) {\\n loan_ = LibLoans.s().loans[loanID];\\n }\\n\\n /**\\n * @notice DEPRECATED\\n * @notice Returns the terms for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanTerms The terms that the loan weer created with.\\n */\\n function getLoanTerms(uint256 loanID)\\n external\\n view\\n returns (LoanTerms memory)\\n {\\n return LibLoans.terms(loanID);\\n }\\n\\n /**\\n * @notice Returns the loan IDs created by the {borrower} account.\\n * @param borrower The account to get loan IDs for.\\n * @return loanIDs The IDs for loans created by the {borrower}\\n */\\n function getBorrowerLoans(address borrower)\\n external\\n view\\n returns (uint128[] memory loanIDs)\\n {\\n return LibLoans.s().borrowerLoans[borrower];\\n }\\n\\n /**\\n * @notice Returns the debt owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return LoanDebt The principal and interest owed amount.\\n */\\n function getDebtOwed(uint256 loanID)\\n external\\n view\\n returns (LoanDebt memory)\\n {\\n return LibLoans.debt(loanID);\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID) external view returns (uint256) {\\n return LibLoans.getTotalOwed(loanID);\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n external\\n view\\n returns (uint256)\\n {\\n return LibLoans.getInterestOwedFor(loanID, amountBorrow);\\n }\\n\\n /**\\n * @notice it returns the collateral needed for a loan\\n * @param loanID the identifier of the loan ID to retrieve collateral from\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n external\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n return LibLoans.getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the typed address of a loan escrow\\n * @param loanID the identifier of the respective escrow's loan\\n * @return escrow_ the typed address of the returned ILoanEscrow\\n */\\n function getLoanEscrow(uint256 loanID)\\n external\\n view\\n returns (address escrow_)\\n {\\n escrow_ = address(LibLoans.s().loanEscrows[loanID]);\\n }\\n\\n /**\\n * @notice it returns the escrow's total value by calculating the value all the escrow tokens\\n * @param loanID the identifier of the respective escrow's loan\\n * @return the total value of the loan escrow\\n */\\n function getLoanEscrowValue(uint256 loanID)\\n external\\n view\\n returns (uint256)\\n {\\n return LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n /**\\n * @notice it returns the total escrow tokens held by an escrow\\n * @param loanID the identifier of the respective escrow's loan\\n * @return tokens_ the tokens held at the escrow loan\\n */\\n function getEscrowTokens(uint256 loanID)\\n external\\n view\\n returns (address[] memory tokens_)\\n {\\n EnumerableSet.AddressSet storage escrowTokens =\\n LibEscrow.getEscrowTokens(loanID);\\n tokens_ = new address[](EnumerableSet.length(escrowTokens));\\n for (uint256 i; i < tokens_.length; i++) {\\n tokens_[i] = EnumerableSet.at(escrowTokens, i);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xbf39ea599f556eb6c0ea2e9aef435fe8edc258c63511667506923f54f6200bba\",\"license\":\"MIT\"},\"contracts/market/RepayFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { PausableMods } from \\\"../settings/pausable/PausableMods.sol\\\";\\nimport {\\n ReentryMods\\n} from \\\"../contexts2/access-control/reentry/ReentryMods.sol\\\";\\nimport { AUTHORIZED } from \\\"../shared/roles.sol\\\";\\nimport { LoanDataFacet } from \\\"./LoanDataFacet.sol\\\";\\nimport { EscrowClaimTokens } from \\\"../escrow/EscrowClaimTokens.sol\\\";\\n\\n// Libraries\\nimport {\\n IERC20,\\n SafeERC20\\n} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport { LibLoans } from \\\"./libraries/LibLoans.sol\\\";\\nimport { LibCollateral } from \\\"./libraries/LibCollateral.sol\\\";\\nimport { LibDapps } from \\\"../escrow/dapps/libraries/LibDapps.sol\\\";\\nimport { LibEscrow } from \\\"../escrow/libraries/LibEscrow.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { NumbersLib } from \\\"../shared/libraries/NumbersLib.sol\\\";\\nimport { PriceAggLib } from \\\"../price-aggregator/PriceAggLib.sol\\\";\\nimport { NFTLib } from \\\"../nft/libraries/NFTLib.sol\\\";\\n\\n// Interfaces\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus\\n} from \\\"../storage/market.sol\\\";\\n\\ncontract RepayFacet is RolesMods, ReentryMods, PausableMods, EscrowClaimTokens {\\n /**\\n @notice This event is emitted when a loan has been successfully repaid\\n @param loanID ID of loan from which collateral was withdrawn\\n @param borrower Account address of the borrower\\n @param amountPaid Amount of the loan paid back\\n @param payer Account address of the payer\\n @param totalOwed Total amount of the loan to be repaid\\n */\\n event LoanRepaid(\\n uint256 indexed loanID,\\n address indexed borrower,\\n uint256 amountPaid,\\n address payer,\\n uint256 totalOwed\\n );\\n\\n /**\\n * @notice This event is emitted when a loan has been successfully liquidated\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param borrower Account address of the borrower\\n * @param liquidator Account address of the liquidator\\n * @param reward Value in lending token paid out to liquidator\\n * @param tokensIn Percentage of the collateral price paid by the liquidator to the lending pool\\n */\\n event LoanLiquidated(\\n uint256 indexed loanID,\\n address indexed borrower,\\n address liquidator,\\n uint256 reward,\\n uint256 tokensIn\\n );\\n\\n /**\\n * @notice Repay this Escrow's loan.\\n * @dev If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.\\n * @dev Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\\n * @param loanID The id of the loan being used.\\n * @param amount The amount being repaid.\\n */\\n function escrowRepay(uint256 loanID, uint256 amount)\\n external\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n nonReentry(\\\"\\\")\\n {\\n uint256 balance =\\n LibEscrow.balanceOf(loanID, LibLoans.loan(loanID).lendingToken);\\n uint256 totalOwed = LibLoans.getTotalOwed(loanID);\\n // if there isn't enough balance in the escrow, then transfer amount needed to the escrow\\n if (balance < totalOwed && amount > balance) {\\n uint256 amountNeeded =\\n amount > totalOwed ? totalOwed - (balance) : amount - (balance);\\n\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n msg.sender,\\n address(LibEscrow.e(loanID)),\\n amountNeeded\\n );\\n }\\n\\n __repayLoan(loanID, amount, address(LibEscrow.e(loanID)), false);\\n }\\n\\n /**\\n * @notice Make a payment to a loan\\n * @param loanID The ID of the loan the payment is for\\n * @param amount The amount of tokens to pay back to the loan\\n */\\n function repayLoan(uint256 loanID, uint256 amount)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n __repayLoan(loanID, amount, msg.sender, false);\\n }\\n\\n /**\\n * @notice it repays the loan, either from an escrow or from a regular address\\n * @param loanID the identifier of the loan to repay\\n * @param amount the amount to repay the loan\\n * @param sender the address of the sender that wants to pay, can also be a loan escrow\\n * @param isLiquidation is this loan being liquidated?\\n * @return leftToPay_ the amount left to pay for the loan\\n */\\n function __repayLoan(\\n uint256 loanID,\\n uint256 amount,\\n address sender,\\n bool isLiquidation\\n ) private returns (uint256 leftToPay_) {\\n require(amount > 0, \\\"Teller: zero repay\\\");\\n\\n // calculate the actual amount to repay\\n leftToPay_ =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n if (leftToPay_ < amount) {\\n amount = leftToPay_;\\n leftToPay_ = 0;\\n } else {\\n leftToPay_ -= amount;\\n }\\n\\n // Get the Teller token for the loan\\n ITToken tToken =\\n MarketStorageLib.store().tTokens[\\n LibLoans.loan(loanID).lendingToken\\n ];\\n // Transfer funds from an escrow if an escrow is calling it\\n // Otherwise, transfer funds from an account\\n if (address(LibEscrow.e(loanID)) == sender) {\\n LibEscrow.e(loanID).claimToken(\\n LibLoans.loan(loanID).lendingToken,\\n address(tToken),\\n amount\\n );\\n } else {\\n SafeERC20.safeTransferFrom(\\n IERC20(LibLoans.loan(loanID).lendingToken),\\n sender,\\n address(tToken),\\n amount\\n );\\n }\\n\\n // Deduct the interest and principal owed\\n uint256 principalPaid;\\n uint256 interestPaid;\\n if (amount < LibLoans.debt(loanID).interestOwed) {\\n interestPaid = amount;\\n LibLoans.debt(loanID).interestOwed -= amount;\\n } else {\\n if (LibLoans.debt(loanID).interestOwed > 0) {\\n interestPaid = LibLoans.debt(loanID).interestOwed;\\n amount -= interestPaid;\\n LibLoans.debt(loanID).interestOwed = 0;\\n }\\n\\n if (amount > 0) {\\n principalPaid = amount;\\n LibLoans.debt(loanID).principalOwed -= amount;\\n }\\n }\\n\\n // Tell the Teller Token value has been deposited back into the pool.\\n tToken.repayLoan(principalPaid, interestPaid);\\n\\n if (isLiquidation) {\\n // Make sure there is nothing left to repay on the loan\\n require(leftToPay_ == 0, \\\"Teller: liquidate partial repay\\\");\\n\\n // Set loan status\\n LibLoans.loan(loanID).status = LoanStatus.Liquidated;\\n\\n // Transfer NFT if linked\\n NFTLib.liquidateNFT(loanID);\\n } else {\\n // if the loan is now fully paid, close it and withdraw borrower collateral\\n if (leftToPay_ == 0) {\\n LibLoans.loan(loanID).status = LoanStatus.Closed;\\n\\n // Check if the loan has a collateral token\\n if (LibLoans.loan(loanID).collateralToken != address(0)) {\\n LibCollateral.withdrawAll(\\n loanID,\\n LibLoans.loan(loanID).borrower\\n );\\n }\\n\\n // Claim tokens in the escrow for the loan if any\\n __claimEscrowTokens(loanID);\\n\\n // Restake any NFTs linked to loan for borrower\\n NFTLib.restakeLinked(loanID, LibLoans.loan(loanID).borrower);\\n }\\n\\n emit LoanRepaid(\\n loanID,\\n LibLoans.loan(loanID).borrower,\\n amount,\\n msg.sender,\\n leftToPay_\\n );\\n }\\n }\\n\\n /**\\n * @notice Liquidate a loan if it is expired or under collateralized\\n * @param loanID The ID of the loan to be liquidated\\n */\\n function liquidateLoan(uint256 loanID)\\n external\\n nonReentry(\\\"\\\")\\n paused(\\\"\\\", false)\\n authorized(AUTHORIZED, msg.sender)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n uint256 collateralAmount = LibCollateral.e(loanID).loanSupply(loanID);\\n require(\\n RepayLib.isLiquidable(loanID, collateralAmount),\\n \\\"Teller: does not need liquidation\\\"\\n );\\n\\n // Calculate the reward before repaying the loan\\n (uint256 rewardInLending, uint256 collateralInLending) =\\n RepayLib.getLiquidationReward(loanID, collateralAmount);\\n\\n // The liquidator pays the amount still owed on the loan\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n __repayLoan(loanID, amountToLiquidate, msg.sender, true);\\n\\n // Payout the liquidator reward owed\\n if (rewardInLending > 0) {\\n RepayLib.payOutLiquidator(\\n loanID,\\n rewardInLending,\\n collateralInLending,\\n collateralAmount,\\n payable(msg.sender)\\n );\\n }\\n\\n emit LoanLiquidated(\\n loanID,\\n loan.borrower,\\n msg.sender,\\n rewardInLending,\\n amountToLiquidate\\n );\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @return inLending_ The value the liquidator will receive denoted in lending tokens.\\n * @return inCollateral_ The value the liquidator will receive denoted in collateral tokens.\\n */\\n function getLiquidationReward(uint256 loanID)\\n external\\n view\\n returns (uint256 inLending_, uint256 inCollateral_)\\n {\\n (inLending_, ) = RepayLib.getLiquidationReward(\\n loanID,\\n LibCollateral.e(loanID).loanSupply(loanID)\\n );\\n inCollateral_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n inLending_\\n );\\n }\\n}\\n\\nlibrary RepayLib {\\n /**\\n * @notice It checks if a loan can be liquidated.\\n * @param loanID The loan ID to check.\\n * @return true if the loan is liquidable.\\n */\\n function isLiquidable(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (bool)\\n {\\n Loan storage loan = LibLoans.loan(loanID);\\n // Check if loan can be liquidated\\n if (loan.status != LoanStatus.Active) {\\n return false;\\n }\\n\\n if (loan.collateralRatio > 0) {\\n // If loan has a collateral ratio, check how much is needed\\n (, uint256 neededInCollateral, ) =\\n LoanDataFacet(address(this)).getCollateralNeededInfo(loanID);\\n if (neededInCollateral > collateralAmount) {\\n return true;\\n }\\n }\\n\\n // Otherwise, check if the loan has expired\\n return block.timestamp >= loan.loanStartTime + loan.duration;\\n }\\n\\n /**\\n * @notice It gets the current liquidation reward for a given loan.\\n * @param loanID The loan ID to get the info.\\n * @param collateralAmount The amount of collateral for the {loanID}. Passed in to save gas calling the collateral escrow multiple times.\\n * @return reward_ The value the liquidator will receive denoted in lending tokens.\\n */\\n function getLiquidationReward(uint256 loanID, uint256 collateralAmount)\\n internal\\n view\\n returns (uint256 reward_, uint256 collateralValue_)\\n {\\n uint256 amountToLiquidate =\\n LibLoans.debt(loanID).principalOwed +\\n LibLoans.debt(loanID).interestOwed;\\n\\n // Max reward is amount repaid on loan plus extra percentage\\n uint256 maxReward =\\n amountToLiquidate +\\n NumbersLib.percent(\\n amountToLiquidate,\\n uint16(PlatformSettingsLib.getLiquidateRewardPercent())\\n );\\n\\n // Calculate available collateral for reward\\n if (collateralAmount > 0) {\\n collateralValue_ = PriceAggLib.valueFor(\\n LibLoans.loan(loanID).collateralToken,\\n LibLoans.loan(loanID).lendingToken,\\n collateralAmount\\n );\\n reward_ += collateralValue_;\\n }\\n\\n // Calculate loan escrow value if collateral not enough to cover reward\\n if (reward_ < maxReward) {\\n reward_ += LibEscrow.calculateTotalValue(loanID);\\n }\\n\\n // Cap the reward to max\\n if (reward_ > maxReward) {\\n reward_ = maxReward;\\n }\\n }\\n\\n /**\\n * @notice Checks if the loan has an Escrow and claims any tokens then pays out the loan collateral.\\n * @dev See Escrow.claimTokens for more info.\\n * @param loanID The loan ID which is being liquidated\\n * @param rewardInLending The total amount of reward based in the lending token to pay the liquidator\\n * @param collateralInLending The amount of collateral that is available for the loan denoted in lending tokens\\n * @param collateralAmount The amount of collateral that is available for the loan\\n * @param liquidator The address of the liquidator where the liquidation reward will be sent to\\n */\\n function payOutLiquidator(\\n uint256 loanID,\\n uint256 rewardInLending,\\n uint256 collateralInLending,\\n uint256 collateralAmount,\\n address payable liquidator\\n ) internal {\\n // check if loan is liquidated\\n require(\\n LibLoans.loan(loanID).status == LoanStatus.Liquidated,\\n \\\"Teller: loan not liquidated\\\"\\n );\\n\\n // if the lending reward is less than the collateral lending tokens, then aggregate\\n // the value for the lending token with the collateral token and send it to the liquidator\\n if (rewardInLending <= collateralInLending) {\\n uint256 rewardInCollateral =\\n PriceAggLib.valueFor(\\n LibLoans.loan(loanID).lendingToken,\\n LibLoans.loan(loanID).collateralToken,\\n rewardInLending\\n );\\n\\n LibCollateral.withdraw(loanID, rewardInCollateral, liquidator);\\n } else {\\n // Payout whats available in the collateral token\\n LibCollateral.withdraw(loanID, collateralAmount, liquidator);\\n\\n // Claim remaining reward value from the loan escrow\\n claimEscrowTokensByValue(\\n loanID,\\n liquidator,\\n rewardInLending - collateralInLending\\n );\\n }\\n }\\n\\n /**\\n * @dev Send the equivalent of tokens owned by the loan escrow (in lending value) to the recipient,\\n * @param loanID The loan ID to clam tokens from\\n * @param recipient address to send the tokens to\\n * @param value The value of escrow held tokens to be claimed based in lending value\\n */\\n function claimEscrowTokensByValue(\\n uint256 loanID,\\n address recipient,\\n uint256 value\\n ) private {\\n EnumerableSet.AddressSet storage tokens =\\n MarketStorageLib.store().escrowTokens[loanID];\\n uint256 valueLeftToTransfer = value;\\n\\n // Start with the lending token\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n LibLoans.loan(loanID).lendingToken,\\n recipient,\\n valueLeftToTransfer\\n );\\n\\n // Cycle through remaining tokens\\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\\n if (valueLeftToTransfer == 0) {\\n return;\\n }\\n\\n valueLeftToTransfer = claimEscrowToken(\\n loanID,\\n EnumerableSet.at(tokens, i),\\n recipient,\\n valueLeftToTransfer\\n );\\n }\\n }\\n\\n /**\\n * @notice it claims the escrow tokens for the liquidator\\n * @notice it keeps claiming escrow tokens until there aren't anymore tokens or the valueLeftToTransfer is zero\\n * @param loanID the identifier of the escrow loan to claim tokens from\\n * @param token the address of the token asset to claim\\n * @param recipient the address of the recipient to transfer the tokens to\\n * @param valueLeftToTransfer the value left to transfer to the liquidator that is returned back\\n * @return the value left to transfer\\n */\\n function claimEscrowToken(\\n uint256 loanID,\\n address token,\\n address recipient,\\n uint256 valueLeftToTransfer\\n ) private returns (uint256) {\\n uint256 balance = LibEscrow.balanceOf(loanID, token);\\n // get value of token balance in lending value\\n if (balance > 0) {\\n // If token not the lending token, get value of token\\n uint256 balanceInLending;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n balanceInLending = balance;\\n } else {\\n balanceInLending = PriceAggLib.valueFor(\\n token,\\n LibLoans.loan(loanID).lendingToken,\\n balance\\n );\\n }\\n\\n if (balanceInLending <= valueLeftToTransfer) {\\n LibEscrow.e(loanID).claimToken(token, recipient, balance);\\n valueLeftToTransfer -= balanceInLending;\\n } else {\\n // Token balance is more than enough so calculate ratio of balance to transfer\\n uint256 valueToTransfer;\\n if (token == LibLoans.loan(loanID).lendingToken) {\\n valueToTransfer = valueLeftToTransfer;\\n } else {\\n valueToTransfer = NumbersLib.percent(\\n balance,\\n NumbersLib.ratioOf(\\n valueLeftToTransfer,\\n balanceInLending\\n )\\n );\\n }\\n\\n LibEscrow.e(loanID).claimToken(\\n token,\\n recipient,\\n valueToTransfer\\n );\\n valueLeftToTransfer = 0;\\n }\\n }\\n return valueLeftToTransfer;\\n }\\n}\\n\",\"keccak256\":\"0xc440b61519f74c4eba549f1f531726b1cd8b3da60ba7654cccd4eb9bd9fd7020\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n /**\\n * @notice it initializes an escrow\\n * @param tokenAddress the address of the collateral token to be stored\\n * @param isWETH check if it's wrapped Ethereum\\n */\\n function init(address tokenAddress, bool isWETH) external;\\n\\n /**\\n * @notice it deposits an amount of the respective collateral token into the escrow\\n * @param loanID the ID of the loan\\n * @param amount the amount of collateral tokens to be deposited\\n */\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n /**\\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\\n * @dev only the TellerDiamond can make this call on behalf of the borrower\\n * @param loanID identifier of the loan\\n * @param amount number of collateral tokens to send\\n * @param receiver payable address to transfer money to\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n /**\\n * @notice it returns the supply of the respective loan\\n * @param loanID the respective loan ID\\n * @return supply_ the amount in collateral of the respective loan\\n */\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n /**\\n * @notice it returns the total supply of the collateral token held by the contract\\n * @return supply_ the total amount of collateral\\n */\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x900fed2311f919ba1451a6583ddbf9f3bc8afa8f5189500fff51f0c049258ed3\",\"license\":\"MIT\"},\"contracts/market/libraries/LibCollateral.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport { ICollateralEscrow } from \\\"../collateral/ICollateralEscrow.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\nimport { MarketStorageLib } from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibCollateral {\\n /**\\n * @notice This event is emitted when collateral has been deposited for the loan\\n * @param loanID ID of the loan for which collateral was deposited\\n * @param depositor Account that deposited funds\\n * @param amount Amount of collateral deposited\\n */\\n event CollateralDeposited(\\n uint256 indexed loanID,\\n address indexed depositor,\\n uint256 amount\\n );\\n\\n /**\\n * @notice This event is emitted when collateral has been withdrawn\\n * @param loanID ID of loan from which collateral was withdrawn\\n * @param receiver Account that received funds\\n * @param amount Value of collateral withdrawn\\n */\\n event CollateralWithdrawn(\\n uint256 indexed loanID,\\n address indexed receiver,\\n uint256 amount\\n );\\n\\n /**\\n * @notice it gets MarketStorage's collateral escrow using the loanID\\n * @param loanID the loanID to be used\\n * @return c_ which is the collateral escrow\\n */\\n function e(uint256 loanID) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[\\n MarketStorageLib.store().loans[loanID].collateralToken\\n ];\\n }\\n\\n function e(address token) internal view returns (ICollateralEscrow c_) {\\n c_ = MarketStorageLib.store().collateralEscrows[token];\\n }\\n\\n /**\\n * @notice it deposits an amount of collateral into a collateral escrow's address of a respective loan\\n * @param loanID the respective loan ID\\n * @param amount the amount of collateral to deposit\\n */\\n function deposit(uint256 loanID, uint256 amount) internal {\\n e(loanID).deposit{ value: amount }(loanID, amount);\\n\\n emit CollateralDeposited(loanID, msg.sender, amount);\\n }\\n\\n /**\\n * @notice it withdraws an amount from the collateral escrow\\n * @param loanID the respective loanID to withdraw from\\n * @param amount the number of collateral tokens to withdraw\\n * @param receiver the address who receives the withdrawal\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) internal {\\n e(loanID).withdraw(loanID, amount, receiver);\\n\\n emit CollateralWithdrawn(loanID, receiver, amount);\\n }\\n\\n /**\\n * @notice it withdraws the entire supply in collateral of a respective loan to an address\\n * @param loanID the respective loan's ID\\n * @param receiver the address of the receiver to withdraw tokens from\\n */\\n function withdrawAll(uint256 loanID, address payable receiver) internal {\\n withdraw(loanID, e(loanID).loanSupply(loanID), receiver);\\n }\\n\\n /**\\n * @notice it initializes a new escrow collateral to hold collateral tokens\\n * @param token address of the collateral token it holds\\n */\\n function createEscrow(address token) internal {\\n // Check if collateral escrow exists\\n if (address(e(token)) == address(0)) {\\n // Create escrow\\n address escrow =\\n AppStorageLib.store().collateralEscrowBeacon.cloneProxy(\\\"\\\");\\n ICollateralEscrow(escrow).init(\\n token,\\n // Check if collateral token is the base network token\\n token == AppStorageLib.store().wrappedNativeToken\\n );\\n\\n // Set max allowance\\n IERC20(token).approve(escrow, type(uint256).max);\\n // Save escrow address for loan\\n MarketStorageLib.store().collateralEscrows[\\n token\\n ] = ICollateralEscrow(escrow);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x539fb96f6d41224bfe644fbd3def4d1c0bba3ffcd31e659ff6b4bd274c5a39da\",\"license\":\"MIT\"},\"contracts/market/libraries/LibLoans.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { LibEscrow } from \\\"../../escrow/libraries/LibEscrow.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\nimport {\\n PlatformSettingsLib\\n} from \\\"../../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { PriceAggLib } from \\\"../../price-aggregator/PriceAggLib.sol\\\";\\n\\n// Storage\\nimport {\\n MarketStorageLib,\\n MarketStorage,\\n Loan,\\n LoanStatus,\\n LoanDebt,\\n LoanTerms\\n} from \\\"../../storage/market.sol\\\";\\n\\nlibrary LibLoans {\\n using NumbersLib for int256;\\n using NumbersLib for uint256;\\n\\n bytes32 internal constant ID = keccak256(\\\"LOANS\\\");\\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\\n\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n * @notice it returns the loan\\n * @param loanID the ID of the respective loan\\n * @return l_ the loan\\n */\\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\\n l_ = s().loans[loanID];\\n }\\n\\n /**\\n * @notice it returns the loan debt from a respective loan\\n * @param loanID the ID of the respective loan\\n * @return d_ the loan debt from a respective loan\\n */\\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\\n d_ = s().loanDebt[loanID];\\n }\\n\\n // DEPRECATED\\n function terms(uint256 loanID)\\n internal\\n view\\n returns (LoanTerms storage t_)\\n {\\n t_ = s()._loanTerms[loanID];\\n }\\n\\n /**\\n * @notice Returns the total amount owed for a specified loan.\\n * @param loanID The loan ID to get the total amount owed.\\n * @return owed_ uint256 The total owed amount.\\n */\\n function getTotalOwed(uint256 loanID)\\n internal\\n view\\n returns (uint256 owed_)\\n {\\n if (loan(loanID).status == LoanStatus.Active) {\\n owed_ = debt(loanID).principalOwed + (debt(loanID).interestOwed);\\n }\\n }\\n\\n /**\\n * @notice Returns the amount of interest owed for a given loan and loan amount.\\n * @param loanID The loan ID to get the owed interest.\\n * @param amountBorrow The principal of the loan to take out.\\n * @return uint256 The interest owed.\\n */\\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\\n internal\\n view\\n returns (uint256)\\n {\\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\\n }\\n\\n function getCollateralNeeded(uint256 loanID)\\n internal\\n view\\n returns (uint256 _needed)\\n {\\n (, _needed, ) = getCollateralNeededInfo(loanID);\\n }\\n\\n /**\\n * @notice it returns the total collateral needed in lending tokens, in collateral tokens and in escrowed loan values\\n * @param loanID the loanID to get the total collateral needed\\n * @return neededInLendingTokens total collateral needed in lending tokens\\n * @return neededInCollateralTokens total collateral needed in collateral tokens\\n * @return escrowLoanValue total collateral needed in loan value\\n */\\n function getCollateralNeededInfo(uint256 loanID)\\n internal\\n view\\n returns (\\n uint256 neededInLendingTokens,\\n uint256 neededInCollateralTokens,\\n uint256 escrowLoanValue\\n )\\n {\\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\\n loanID\\n );\\n\\n // check if needed lending tokens is zero. if true, then needed collateral tokens is zero. else,\\n if (neededInLendingTokens == 0) {\\n neededInCollateralTokens = 0;\\n } else {\\n neededInCollateralTokens = PriceAggLib.valueFor(\\n loan(loanID).lendingToken,\\n loan(loanID).collateralToken,\\n neededInLendingTokens\\n );\\n }\\n }\\n\\n /**\\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\\n * @param loanID The loan ID to get needed collateral info for.\\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\\n */\\n function getCollateralNeededInTokens(uint256 loanID)\\n internal\\n view\\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\\n {\\n if (loan(loanID).collateralRatio == 0) {\\n return (0, 0);\\n }\\n\\n /*\\n The collateral to principal owed ratio is the sum of:\\n * collateral buffer percent\\n * loan interest rate\\n * liquidation reward percent\\n * X factor of additional collateral\\n */\\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\\n if (loan(loanID).status == LoanStatus.TermsSet) {\\n neededInLendingTokens = loan(loanID).borrowedAmount.percent(\\n loan(loanID).collateralRatio\\n );\\n } else if (loan(loanID).status == LoanStatus.Active) {\\n uint16 requiredRatio =\\n loan(loanID).collateralRatio -\\n getInterestRatio(loanID) -\\n uint16(PlatformSettingsLib.getCollateralBufferValue());\\n\\n neededInLendingTokens =\\n debt(loanID).principalOwed +\\n debt(loanID).interestOwed;\\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\\n if (\\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\\n ) {\\n neededInLendingTokens -= escrowLoanValue;\\n }\\n neededInLendingTokens = neededInLendingTokens.percent(\\n requiredRatio\\n );\\n }\\n }\\n\\n /**\\n * @notice check if a loan can go to end of auction with a collateral ratio\\n * @return bool checking if collateralRatio is >= the over collateralized buffer value\\n */\\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\\n internal\\n view\\n returns (bool)\\n {\\n return\\n collateralRatio >=\\n PlatformSettingsLib.getOverCollateralizedBufferValue();\\n }\\n\\n /**\\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\\n * @notice There is a minimum threshold of 1%.\\n * @dev The interest rate is APY (annual percentage yield).\\n * @param loanID The loan ID to get the interest rate for.\\n */\\n function getInterestRatio(uint256 loanID)\\n internal\\n view\\n returns (uint16 ratio_)\\n {\\n ratio_ = uint16(\\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\\n SECONDS_PER_YEAR\\n );\\n\\n if (ratio_ == 0) {\\n ratio_ = 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0xaabb82718f6948669e5c984d7bdc0d0ae4806e3b17beba4dd60e771d67444c07\",\"license\":\"MIT\"},\"contracts/nft/IStakeableNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IStakeableNFT {\\n function tokenBaseLoanSize(uint256 tokenId) external view returns (uint256);\\n\\n function tokenURIHash(uint256 tokenId)\\n external\\n view\\n returns (string memory);\\n\\n function tokenContributionAsset(uint256 tokenId)\\n external\\n view\\n returns (address);\\n\\n function tokenContributionSize(uint256 tokenId)\\n external\\n view\\n returns (uint256);\\n\\n function tokenContributionMultiplier(uint256 tokenId)\\n external\\n view\\n returns (uint8);\\n}\\n\",\"keccak256\":\"0xfbf44350ad91a54de26f39195d714580d7dade556ea4c7991a51eef5aa839105\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x417b75f5d92be67993efc54db7d453be5b5058a9a54d8916380e0281d3299526\",\"license\":\"MIT\"},\"contracts/nft/TellerNFTDictionary.sol\":{\"content\":\"/**\\n * @notice TellerNFTDictionary Version 1.02\\n *\\n * @notice This contract is used to gather data for TellerV1 NFTs more efficiently.\\n * @notice This contract has data which must be continuously synchronized with the TellerV1 NFT data\\n *\\n * @author develop@teller.finance\\n */\\n\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Interfaces\\nimport \\\"./IStakeableNFT.sol\\\";\\n\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFTDictionary is IStakeableNFT, AccessControlUpgradeable {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n mapping(uint256 => uint256) public baseLoanSizes;\\n mapping(uint256 => string[]) public hashes;\\n mapping(uint256 => address) public contributionAssets;\\n mapping(uint256 => uint256) public contributionSizes;\\n mapping(uint256 => uint8) public contributionMultipliers;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n\\n /* State Variables */\\n\\n mapping(uint256 => uint256) public _tokenTierMappingCompressed;\\n bool public _tokenTierMappingCompressedSet;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFTDictionary: not admin\\\");\\n _;\\n }\\n\\n function initialize(address initialAdmin) public {\\n _setupRole(ADMIN, initialAdmin);\\n _setRoleAdmin(ADMIN, ADMIN);\\n\\n __AccessControl_init();\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTierIndex(uint256 tokenId)\\n public\\n view\\n returns (uint8 index_)\\n {\\n //32 * 8 = 256 - each uint256 holds the data of 32 tokens . 8 bits each.\\n\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 compressedRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n //use 31 instead of 32 to account for the '0x' in the start.\\n //the '31 -' reverses our bytes order which is necessary\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint8 tierIndex = uint8((compressedRegister >> offset));\\n\\n return tierIndex;\\n }\\n\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory)\\n {\\n return hashes[tierIndex];\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTier(uint256 index, Tier memory newTier)\\n external\\n onlyAdmin\\n returns (bool)\\n {\\n baseLoanSizes[index] = newTier.baseLoanSize;\\n hashes[index] = newTier.hashes;\\n contributionAssets[index] = newTier.contributionAsset;\\n contributionSizes[index] = newTier.contributionSize;\\n contributionMultipliers[index] = newTier.contributionMultiplier;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param tiersMapping Information about the new tiers to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setAllTokenTierMappings(uint256[] memory tiersMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n require(\\n !_tokenTierMappingCompressedSet,\\n \\\"TellerNFTDictionary: token tier mapping already set\\\"\\n );\\n for (uint256 i = 0; i < tiersMapping.length; i++) {\\n _tokenTierMappingCompressed[i] = tiersMapping[i];\\n }\\n\\n _tokenTierMappingCompressedSet = true;\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param index the mapping row, each holds data for 32 tokens\\n * @param tierMapping Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierMapping(uint256 index, uint256 tierMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n _tokenTierMappingCompressed[index] = tierMapping;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenIds the NFT token Ids for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenIds(\\n uint256[] calldata tokenIds,\\n uint256 tokenTier\\n ) public onlyAdmin returns (bool) {\\n for (uint256 i; i < tokenIds.length; i++) {\\n setTokenTierForTokenId(tokenIds[i], tokenTier);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenId the NFT token Id for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenId(uint256 tokenId, uint256 tokenTier)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 existingRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint256 updateMaskShifted =\\n 0x00000000000000000000000000000000000000000000000000000000000000FF <<\\n offset;\\n\\n uint256 updateMaskShiftedNegated = ~updateMaskShifted;\\n\\n uint256 tokenTierShifted =\\n ((0x0000000000000000000000000000000000000000000000000000000000000000 |\\n tokenTier) << offset);\\n\\n uint256 existingRegisterClearedWithMask =\\n existingRegister & updateMaskShiftedNegated;\\n\\n uint256 updatedRegister =\\n existingRegisterClearedWithMask | tokenTierShifted;\\n\\n _tokenTierMappingCompressed[mappingIndex] = updatedRegister;\\n\\n return true;\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(IStakeableNFT).interfaceId ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n New methods for the dictionary\\n */\\n\\n /**\\n * @notice It returns Base Loan Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenBaseLoanSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return baseLoanSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Token URI Hash for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenURIHash(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n string[] memory tierImageHashes = hashes[tokenTier];\\n return tierImageHashes[tokenId % (tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice It returns Contribution Asset for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionAsset(uint256 tokenId)\\n public\\n view\\n override\\n returns (address)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionAssets[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Multiplier for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionMultiplier(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint8)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionMultipliers[tokenTier];\\n }\\n}\\n\",\"keccak256\":\"0xf33e3fa1f609fdd2abb3b5fb9c232269d13363a3e4fa5697ea96269e361e74fa\"},\"contracts/nft/libraries/NFTLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../TellerNFT.sol\\\";\\n\\n// Libraries\\nimport {\\n MerkleProof\\n} from \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\nimport { NFTStorageLib, NFTStorage } from \\\"../../storage/nft.sol\\\";\\n\\nlibrary NFTLib {\\n function s() internal pure returns (NFTStorage storage s_) {\\n s_ = NFTStorageLib.store();\\n }\\n\\n function nft() internal view returns (TellerNFT nft_) {\\n nft_ = AppStorageLib.store().nft;\\n }\\n\\n /**s\\n * @notice it transfers the NFT from the sender to the diamond to stake then adds the NFTID to the list of the owner's stakedNFTs\\n * @param nftID the ID of the NFT to stake\\n * @param owner the owner of the NFT who will stake the NFT\\n */\\n function stake(uint256 nftID, address owner) internal {\\n // Transfer to diamond\\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\\n // Add NFT ID to user set\\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\\n }\\n\\n /**\\n * @notice it unstakes the NFT by removing the NFT ID from the list of the user's staked NFTs\\n * @param nftID the ID of the NFT to remove from the list of the user's staked NFTs\\n * @return success_ the boolean value telling us if the user has unsuccessfully unstaked the NFT\\n */\\n function unstake(uint256 nftID) internal returns (bool success_) {\\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\\n }\\n\\n /**\\n * @notice it gets the list of staked NFTs from the owner\\n * @param nftOwner the owner of the staked NFTs to pull from\\n * @return staked_ the array of the staked NFTs owned by the user\\n */\\n function stakedNFTs(address nftOwner)\\n internal\\n view\\n returns (uint256[] memory staked_)\\n {\\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\\n staked_ = new uint256[](EnumerableSet.length(nfts));\\n for (uint256 i; i < staked_.length; i++) {\\n staked_[i] = EnumerableSet.at(nfts, i);\\n }\\n }\\n\\n /**\\n * @notice if the user fails to pay his loan, then we liquidate the all the NFTs associated with the loan\\n * @param loanID the identifier of the loan to liquidate the NFTs from\\n */\\n function liquidateNFT(uint256 loanID) internal {\\n // Check if NFTs are linked\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n NFTLib.nft().transferFrom(\\n address(this),\\n AppStorageLib.store().nftLiquidationController,\\n EnumerableSet.at(nfts, i)\\n );\\n }\\n }\\n\\n /**\\n * @notice it unstakes an NFT and verifies the proof in order to apply the proof to a loan\\n * @param loanID the identifier of the loan\\n * @param nftID the NFT ID to apply to the loan\\n */\\n function applyToLoan(uint256 loanID, uint256 nftID) internal {\\n // NFT must be currently staked\\n // Remove NFT from being staked - returns bool\\n require(unstake(nftID), \\\"Teller: borrower nft not staked\\\");\\n\\n // Apply NFT to loan\\n EnumerableSet.add(s().loanNFTs[loanID], nftID);\\n }\\n\\n /**\\n * @notice it finds the loan's NFTs and adds them back to the owner's list of staked NFTs\\n * @param loanID the identifier of the respective loan to add the NFTs back to the user's staked NFTs\\n * @param owner the owner to add the unstaked NFTs back to the staked pile\\n */\\n function restakeLinked(uint256 loanID, address owner) internal {\\n // Get linked NFT\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n // Restake the NFT\\n EnumerableSet.add(s().stakedNFTs[owner], EnumerableSet.at(nfts, i));\\n }\\n }\\n}\\n\",\"keccak256\":\"0xccbd35c6e8d0130b38f5025ee81c47d55e4fa48c8fcb8bec6f70c21061e0ce61\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { ChainlinkLib } from \\\"./chainlink/ChainlinkLib.sol\\\";\\nimport { CompoundLib } from \\\"../shared/libraries/CompoundLib.sol\\\";\\n\\n// Interfaces\\nimport {\\n AggregatorV2V3Interface\\n} from \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\ncontract PriceAggFacet {\\n uint256 internal constant TEN = 10;\\n\\n /**\\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return int256 The latest answer as given from Chainlink.\\n */\\n function getPriceFor(address src, address dst)\\n external\\n view\\n returns (int256)\\n {\\n return _priceFor(src, dst);\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @param srcAmount Amount of the source token to convert into the destination token.\\n * @return uint256 Value of the source token amount in destination tokens.\\n */\\n function getValueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) external view returns (uint256) {\\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\\n }\\n\\n /**\\n * @notice It calculates the value of a token amount into another.\\n * @param src Source token address.\\n * @param amount Amount of the source token to convert into the destination token.\\n * @param exchangeRate The calculated exchange rate between the tokens.\\n * @return uint256 Value of the source token amount given an exchange rate peg.\\n */\\n function _valueFor(\\n address src,\\n uint256 amount,\\n uint256 exchangeRate\\n ) internal view returns (uint256) {\\n return (amount * exchangeRate) / _oneToken(src);\\n }\\n\\n /**\\n * @notice it returns 10^{numberOfDecimals} for a token\\n * @param token the address to calculate the decimals for\\n * @return 10^number of decimals used to calculate the price and value of different token pairs\\n */\\n function _oneToken(address token) internal view returns (uint256) {\\n return TEN**_decimalsFor(token);\\n }\\n\\n /**\\n * @notice It gets the number of decimals for a given token.\\n * @param addr Token address to get decimals for.\\n * @return uint8 Number of decimals the given token.\\n */\\n function _decimalsFor(address addr) internal view returns (uint8) {\\n return ERC20(addr).decimals();\\n }\\n\\n /**\\n * @notice it tries to calculate a price from Compound and Chainlink.\\n * @dev if no price is found on compound, then calculate it on chainlink\\n * @param src the token address to calculate the price for in dst\\n * @param dst the token address to retrieve the price of src\\n * @return price_ the price of src in dst\\n */\\n function _priceFor(address src, address dst)\\n private\\n view\\n returns (int256 price_)\\n {\\n // If no Compound route, try Chainlink directly.\\n price_ = int256(_compoundPriceFor(src, dst));\\n if (price_ == 0) {\\n price_ = _chainlinkPriceFor(src, dst);\\n if (price_ == 0) {\\n revert(\\\"Teller: cannot calc price\\\");\\n }\\n }\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\\n * @param src the address of the src token\\n * @param dst the address of the dst token\\n * @return the price of the src token in dst token\\n\\n */\\n function _compoundPriceFor(address src, address dst)\\n private\\n view\\n returns (uint256)\\n {\\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\\n if (isSrcCompound) {\\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\\n if (srcUnderlying == dst) {\\n return cRate;\\n } else {\\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\\n }\\n } else {\\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\\n if (isDstCompound) {\\n uint256 cRate =\\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\\n if (dstUnderlying == src) {\\n return cRate;\\n } else {\\n return\\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\\n * @param src the source token to calculate price for with chainlink\\n * @param dst the destination token to calculate price for with chainlink\\n * @param cRate the compound rate to multiply with the price of the dst token\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _calcPriceFromCompoundRate(\\n address src,\\n address dst,\\n uint256 cRate\\n ) private view returns (uint256) {\\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\\n uint256 value = (cRate * _oneToken(dst)) / rate;\\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\\n }\\n\\n /**\\n * @notice Scales the {value} by the difference in decimal values.\\n * @param value the the value of the src in dst\\n * @param srcDecimals src token decimals\\n * @param dstDecimals dst token decimals\\n * @return the price of src in dst after scaling the difference in decimal values\\n */\\n function _scale(\\n uint256 value,\\n uint256 srcDecimals,\\n uint256 dstDecimals\\n ) internal pure returns (uint256) {\\n if (dstDecimals > srcDecimals) {\\n return value * (TEN**(dstDecimals - srcDecimals));\\n } else {\\n return value / (TEN**(srcDecimals - dstDecimals));\\n }\\n }\\n\\n /**\\n * @notice it tries to calculate the price of {src} in {dst}\\n * @param src address of source token\\n * @param dst address of destination token\\n * @return the price of src token in dst\\n */\\n function _chainlinkPriceFor(address src, address dst)\\n private\\n view\\n returns (int256)\\n {\\n (address agg, bool foundAgg, bool inverse) =\\n ChainlinkLib.aggregatorFor(src, dst);\\n if (foundAgg) {\\n uint256 price =\\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\\n if (inverse) {\\n price = (TEN**(resDecimals + resDecimals)) / price;\\n }\\n return\\n SafeCast.toInt256(\\n (_scale(price, resDecimals, _decimalsFor(dst)))\\n );\\n } else {\\n address wrappedNativeToken =\\n AppStorageLib.store().wrappedNativeToken;\\n if (dst != wrappedNativeToken) {\\n int256 price1 = _priceFor(src, wrappedNativeToken);\\n if (price1 > 0) {\\n int256 price2 = _priceFor(dst, wrappedNativeToken);\\n if (price2 > 0) {\\n uint256 dstFactor = TEN**_decimalsFor(dst);\\n return (price1 * int256(dstFactor)) / price2;\\n }\\n }\\n }\\n }\\n\\n return 0;\\n }\\n\\n /**\\n * @notice it checks if a token is a cToken. If it is, then get the underlying address\\n * @param token address of the token\\n * @return isCToken boolean whether it's a cToken\\n * @return underlying the address of the cToken\\n */\\n function _isCToken(address token)\\n private\\n view\\n returns (bool isCToken, address underlying)\\n {\\n isCToken = CompoundLib.isCompoundToken(token);\\n if (isCToken) {\\n underlying = CompoundLib.getUnderlying(token);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xcf6280e2d36fdedbca4c0b94e413832f4bb267202de235bfc1cf6fda26c780ec\",\"license\":\"MIT\"},\"contracts/price-aggregator/PriceAggLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { PriceAggFacet } from \\\"./PriceAggFacet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../storage/app.sol\\\";\\n\\n/**\\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\\n */\\nlibrary PriceAggLib {\\n /**\\n * @notice It calculates the value of one token amount into another\\n * @param src the source token\\n * @param dst the destination token\\n * @param srcAmount the amount of source token\\n * @return value_ the returned value of src in dst\\n */\\n function valueFor(\\n address src,\\n address dst,\\n uint256 srcAmount\\n ) internal view returns (uint256 value_) {\\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\\n }\\n\\n /**\\n * @notice It returns the price of the token pair as given from Compound.\\n * @dev if no compound price is calculated, then it checks Chainlink price Aggregator\\n * @param src the address of the source token\\n * @param dst the address of the desitnation token\\n * @return price_ gets the price of src in dst\\n */\\n function priceFor(address src, address dst)\\n internal\\n view\\n returns (int256 price_)\\n {\\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\\n }\\n}\\n\",\"keccak256\":\"0xff59eee567fa4a7f5cac432e31d918be92834f04614f49572d3984a5b030ac79\",\"license\":\"MIT\"},\"contracts/price-aggregator/chainlink/ChainlinkLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport {\\n PriceAggStorageLib,\\n ChainlinkAggStorage\\n} from \\\"../../storage/price-aggregator.sol\\\";\\n\\nlibrary ChainlinkLib {\\n function s() internal view returns (ChainlinkAggStorage storage) {\\n return PriceAggStorageLib.store().chainlink;\\n }\\n\\n /**\\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\\n * @param src Source token address.\\n * @param dst Destination token address.\\n * @return aggregator The Chainlink Aggregator address.\\n * @return found whether or not the ChainlinkAggregator exists.\\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\\n */\\n function aggregatorFor(address src, address dst)\\n internal\\n view\\n returns (\\n address aggregator,\\n bool found,\\n bool inverse\\n )\\n {\\n aggregator = s().aggregators[src][dst];\\n if (aggregator != address(0)) {\\n found = true;\\n } else {\\n aggregator = s().aggregators[dst][src];\\n if (aggregator != address(0)) {\\n found = true;\\n inverse = true;\\n }\\n }\\n }\\n\\n /**\\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\\n * @param token Token address to check if is supported.\\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\\n */\\n function isTokenSupported(address token)\\n internal\\n view\\n returns (bool isSupported_)\\n {\\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\\n }\\n}\\n\",\"keccak256\":\"0x84fcff4e22dcf0a954794b08f4a5e66cb0b9522a74cccb7d80c07e7032440f42\",\"license\":\"MIT\"},\"contracts/settings/pausable/PausableMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\nabstract contract PausableMods {\\n /**\\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\\n * @param id id of the facet to check if is paused.\\n * @param state Boolean that the protocol AND facet should be in.\\n */\\n modifier paused(bytes32 id, bool state) {\\n require(\\n __isPaused(\\\"\\\") == state && __isPaused(id) == state,\\n __pausedMessage(state)\\n );\\n _;\\n }\\n\\n /**\\n * @dev Checks if the given id is paused.\\n * @param id Encoded id of the facet to check if is paused.\\n * @return the bool to tell us if the facet is paused (true) or not (false)\\n */\\n function __isPaused(bytes32 id) private view returns (bool) {\\n return AppStorageLib.store().paused[id];\\n }\\n\\n /**\\n * @dev Gets the message that should be reverted with given a state it should be in.\\n * @param state Boolean that an id should be in.\\n * @return a message stating whether the facet is paused or not\\n */\\n function __pausedMessage(bool state) private pure returns (string memory) {\\n return state ? \\\"Pausable: not paused\\\" : \\\"Pausable: paused\\\";\\n }\\n}\\n\",\"keccak256\":\"0x2d3f848ee56ae5fa365539c2509c03c167affc89c89f98bb98cb9b83fbe8ae4c\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"NFTInterestRate\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getNFTInterestRate() internal view returns (uint16 value_) {\\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0x44294be1af9f913b2ed391a40cd4b646537a4b463b8d5ff1fac8ead3988966c1\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for loans taken out with an NFT.\\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\\n */\\nbytes32 constant NFT_INTEREST_RATE = keccak256(\\\"NFTInterestRate\\\");\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xd68a7df42b2bbba6f935d5890b7b37997c1432e25ae113827b8bde87f94fd86f\",\"license\":\"MIT\"},\"contracts/shared/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n /**\\n * @notice Checks if the account should be allowed to mint tokens in the given market\\n * @param cToken The market to verify the mint against\\n * @param minter The account which would get the minted tokens\\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates mint and reverts on rejection. May emit logs.\\n * @param cToken Asset being minted\\n * @param minter The address minting the tokens\\n * @param mintAmount The amount of the underlying asset being minted\\n * @param mintTokens The number of tokens being minted\\n */\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to redeem tokens in the given market\\n * @param cToken The market to verify the redeem against\\n * @param redeemer The account which would redeem the tokens\\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates redeem and reverts on rejection. May emit logs.\\n * @param cToken Asset being redeemed\\n * @param redeemer The address redeeming the tokens\\n * @param redeemAmount The amount of the underlying asset being redeemed\\n * @param redeemTokens The number of tokens being redeemed\\n */\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\\n * @param cToken The market to verify the borrow against\\n * @param borrower The account which would borrow the asset\\n * @param borrowAmount The amount of underlying the account would borrow\\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates borrow and reverts on rejection. May emit logs.\\n * @param cToken Asset whose underlying is being borrowed\\n * @param borrower The address borrowing the underlying\\n * @param borrowAmount The amount of the underlying asset requested to borrow\\n */\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to repay a borrow in the given market\\n * @param cToken The market to verify the repay against\\n * @param payer The account which would repay the asset\\n * @param borrower The account which would borrowed the asset\\n * @param repayAmount The amount of the underlying asset the account would repay\\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\\n * @param cToken Asset being repaid\\n * @param payer The address repaying the borrow\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param borrowerIndex the index of the borrower\\n */\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n /**\\n * @notice Checks if the liquidation should be allowed to occur\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n */\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the seizing of assets should be allowed to occur\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates seize and reverts on rejection. May emit logs.\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to transfer tokens in the given market\\n * @param cToken The market to verify the transfer against\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates transfer and reverts on rejection. May emit logs.\\n * @param cToken Asset being transferred\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n */\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in all markets\\n * @param holder The address to claim COMP for\\n */\\n function claimComp(address holder) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in the specified markets\\n * @param holder The address to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n */\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n /**\\n * @notice Claim all comp accrued by the holders\\n * @param holders The addresses to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n * @param borrowers Whether or not to claim COMP earned by borrowing\\n * @param suppliers Whether or not to claim COMP earned by supplying\\n */\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n /**\\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\\n * @param cTokenBorrowed The address of the borrowed cToken\\n * @param cTokenCollateral The address of the collateral cToken\\n * @param repayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\\n */\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n /**\\n * @notice Return the address of the COMP token\\n * @return The address of COMP\\n */\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x38a824a4a21ce9370fa581a616d1bb9d311f27d8982a6b96ebeba90bd5fd0adb\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n\\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x208769886b3db8f03ef1fa26f1caee189038dfc744b9a499402fc4e4c0090c38\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/libraries/CompoundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { ICErc20 } from \\\"../interfaces/ICErc20.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib } from \\\"../../storage/app.sol\\\";\\n\\n/**\\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary CompoundLib {\\n /**\\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\\n */\\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\\n\\n function exchangeRate(address cToken) internal view returns (uint256) {\\n return ICErc20(cToken).exchangeRateStored();\\n }\\n\\n /**\\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param cTokenAmount Amount of the Compound asset.\\n * @return value of the Compound token amount in underlying tokens.\\n */\\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\\n EXCHANGE_RATE_SCALE;\\n }\\n\\n /**\\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\\n * @param cToken Address of the Compound token.\\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\\n * @return value of the underlying amount in Compound tokens.\\n */\\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\\n internal\\n view\\n returns (uint256)\\n {\\n return\\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\\n ICErc20(cToken).exchangeRateStored();\\n }\\n\\n function isCompoundToken(address token) internal view returns (bool) {\\n return AppStorageLib.store().cTokenRegistry[token];\\n }\\n\\n /**\\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\\n * @dev CETH is the only Compound token that does not support the {underlying} function.\\n * @param cToken address of the compound token\\n * @return address of the underlying cToken\\n */\\n function getUnderlying(address cToken) internal view returns (address) {\\n (bool success, bytes memory data) =\\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\\n if (success) {\\n return abi.decode(data, (address));\\n }\\n\\n return AppStorageLib.store().assetAddresses[\\\"WETH\\\"];\\n }\\n}\\n\",\"keccak256\":\"0x99206384c27b0e68b1ec7b82260f6a47965f611875c018bc076ff8a688a6c6d7\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n /**\\n * @notice it returns the absolute number of a specified parameter\\n * @param self the number to be returned in it's absolute\\n * @return the absolute number\\n */\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0x4f750cde25d4b1db919abf3192d58ed6aef617d03637e1e9e2dc31b70dcc32a3\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n address wrappedNativeToken;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4504c5c460972a25cd1f0e6eb1d8dd84a668be75a3aeb89a47a49c2327c12923\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\n// DEPRECATED\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\nstruct LoanRequest {\\n LoanUserRequest request;\\n LoanConsensusResponse[] responses;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanUserRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanConsensusResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) _loanTerms; // DEPRECATED: DO NOT REMOVE\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb7e05aeec806b5621512def93f4a389b4ef88c50ef9fe7115a33f57db2f2304b\",\"license\":\"MIT\"},\"contracts/storage/nft.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"../nft/TellerNFTDictionary.sol\\\";\\n\\n// Utils\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct NFTStorage {\\n // Maps NFT owner to set of token IDs owned\\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\\n // Maps loanID to NFT IDs indicating NFT being used for the loan\\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\\n // Merkle root used for verifying nft IDs to base loan size\\n TellerNFTDictionary nftDictionary;\\n}\\n\\nbytes32 constant NFT_STORAGE_POS = keccak256(\\\"teller.staking.storage\\\");\\n\\nlibrary NFTStorageLib {\\n function store() internal pure returns (NFTStorage storage s) {\\n bytes32 pos = NFT_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd44f213be3125ea2e2de120c241832f1861be18b3ff2fd4c3baa52ea20b94812\",\"license\":\"MIT\"},\"contracts/storage/price-aggregator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct ChainlinkAggStorage {\\n // Maps source token => destination token => Chainlink Aggregator\\n mapping(address => mapping(address => address)) aggregators;\\n // Maps token address to number of supported Chainlink pairs\\n mapping(address => uint256) pairCount;\\n // Stores set of token addresses supported by Chainlink\\n EnumerableSet.AddressSet supportedTokens;\\n}\\n\\nstruct PriceAggStorage {\\n ChainlinkAggStorage chainlink;\\n}\\n\\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\\n \\\"teller.price.aggregator.storage\\\"\\n);\\n\\nlibrary PriceAggStorageLib {\\n function store() internal pure returns (PriceAggStorage storage s) {\\n bytes32 pos = PRICE_AGG_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0x39a2c6e514cbc48d03f8de560a855527ddf9cd08e2042a75e5c1820a6298d4a1\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "params": { + "borrower": "Account address of the borrower", + "liquidator": "Account address of the liquidator", + "loanID": "ID of loan from which collateral was withdrawn", + "reward": "Value in lending token paid out to liquidator", + "tokensIn": "Percentage of the collateral price paid by the liquidator to the lending pool" + } + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "params": { + "amountPaid": "Amount of the loan paid back", + "borrower": "Account address of the borrower", + "loanID": "ID of loan from which collateral was withdrawn", + "payer": "Account address of the payer", + "totalOwed": "Total amount of the loan to be repaid" + } + } + }, + "kind": "dev", + "methods": { + "claimTokens(uint256)": { + "params": { + "loanID": "The id of the loan being used." + } + }, + "escrowRepay(uint256,uint256)": { + "details": "If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.", + "params": { + "amount": "The amount being repaid.", + "loanID": "The id of the loan being used." + } + }, + "getLiquidationReward(uint256)": { + "params": { + "loanID": "The loan ID to get the info." + }, + "returns": { + "inCollateral_": "The value the liquidator will receive denoted in collateral tokens.", + "inLending_": "The value the liquidator will receive denoted in lending tokens." + } + }, + "liquidateLoan(uint256)": { + "params": { + "loanID": "The ID of the loan to be liquidated" + } + }, + "repayLoan(uint256,uint256)": { + "params": { + "amount": "The amount of tokens to pay back to the loan", + "loanID": "The ID of the loan the payment is for" + } + } + }, + "version": 1 + }, + "userdoc": { + "events": { + "LoanLiquidated(uint256,address,address,uint256,uint256)": { + "notice": "This event is emitted when a loan has been successfully liquidated" + }, + "LoanRepaid(uint256,address,uint256,address,uint256)": { + "notice": "This event is emitted when a loan has been successfully repaid" + }, + "TokensClaimed(address)": { + "notice": "Notifies when the Escrow's tokens have been claimed." + } + }, + "kind": "user", + "methods": { + "claimTokens(uint256)": { + "notice": "Sends the tokens owned by this escrow to the owner." + }, + "escrowRepay(uint256,uint256)": { + "notice": "Repay this Escrow's loan." + }, + "getLiquidationReward(uint256)": { + "notice": "It gets the current liquidation reward for a given loan." + }, + "liquidateLoan(uint256)": { + "notice": "Liquidate a loan if it is expired or under collateralized" + }, + "repayLoan(uint256,uint256)": { + "notice": "Make a payment to a loan" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/SettingsFacet.json b/deployments/polygon_mumbai/SettingsFacet.json new file mode 100644 index 000000000..849047168 --- /dev/null +++ b/deployments/polygon_mumbai/SettingsFacet.json @@ -0,0 +1,311 @@ +{ + "address": "0x00C864C47Ed6B60f8C0588Da0d1065fB87d69B80", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + }, + { + "internalType": "address", + "name": "wrappedNativeToken", + "type": "address" + }, + { + "internalType": "address", + "name": "nftDictionary", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "SettingsFacet", + "transactionHash": "0x7982cec9a9dafaac8c53c681979b487f9b0b790e802e3387440f03e24e43963b", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x00C864C47Ed6B60f8C0588Da0d1065fB87d69B80", + "transactionIndex": 0, + "gasUsed": "624842", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000800100000000000000000100000000004000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000080000000000000000000200000000000000000000000000000000000000000000000000000000000004000000000000100000001000000000000000000000000000000100040000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0x1c7f5890b7ea22153d23279d81271f6559ff20be61b9319ee9a76cdd84688d0e", + "transactionHash": "0x7982cec9a9dafaac8c53c681979b487f9b0b790e802e3387440f03e24e43963b", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692438, + "transactionHash": "0x7982cec9a9dafaac8c53c681979b487f9b0b790e802e3387440f03e24e43963b", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000be188d6641e8b680743a4815dfa0f6208038960f" + ], + "data": "0x000000000000000000000000000000000000000000000000004298b6f385b8000000000000000000000000000000000000000000000000003fc833814308340000000000000000000000000000000000000000000000007e5885ec1a291dc5500000000000000000000000000000000000000000000000003f859aca4f827c0000000000000000000000000000000000000000000000007e58c884d11ca37d50", + "logIndex": 0, + "blockHash": "0x1c7f5890b7ea22153d23279d81271f6559ff20be61b9319ee9a76cdd84688d0e" + } + ], + "blockNumber": 15692438, + "cumulativeGasUsed": "624842", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"restriction\",\"type\":\"bool\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pauser\",\"type\":\"address\"}],\"name\":\"PlatformRestricted\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"addAuthorizedAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"addressesToAdd\",\"type\":\"address[]\"}],\"name\":\"addAuthorizedAddressList\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getNFTLiquidationController\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"controller_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"hasAuthorization\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"string\",\"name\":\"sym\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"internalType\":\"struct InitAssets[]\",\"name\":\"assets\",\"type\":\"tuple[]\"},{\"internalType\":\"address[]\",\"name\":\"cTokens\",\"type\":\"address[]\"},{\"internalType\":\"address\",\"name\":\"tellerNFT\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"loansEscrowBeacon\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"collateralEscrowBeacon\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tTokenBeacon\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"nftLiquidationController\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"wrappedNativeToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"nftDictionary\",\"type\":\"address\"}],\"internalType\":\"struct InitArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"name\":\"init\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"removeAuthorizedAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newController\",\"type\":\"address\"}],\"name\":\"setNFTLiquidationController\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"PlatformRestricted(bool,address)\":{\"params\":{\"pauser\":\"address of the pauser flipping the switch\",\"restriction\":\"Boolean representing the state of the restriction\"}}},\"kind\":\"dev\",\"methods\":{\"addAuthorizedAddress(address)\":{\"params\":{\"account\":\"The wallet address of the user being authorized\"}},\"addAuthorizedAddressList(address[])\":{\"params\":{\"addressesToAdd\":\"The list of wallet addresses being authorized\"}},\"getNFTLiquidationController()\":{\"returns\":{\"controller_\":\"The address where NFTs are be transferred.\"}},\"hasAuthorization(address)\":{\"params\":{\"account\":\"The account address to check for\"},\"returns\":{\"_0\":\"True if account has authorization, false if it does not\"}},\"init((address,(string,address)[],address[],address,address,address,address,address,address,address))\":{\"params\":{\"_args\":\"multiple arguments that are stored in the AppStorageLibrary\"}},\"removeAuthorizedAddress(address)\":{\"params\":{\"account\":\"The wallet address of the user being unauthorized\"}},\"setNFTLiquidationController(address)\":{\"params\":{\"newController\":\"The address where NFTs should be transferred.\"}}},\"version\":1},\"userdoc\":{\"events\":{\"PlatformRestricted(bool,address)\":{\"notice\":\"This event is emitted when the platform restriction is switched\"}},\"kind\":\"user\",\"methods\":{\"addAuthorizedAddress(address)\":{\"notice\":\"Adds a wallet address to the list of authorized wallets\"},\"addAuthorizedAddressList(address[])\":{\"notice\":\"Adds a list of wallet addresses to the list of authorized wallets\"},\"getNFTLiquidationController()\":{\"notice\":\"Gets the new address where NFTs are sent when used for taking out a loan and gets liquidated.\"},\"hasAuthorization(address)\":{\"notice\":\"Tests whether an account has authorization\"},\"init((address,(string,address)[],address[],address,address,address,address,address,address,address))\":{\"notice\":\"it stores multiple parameters in the AppStorageLib\"},\"removeAuthorizedAddress(address)\":{\"notice\":\"Removes a wallet address from the list of authorized wallets\"},\"setNFTLiquidationController(address)\":{\"notice\":\"Sets a new address to which NFTs should be sent when used for taking out a loan and gets liquidated.\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/settings/SettingsFacet.sol\":\"SettingsFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Trees proofs.\\n *\\n * The proofs can be generated using the JavaScript library\\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\\n *\\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n bytes32 computedHash = leaf;\\n\\n for (uint256 i = 0; i < proof.length; i++) {\\n bytes32 proofElement = proof[i];\\n\\n if (computedHash <= proofElement) {\\n // Hash(current computed hash + current element of the proof)\\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\\n } else {\\n // Hash(current element of the proof + current computed hash)\\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\\n }\\n }\\n\\n // Check if the computed hash (root) is equal to the provided root\\n return computedHash == root;\\n }\\n}\\n\",\"keccak256\":\"0xeee34bfb413657b6cd6c8e1e15c2080ba5ebaac479578515922804346fb63f7c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/nft/IStakeableNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IStakeableNFT {\\n function tokenBaseLoanSize(uint256 tokenId) external view returns (uint256);\\n\\n function tokenURIHash(uint256 tokenId)\\n external\\n view\\n returns (string memory);\\n\\n function tokenContributionAsset(uint256 tokenId)\\n external\\n view\\n returns (address);\\n\\n function tokenContributionSize(uint256 tokenId)\\n external\\n view\\n returns (uint256);\\n\\n function tokenContributionMultiplier(uint256 tokenId)\\n external\\n view\\n returns (uint8);\\n}\\n\",\"keccak256\":\"0xfbf44350ad91a54de26f39195d714580d7dade556ea4c7991a51eef5aa839105\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x417b75f5d92be67993efc54db7d453be5b5058a9a54d8916380e0281d3299526\",\"license\":\"MIT\"},\"contracts/nft/TellerNFTDictionary.sol\":{\"content\":\"/**\\n * @notice TellerNFTDictionary Version 1.02\\n *\\n * @notice This contract is used to gather data for TellerV1 NFTs more efficiently.\\n * @notice This contract has data which must be continuously synchronized with the TellerV1 NFT data\\n *\\n * @author develop@teller.finance\\n */\\n\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Interfaces\\nimport \\\"./IStakeableNFT.sol\\\";\\n\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFTDictionary is IStakeableNFT, AccessControlUpgradeable {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n mapping(uint256 => uint256) public baseLoanSizes;\\n mapping(uint256 => string[]) public hashes;\\n mapping(uint256 => address) public contributionAssets;\\n mapping(uint256 => uint256) public contributionSizes;\\n mapping(uint256 => uint8) public contributionMultipliers;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n\\n /* State Variables */\\n\\n mapping(uint256 => uint256) public _tokenTierMappingCompressed;\\n bool public _tokenTierMappingCompressedSet;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFTDictionary: not admin\\\");\\n _;\\n }\\n\\n function initialize(address initialAdmin) public {\\n _setupRole(ADMIN, initialAdmin);\\n _setRoleAdmin(ADMIN, ADMIN);\\n\\n __AccessControl_init();\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTierIndex(uint256 tokenId)\\n public\\n view\\n returns (uint8 index_)\\n {\\n //32 * 8 = 256 - each uint256 holds the data of 32 tokens . 8 bits each.\\n\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 compressedRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n //use 31 instead of 32 to account for the '0x' in the start.\\n //the '31 -' reverses our bytes order which is necessary\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint8 tierIndex = uint8((compressedRegister >> offset));\\n\\n return tierIndex;\\n }\\n\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory)\\n {\\n return hashes[tierIndex];\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTier(uint256 index, Tier memory newTier)\\n external\\n onlyAdmin\\n returns (bool)\\n {\\n baseLoanSizes[index] = newTier.baseLoanSize;\\n hashes[index] = newTier.hashes;\\n contributionAssets[index] = newTier.contributionAsset;\\n contributionSizes[index] = newTier.contributionSize;\\n contributionMultipliers[index] = newTier.contributionMultiplier;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param tiersMapping Information about the new tiers to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setAllTokenTierMappings(uint256[] memory tiersMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n require(\\n !_tokenTierMappingCompressedSet,\\n \\\"TellerNFTDictionary: token tier mapping already set\\\"\\n );\\n for (uint256 i = 0; i < tiersMapping.length; i++) {\\n _tokenTierMappingCompressed[i] = tiersMapping[i];\\n }\\n\\n _tokenTierMappingCompressedSet = true;\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param index the mapping row, each holds data for 32 tokens\\n * @param tierMapping Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierMapping(uint256 index, uint256 tierMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n _tokenTierMappingCompressed[index] = tierMapping;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenIds the NFT token Ids for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenIds(\\n uint256[] calldata tokenIds,\\n uint256 tokenTier\\n ) public onlyAdmin returns (bool) {\\n for (uint256 i; i < tokenIds.length; i++) {\\n setTokenTierForTokenId(tokenIds[i], tokenTier);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenId the NFT token Id for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenId(uint256 tokenId, uint256 tokenTier)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 existingRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint256 updateMaskShifted =\\n 0x00000000000000000000000000000000000000000000000000000000000000FF <<\\n offset;\\n\\n uint256 updateMaskShiftedNegated = ~updateMaskShifted;\\n\\n uint256 tokenTierShifted =\\n ((0x0000000000000000000000000000000000000000000000000000000000000000 |\\n tokenTier) << offset);\\n\\n uint256 existingRegisterClearedWithMask =\\n existingRegister & updateMaskShiftedNegated;\\n\\n uint256 updatedRegister =\\n existingRegisterClearedWithMask | tokenTierShifted;\\n\\n _tokenTierMappingCompressed[mappingIndex] = updatedRegister;\\n\\n return true;\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(IStakeableNFT).interfaceId ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n New methods for the dictionary\\n */\\n\\n /**\\n * @notice It returns Base Loan Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenBaseLoanSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return baseLoanSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Token URI Hash for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenURIHash(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n string[] memory tierImageHashes = hashes[tokenTier];\\n return tierImageHashes[tokenId % (tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice It returns Contribution Asset for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionAsset(uint256 tokenId)\\n public\\n view\\n override\\n returns (address)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionAssets[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Multiplier for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionMultiplier(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint8)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionMultipliers[tokenTier];\\n }\\n}\\n\",\"keccak256\":\"0xf33e3fa1f609fdd2abb3b5fb9c232269d13363a3e4fa5697ea96269e361e74fa\"},\"contracts/nft/libraries/NFTLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../TellerNFT.sol\\\";\\n\\n// Libraries\\nimport {\\n MerkleProof\\n} from \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../../storage/app.sol\\\";\\nimport { NFTStorageLib, NFTStorage } from \\\"../../storage/nft.sol\\\";\\n\\nlibrary NFTLib {\\n function s() internal pure returns (NFTStorage storage s_) {\\n s_ = NFTStorageLib.store();\\n }\\n\\n function nft() internal view returns (TellerNFT nft_) {\\n nft_ = AppStorageLib.store().nft;\\n }\\n\\n /**s\\n * @notice it transfers the NFT from the sender to the diamond to stake then adds the NFTID to the list of the owner's stakedNFTs\\n * @param nftID the ID of the NFT to stake\\n * @param owner the owner of the NFT who will stake the NFT\\n */\\n function stake(uint256 nftID, address owner) internal {\\n // Transfer to diamond\\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\\n // Add NFT ID to user set\\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\\n }\\n\\n /**\\n * @notice it unstakes the NFT by removing the NFT ID from the list of the user's staked NFTs\\n * @param nftID the ID of the NFT to remove from the list of the user's staked NFTs\\n * @return success_ the boolean value telling us if the user has unsuccessfully unstaked the NFT\\n */\\n function unstake(uint256 nftID) internal returns (bool success_) {\\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\\n }\\n\\n /**\\n * @notice it gets the list of staked NFTs from the owner\\n * @param nftOwner the owner of the staked NFTs to pull from\\n * @return staked_ the array of the staked NFTs owned by the user\\n */\\n function stakedNFTs(address nftOwner)\\n internal\\n view\\n returns (uint256[] memory staked_)\\n {\\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\\n staked_ = new uint256[](EnumerableSet.length(nfts));\\n for (uint256 i; i < staked_.length; i++) {\\n staked_[i] = EnumerableSet.at(nfts, i);\\n }\\n }\\n\\n /**\\n * @notice if the user fails to pay his loan, then we liquidate the all the NFTs associated with the loan\\n * @param loanID the identifier of the loan to liquidate the NFTs from\\n */\\n function liquidateNFT(uint256 loanID) internal {\\n // Check if NFTs are linked\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n NFTLib.nft().transferFrom(\\n address(this),\\n AppStorageLib.store().nftLiquidationController,\\n EnumerableSet.at(nfts, i)\\n );\\n }\\n }\\n\\n /**\\n * @notice it unstakes an NFT and verifies the proof in order to apply the proof to a loan\\n * @param loanID the identifier of the loan\\n * @param nftID the NFT ID to apply to the loan\\n */\\n function applyToLoan(uint256 loanID, uint256 nftID) internal {\\n // NFT must be currently staked\\n // Remove NFT from being staked - returns bool\\n require(unstake(nftID), \\\"Teller: borrower nft not staked\\\");\\n\\n // Apply NFT to loan\\n EnumerableSet.add(s().loanNFTs[loanID], nftID);\\n }\\n\\n /**\\n * @notice it finds the loan's NFTs and adds them back to the owner's list of staked NFTs\\n * @param loanID the identifier of the respective loan to add the NFTs back to the user's staked NFTs\\n * @param owner the owner to add the unstaked NFTs back to the staked pile\\n */\\n function restakeLinked(uint256 loanID, address owner) internal {\\n // Get linked NFT\\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\\n // Restake the NFT\\n EnumerableSet.add(s().stakedNFTs[owner], EnumerableSet.at(nfts, i));\\n }\\n }\\n}\\n\",\"keccak256\":\"0xccbd35c6e8d0130b38f5025ee81c47d55e4fa48c8fcb8bec6f70c21061e0ce61\",\"license\":\"MIT\"},\"contracts/settings/SettingsFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { RolesMods } from \\\"../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, PAUSER, AUTHORIZED } from \\\"../shared/roles.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\nimport { TellerNFTDictionary } from \\\"../nft/TellerNFTDictionary.sol\\\";\\n\\n// Interfaces\\nimport { IUniswapV2Router } from \\\"../shared/interfaces/IUniswapV2Router.sol\\\";\\n\\n// Libraries\\nimport { RolesLib } from \\\"../contexts2/access-control/roles/RolesLib.sol\\\";\\nimport { NFTLib } from \\\"../nft/libraries/NFTLib.sol\\\";\\n\\n// Storage\\nimport { AppStorageLib, AppStorage } from \\\"../storage/app.sol\\\";\\n\\nstruct InitAssets {\\n string sym;\\n address addr;\\n}\\n\\nstruct InitArgs {\\n address admin;\\n InitAssets[] assets;\\n address[] cTokens;\\n address tellerNFT;\\n address loansEscrowBeacon;\\n address collateralEscrowBeacon;\\n address tTokenBeacon;\\n address nftLiquidationController;\\n address wrappedNativeToken;\\n address nftDictionary;\\n}\\n\\ncontract SettingsFacet is RolesMods {\\n /**\\n * @notice This event is emitted when the platform restriction is switched\\n * @param restriction Boolean representing the state of the restriction\\n * @param pauser address of the pauser flipping the switch\\n */\\n event PlatformRestricted(bool restriction, address indexed pauser);\\n\\n /**\\n * @notice Restricts the use of the Teller protocol to authorized wallet addresses only\\n * @param restriction Bool turning the resitriction on or off\\n */\\n function restrictPlatform(bool restriction)\\n internal\\n authorized(ADMIN, msg.sender)\\n {\\n AppStorageLib.store().platformRestricted = restriction;\\n emit PlatformRestricted(restriction, msg.sender);\\n }\\n\\n /**\\n * @notice Adds a wallet address to the list of authorized wallets\\n * @param account The wallet address of the user being authorized\\n */\\n function addAuthorizedAddress(address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(AUTHORIZED, account);\\n }\\n\\n /**\\n * @notice Adds a list of wallet addresses to the list of authorized wallets\\n * @param addressesToAdd The list of wallet addresses being authorized\\n */\\n function addAuthorizedAddressList(address[] calldata addressesToAdd)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n for (uint256 i; i < addressesToAdd.length; i++) {\\n RolesLib.grantRole(AUTHORIZED, addressesToAdd[i]);\\n }\\n }\\n\\n /**\\n * @notice Removes a wallet address from the list of authorized wallets\\n * @param account The wallet address of the user being unauthorized\\n */\\n function removeAuthorizedAddress(address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(AUTHORIZED, account);\\n }\\n\\n /**\\n * @notice Tests whether an account has authorization\\n * @param account The account address to check for\\n * @return True if account has authorization, false if it does not\\n */\\n function hasAuthorization(address account) external view returns (bool) {\\n return RolesLib.hasRole(AUTHORIZED, account);\\n }\\n\\n /**\\n * @notice Sets a new address to which NFTs should be sent when used for taking out a loan and gets liquidated.\\n * @param newController The address where NFTs should be transferred.\\n */\\n function setNFTLiquidationController(address newController)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n AppStorageLib.store().nftLiquidationController = newController;\\n }\\n\\n /**\\n * @notice Gets the new address where NFTs are sent when used for taking out a loan and gets liquidated.\\n * @return controller_ The address where NFTs are be transferred.\\n */\\n function getNFTLiquidationController()\\n external\\n returns (address controller_)\\n {\\n controller_ = AppStorageLib.store().nftLiquidationController;\\n }\\n\\n /**\\n * @notice it stores multiple parameters in the AppStorageLib\\n * @param _args multiple arguments that are stored in the AppStorageLibrary\\n */\\n function init(InitArgs calldata _args) external {\\n AppStorage storage s = AppStorageLib.store();\\n\\n if (s.initialized) return;\\n s.initialized = true;\\n\\n RolesLib.grantRole(ADMIN, _args.admin);\\n RolesLib.grantRole(PAUSER, _args.admin);\\n\\n for (uint256 i; i < _args.assets.length; i++) {\\n s.assetAddresses[_args.assets[i].sym] = _args.assets[i].addr;\\n }\\n for (uint256 i; i < _args.cTokens.length; i++) {\\n s.cTokenRegistry[_args.cTokens[i]] = true;\\n }\\n\\n s.nft = TellerNFT(_args.tellerNFT);\\n s.loansEscrowBeacon = UpgradeableBeaconFactory(_args.loansEscrowBeacon);\\n s.collateralEscrowBeacon = UpgradeableBeaconFactory(\\n _args.collateralEscrowBeacon\\n );\\n s.tTokenBeacon = UpgradeableBeaconFactory(_args.tTokenBeacon);\\n s.nftLiquidationController = _args.nftLiquidationController;\\n s.wrappedNativeToken = _args.wrappedNativeToken;\\n\\n NFTLib.s().nftDictionary = TellerNFTDictionary(_args.nftDictionary);\\n }\\n}\\n\",\"keccak256\":\"0xf4764030b2b81ead7cdb44b82fc1fc3890a9b13a81728462e359238724317633\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"NFTInterestRate\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getNFTInterestRate() internal view returns (uint16 value_) {\\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0x44294be1af9f913b2ed391a40cd4b646537a4b463b8d5ff1fac8ead3988966c1\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for loans taken out with an NFT.\\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\\n */\\nbytes32 constant NFT_INTEREST_RATE = keccak256(\\\"NFTInterestRate\\\");\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xd68a7df42b2bbba6f935d5890b7b37997c1432e25ae113827b8bde87f94fd86f\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n\\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x208769886b3db8f03ef1fa26f1caee189038dfc744b9a499402fc4e4c0090c38\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n address wrappedNativeToken;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4504c5c460972a25cd1f0e6eb1d8dd84a668be75a3aeb89a47a49c2327c12923\",\"license\":\"MIT\"},\"contracts/storage/nft.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"../nft/TellerNFTDictionary.sol\\\";\\n\\n// Utils\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\nstruct NFTStorage {\\n // Maps NFT owner to set of token IDs owned\\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\\n // Maps loanID to NFT IDs indicating NFT being used for the loan\\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\\n // Merkle root used for verifying nft IDs to base loan size\\n TellerNFTDictionary nftDictionary;\\n}\\n\\nbytes32 constant NFT_STORAGE_POS = keccak256(\\\"teller.staking.storage\\\");\\n\\nlibrary NFTStorageLib {\\n function store() internal pure returns (NFTStorage storage s) {\\n bytes32 pos = NFT_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd44f213be3125ea2e2de120c241832f1861be18b3ff2fd4c3baa52ea20b94812\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "events": { + "PlatformRestricted(bool,address)": { + "params": { + "pauser": "address of the pauser flipping the switch", + "restriction": "Boolean representing the state of the restriction" + } + } + }, + "kind": "dev", + "methods": { + "addAuthorizedAddress(address)": { + "params": { + "account": "The wallet address of the user being authorized" + } + }, + "addAuthorizedAddressList(address[])": { + "params": { + "addressesToAdd": "The list of wallet addresses being authorized" + } + }, + "getNFTLiquidationController()": { + "returns": { + "controller_": "The address where NFTs are be transferred." + } + }, + "hasAuthorization(address)": { + "params": { + "account": "The account address to check for" + }, + "returns": { + "_0": "True if account has authorization, false if it does not" + } + }, + "init((address,(string,address)[],address[],address,address,address,address,address,address,address))": { + "params": { + "_args": "multiple arguments that are stored in the AppStorageLibrary" + } + }, + "removeAuthorizedAddress(address)": { + "params": { + "account": "The wallet address of the user being unauthorized" + } + }, + "setNFTLiquidationController(address)": { + "params": { + "newController": "The address where NFTs should be transferred." + } + } + }, + "version": 1 + }, + "userdoc": { + "events": { + "PlatformRestricted(bool,address)": { + "notice": "This event is emitted when the platform restriction is switched" + } + }, + "kind": "user", + "methods": { + "addAuthorizedAddress(address)": { + "notice": "Adds a wallet address to the list of authorized wallets" + }, + "addAuthorizedAddressList(address[])": { + "notice": "Adds a list of wallet addresses to the list of authorized wallets" + }, + "getNFTLiquidationController()": { + "notice": "Gets the new address where NFTs are sent when used for taking out a loan and gets liquidated." + }, + "hasAuthorization(address)": { + "notice": "Tests whether an account has authorization" + }, + "init((address,(string,address)[],address[],address,address,address,address,address,address,address))": { + "notice": "it stores multiple parameters in the AppStorageLib" + }, + "removeAuthorizedAddress(address)": { + "notice": "Removes a wallet address from the list of authorized wallets" + }, + "setNFTLiquidationController(address)": { + "notice": "Sets a new address to which NFTs should be sent when used for taking out a loan and gets liquidated." + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/SignersFacet.json b/deployments/polygon_mumbai/SignersFacet.json new file mode 100644 index 000000000..c994ad050 --- /dev/null +++ b/deployments/polygon_mumbai/SignersFacet.json @@ -0,0 +1,148 @@ +{ + "address": "0xF1743209a10923d484b5e9B65e1Caf4eF7f6C372", + "abi": [ + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + } + ], + "artifactName": "SignersFacet", + "transactionHash": "0x974aa2f69a0a79a53c272be042f98ee30303f97e3e949b7f4f37b03ba395c5b5", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0xF1743209a10923d484b5e9B65e1Caf4eF7f6C372", + "transactionIndex": 0, + "gasUsed": "242576", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000002000000000000000000000000000000000000000000000000000800100000000000000040100000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000040000000004000000000000100000001000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0xd18544d61fd7ccad3310a9c22abf42f7d9a4ae4e3038df2de937723100902cc2", + "transactionHash": "0x974aa2f69a0a79a53c272be042f98ee30303f97e3e949b7f4f37b03ba395c5b5", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692481, + "transactionHash": "0x974aa2f69a0a79a53c272be042f98ee30303f97e3e949b7f4f37b03ba395c5b5", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000c275dc8be39f50d12f66b6a63629c39da5bae5bd" + ], + "data": "0x0000000000000000000000000000000000000000000000000019daa5c954c0000000000000000000000000000000000000000000000000003b1a440a9c9b24000000000000000000000000000000000000000000000000b416c049c684e515d50000000000000000000000000000000000000000000000003b006964d34664000000000000000000000000000000000000000000000000b416da246c4e39d5d5", + "logIndex": 0, + "blockHash": "0xd18544d61fd7ccad3310a9c22abf42f7d9a4ae4e3038df2de937723100902cc2" + } + ], + "blockNumber": 15692481, + "cumulativeGasUsed": "242576", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"addSigner\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"address[]\",\"name\":\"accounts\",\"type\":\"address[]\"}],\"name\":\"addSigners\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isSigner\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"isSigner_\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"addSigner(address,address)\":{\"details\":\"The sender must be the owner.It throws a require error if the sender is not the owner.\",\"params\":{\"account\":\"address to add.\",\"asset\":\"Token address to add signers for.\"}},\"addSigners(address,address[])\":{\"details\":\"The sender must be the owner.It throws a require error if the sender is not the owner.\",\"params\":{\"accounts\":\"addresses to add.\",\"asset\":\"Token address to add signers for.\"}},\"isSigner(address,address)\":{\"params\":{\"account\":\"the account to check in the list of the asset's signers\",\"asset\":\"the asset to check for if the signer exists\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"addSigner(address,address)\":{\"notice\":\"It adds a new account as a signer.\"},\"addSigners(address,address[])\":{\"notice\":\"It adds a list of account as signers.\"},\"isSigner(address,address)\":{\"notice\":\"it checks if an account is already in the list of the asset's signers\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/market/SignersFacet.sol\":\"SignersFacet\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n /**\\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\\n * @param dappAddress address of the target contract address\\n * @param dappData encoded abi of the function in our contract we want to call\\n * @return the called data in bytes\\n */\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n /**\\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\\n * @param token address of the respective ERC20 token to approve for the spender\\n * @param spender address of the respective spender who is approved by the token contract\\n */\\n function setTokenAllowance(address token, address spender) external;\\n\\n /**\\n * @notice it allows user to claim their escrow tokens\\n * @dev only the owner (TellerDiamond) can make this call on behalf of the users\\n * @param token address of the respective token contract to claim tokens from\\n * @param to address where the tokens should be transferred to\\n * @param amount uint256 amount of tokens to be claimed\\n */\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xaf67fc4454ffaa4d2f7e46fe7101876e8ebdb1a5426c30f87b8e18cc573ac019\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when a user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when a user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n * @return ERC20 token\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n * @return balance_ the balance of the account\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice It calculates the total supply of the underlying asset.\\n * @return totalSupply_ the total supply denoted in the underlying asset.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given market.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n \\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfill the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n * @return mintAmount_ the amount minted of the specified token\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n * @return address of the strategy contract\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n * @param state boolean value that resembles the platform's state\\n */\\n function restrict(bool state) external virtual;\\n\\n /**\\n * @notice it initializes the Teller Token\\n * @param admin address of the admin to the respective Teller Token\\n * @param underlying address of the ERC20 token\\n */\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xf30ac4ef491851477ff9a3dd04974ebe74b529c37a3ef4e05798c3f734ceeb3d\",\"license\":\"MIT\"},\"contracts/market/SignersFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Storage\\nimport { MarketStorageLib } from \\\"../storage/market.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\ncontract SignersFacet {\\n /**\\n * @notice It adds a new account as a signer.\\n * @param asset Token address to add signers for.\\n * @param account address to add.\\n * @dev The sender must be the owner.\\n * @dev It throws a require error if the sender is not the owner.\\n */\\n function addSigner(address asset, address account) external {\\n _addSigner(asset, account);\\n }\\n\\n /**\\n * @notice It adds a list of account as signers.\\n * @param asset Token address to add signers for.\\n * @param accounts addresses to add.\\n * @dev The sender must be the owner.\\n * @dev It throws a require error if the sender is not the owner.\\n */\\n function addSigners(address asset, address[] calldata accounts) external {\\n for (uint256 i; i < accounts.length; i++) {\\n _addSigner(asset, accounts[i]);\\n }\\n }\\n\\n /**\\n * @notice it adds an account to a list of signers for an asset\\n * @param asset is the token address to check for signers\\n * @param account is the account address of the signer\\n */\\n function _addSigner(address asset, address account) internal {\\n if (!isSigner(asset, account)) {\\n EnumerableSet.add(MarketStorageLib.store().signers[asset], account);\\n }\\n }\\n\\n /**\\n * @notice it checks if an account is already in the list of the asset's signers\\n * @param asset the asset to check for if the signer exists\\n * @param account the account to check in the list of the asset's signers\\n */\\n function isSigner(address asset, address account)\\n public\\n view\\n returns (bool isSigner_)\\n {\\n isSigner_ = EnumerableSet.contains(\\n MarketStorageLib.store().signers[asset],\\n account\\n );\\n }\\n}\\n\",\"keccak256\":\"0x5685cd92df88ac39171f7db282a658992402c93d666def412a345594e7e47105\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n /**\\n * @notice it initializes an escrow\\n * @param tokenAddress the address of the collateral token to be stored\\n * @param isWETH check if it's wrapped Ethereum\\n */\\n function init(address tokenAddress, bool isWETH) external;\\n\\n /**\\n * @notice it deposits an amount of the respective collateral token into the escrow\\n * @param loanID the ID of the loan\\n * @param amount the amount of collateral tokens to be deposited\\n */\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n /**\\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\\n * @dev only the TellerDiamond can make this call on behalf of the borrower\\n * @param loanID identifier of the loan\\n * @param amount number of collateral tokens to send\\n * @param receiver payable address to transfer money to\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n /**\\n * @notice it returns the supply of the respective loan\\n * @param loanID the respective loan ID\\n * @return supply_ the amount in collateral of the respective loan\\n */\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n /**\\n * @notice it returns the total supply of the collateral token held by the contract\\n * @return supply_ the total amount of collateral\\n */\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x900fed2311f919ba1451a6583ddbf9f3bc8afa8f5189500fff51f0c049258ed3\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n /**\\n * @notice it returns the absolute number of a specified parameter\\n * @param self the number to be returned in it's absolute\\n * @return the absolute number\\n */\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0x4f750cde25d4b1db919abf3192d58ed6aef617d03637e1e9e2dc31b70dcc32a3\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\n// DEPRECATED\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\nstruct LoanRequest {\\n LoanUserRequest request;\\n LoanConsensusResponse[] responses;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanUserRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanConsensusResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) _loanTerms; // DEPRECATED: DO NOT REMOVE\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb7e05aeec806b5621512def93f4a389b4ef88c50ef9fe7115a33f57db2f2304b\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "0x608060405234801561001057600080fd5b5061036d806100206000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c80632239f5561461004657806346efd16c1461005b57806378b248e41461006e575b600080fd5b61005961005436600461025d565b610095565b005b61005961006936600461028f565b6100a3565b61008161007c36600461025d565b610104565b604051901515815260200160405180910390f35b61009f828261014c565b5050565b60005b818110156100fe576100ec848484848181106100d257634e487b7160e01b600052603260045260246000fd5b90506020020160208101906100e79190610243565b61014c565b806100f681610310565b9150506100a6565b50505050565b6001600160a01b03821660009081527f0553069f1f0518e59f8623c18c83a1f987f2a0544d563e98dd803a7078142a8e6020526040812061014590836101a0565b9392505050565b6101568282610104565b61009f576001600160a01b03821660009081527f0553069f1f0518e59f8623c18c83a1f987f2a0544d563e98dd803a7078142a8e6020526040902061019b90826101c8565b505050565b6001600160a01b03811660009081526001830160205260408120541515610145565b92915050565b6000610145836001600160a01b038416600081815260018301602052604081205461021f575081546001818101845560008481526020808220909301849055845484825282860190935260409020919091556101c2565b5060006101c2565b80356001600160a01b038116811461023e57600080fd5b919050565b600060208284031215610254578081fd5b61014582610227565b6000806040838503121561026f578081fd5b61027883610227565b915061028660208401610227565b90509250929050565b6000806000604084860312156102a3578081fd5b6102ac84610227565b9250602084013567ffffffffffffffff808211156102c8578283fd5b818601915086601f8301126102db578283fd5b8135818111156102e9578384fd5b8760208260051b85010111156102fd578384fd5b6020830194508093505050509250925092565b600060001982141561033057634e487b7160e01b81526011600452602481fd5b506001019056fea2646970667358221220a8e0b1e793648a0e140e218f561e33c64d27c725a1e32ab423eeb7736a2e917f64736f6c63430008030033", + "deployedBytecode": "0x608060405234801561001057600080fd5b50600436106100415760003560e01c80632239f5561461004657806346efd16c1461005b57806378b248e41461006e575b600080fd5b61005961005436600461025d565b610095565b005b61005961006936600461028f565b6100a3565b61008161007c36600461025d565b610104565b604051901515815260200160405180910390f35b61009f828261014c565b5050565b60005b818110156100fe576100ec848484848181106100d257634e487b7160e01b600052603260045260246000fd5b90506020020160208101906100e79190610243565b61014c565b806100f681610310565b9150506100a6565b50505050565b6001600160a01b03821660009081527f0553069f1f0518e59f8623c18c83a1f987f2a0544d563e98dd803a7078142a8e6020526040812061014590836101a0565b9392505050565b6101568282610104565b61009f576001600160a01b03821660009081527f0553069f1f0518e59f8623c18c83a1f987f2a0544d563e98dd803a7078142a8e6020526040902061019b90826101c8565b505050565b6001600160a01b03811660009081526001830160205260408120541515610145565b92915050565b6000610145836001600160a01b038416600081815260018301602052604081205461021f575081546001818101845560008481526020808220909301849055845484825282860190935260409020919091556101c2565b5060006101c2565b80356001600160a01b038116811461023e57600080fd5b919050565b600060208284031215610254578081fd5b61014582610227565b6000806040838503121561026f578081fd5b61027883610227565b915061028660208401610227565b90509250929050565b6000806000604084860312156102a3578081fd5b6102ac84610227565b9250602084013567ffffffffffffffff808211156102c8578283fd5b818601915086601f8301126102db578283fd5b8135818111156102e9578384fd5b8760208260051b85010111156102fd578384fd5b6020830194508093505050509250925092565b600060001982141561033057634e487b7160e01b81526011600452602481fd5b506001019056fea2646970667358221220a8e0b1e793648a0e140e218f561e33c64d27c725a1e32ab423eeb7736a2e917f64736f6c63430008030033", + "devdoc": { + "kind": "dev", + "methods": { + "addSigner(address,address)": { + "details": "The sender must be the owner.It throws a require error if the sender is not the owner.", + "params": { + "account": "address to add.", + "asset": "Token address to add signers for." + } + }, + "addSigners(address,address[])": { + "details": "The sender must be the owner.It throws a require error if the sender is not the owner.", + "params": { + "accounts": "addresses to add.", + "asset": "Token address to add signers for." + } + }, + "isSigner(address,address)": { + "params": { + "account": "the account to check in the list of the asset's signers", + "asset": "the asset to check for if the signer exists" + } + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "addSigner(address,address)": { + "notice": "It adds a new account as a signer." + }, + "addSigners(address,address[])": { + "notice": "It adds a list of account as signers." + }, + "isSigner(address,address)": { + "notice": "it checks if an account is already in the list of the asset's signers" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/TTokenAaveStrategy_1.json b/deployments/polygon_mumbai/TTokenAaveStrategy_1.json new file mode 100644 index 000000000..ff97d9cf3 --- /dev/null +++ b/deployments/polygon_mumbai/TTokenAaveStrategy_1.json @@ -0,0 +1,203 @@ +{ + "address": "0x7b2B52EDD639937e2Ef0DbB5ab7fd85B67a96be6", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "string", + "name": "strategyName", + "type": "string" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "StrategyRebalanced", + "type": "event" + }, + { + "inputs": [], + "name": "NAME", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "internalType": "uint16", + "name": "balanceRatioMin", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "balanceRatioMax", + "type": "uint16" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "rebalance", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "totalUnderlyingSupply", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "withdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "TTokenAaveStrategy_1", + "transactionHash": "0x3471d47f979c9643f28298ffbe8a5c0f35b0a61b09f962e52c1ed75f2362dc32", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x7b2B52EDD639937e2Ef0DbB5ab7fd85B67a96be6", + "transactionIndex": 0, + "gasUsed": "864742", + "logsBloom": "0x00000000000000020000000000008000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000800100000000000000000100000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000020000000000000000001000000000000000000000000004000000000000100000001000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0x9a5991e213967378ee7ef454e8f82ca2dd8642b3448781a95df00da7cb64ad19", + "transactionHash": "0x3471d47f979c9643f28298ffbe8a5c0f35b0a61b09f962e52c1ed75f2362dc32", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692567, + "transactionHash": "0x3471d47f979c9643f28298ffbe8a5c0f35b0a61b09f962e52c1ed75f2362dc32", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000c26880a0af2ea0c7e8130e6ec47af756465452e8" + ], + "data": "0x000000000000000000000000000000000000000000000000005c2a5917f888000000000000000000000000000000000000000000000000003648e1111daf58000000000000000000000000000000000000000000000000aea39e0c597f96d25700000000000000000000000000000000000000000000000035ecb6b805b6d0000000000000000000000000000000000000000000000000aea3fa36b2978f5a57", + "logIndex": 0, + "blockHash": "0x9a5991e213967378ee7ef454e8f82ca2dd8642b3448781a95df00da7cb64ad19" + } + ], + "blockNumber": 15692567, + "cumulativeGasUsed": "864742", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"string\",\"name\":\"strategyName\",\"type\":\"string\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"StrategyRebalanced\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"NAME\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"aTokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint16\",\"name\":\"balanceRatioMin\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"balanceRatioMax\",\"type\":\"uint16\"}],\"name\":\"init\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rebalance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalUnderlyingSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"init(address,uint16,uint16)\":{\"params\":{\"aTokenAddress\":\"Address of the Aave token that has the same underlying asset as the TToken.\",\"balanceRatioMax\":\"Percentage indicating the _ limit of underlying token balance should remain on the TToken\",\"balanceRatioMin\":\"Percentage indicating the _ limit of underlying token balance should remain on the TToken\"}},\"supportsInterface(bytes4)\":{\"params\":{\"interfaceId\":\"Id of the interface in question\"}},\"totalUnderlyingSupply()\":{\"returns\":{\"_0\":\"uint256 the underlying supply\"}},\"withdraw(uint256)\":{\"params\":{\"amount\":\"Amount of underlying tokens that must be available.\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"init(address,uint16,uint16)\":{\"notice\":\"Sets the Aave token that should be used to manage the underlying Teller Token asset.\"},\"rebalance()\":{\"notice\":\"Rebalances the underlying asset held by the Teller Token. This strategy looks at the ratio of held underlying asset balance and balance deposited into Aave. Based on the store {balanceRatioMin} and {balanceRatioMax} values, will deposit or withdraw to keep the ratio within that range.\"},\"supportsInterface(bytes4)\":{\"notice\":\"it checks if interface is supported according to the ERC165 standard\"},\"totalUnderlyingSupply()\":{\"notice\":\"it returns the total supply of an underlying asset in a Teller token.\"},\"withdraw(uint256)\":{\"notice\":\"Rebalances the TToken funds by indicating a minimum {amount} of underlying tokens that must be present after the call.If the minimum amount is present, no rebalance happens.\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/lending/ttoken/strategies/aave/TTokenAaveStrategy_1.sol\":\"TTokenAaveStrategy_1\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/ERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165 is IERC165 {\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165).interfaceId;\\n }\\n}\\n\",\"keccak256\":\"0x5718c5df9bd67ac68a796961df938821bb5dc0cd4c6118d77e9145afb187409b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/escrow/dapps/interfaces/IVault.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a Yearn Vault\\n @author develop@teller.finance\\n */\\n\\ninterface IVault {\\n /**\\n @notice Returns the unwrapped native token address that the Vault takes as deposit\\n @return The address of the unwrapped token\\n */\\n function token() external view returns (address);\\n\\n /**\\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\\n @return The name of the wrapped token\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\\n @return The symbol of the wrapped token\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\\n @return The number of decimals for the token\\n */\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice Returns the address of the Vault's controller\\n @return The address of the controller contract\\n */\\n function controller() external view returns (address);\\n\\n /**\\n @notice Returns the address of the Vault's governance contract\\n @return The contract address\\n */\\n function governance() external view returns (address);\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\\n\\n /**\\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\\n @return The token price\\n */\\n function getPricePerShare() external view returns (uint256); // v2 vaults\\n\\n /**\\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\\n @param amountToDeposit The amount of tokens to deposit\\n */\\n function deposit(uint256 amountToDeposit) external;\\n\\n /**\\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\\n */\\n function depositAll() external;\\n\\n /**\\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\\n @param amountToWithdraw The amount to withdraw\\n */\\n function withdraw(uint256 amountToWithdraw) external;\\n\\n /**\\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\\n */\\n function withdrawAll() external;\\n}\\n\",\"keccak256\":\"0x0e2e145747f8745bde77d4741abba1a1edb1dab02e9d467eff60cb881bcffd79\",\"license\":\"MIT\"},\"contracts/escrow/dapps/libraries/LibDapps.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAToken } from \\\"../../../shared/interfaces/IAToken.sol\\\";\\nimport {\\n IAaveLendingPool\\n} from \\\"../../../shared/interfaces/IAaveLendingPool.sol\\\";\\nimport {\\n IAaveLendingPoolAddressesProvider\\n} from \\\"../../../shared/interfaces/IAaveLendingPoolAddressesProvider.sol\\\";\\nimport {\\n IUniswapV2Router\\n} from \\\"../../../shared/interfaces/IUniswapV2Router.sol\\\";\\nimport { IVault } from \\\"../interfaces/IVault.sol\\\";\\n\\n// Libraries\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\n\\n// Storage\\nimport { MarketStorageLib, MarketStorage } from \\\"../../../storage/market.sol\\\";\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\n\\nlibrary LibDapps {\\n function s() internal pure returns (MarketStorage storage) {\\n return MarketStorageLib.store();\\n }\\n\\n /**\\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\\n @return IAaveLendingPool instance address\\n */\\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\\n return\\n IAaveLendingPool(\\n IAaveLendingPoolAddressesProvider(\\n 0xd05e3E715d945B59290df0ae8eF85c1BdB684744 // Polygon mainnet\\n )\\n .getLendingPool()\\n ); // LP address provider contract is immutable and the address will never change\\n }\\n\\n /**\\n @notice Grabs the aToken instance from the lending pool\\n @param tokenAddress The underlying asset address to get the aToken for\\n @return IAToken instance\\n */\\n function getAToken(address tokenAddress) internal view returns (IAToken) {\\n return\\n IAToken(\\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\\n );\\n }\\n\\n /**\\n @notice Grabs the yVault address for a token from the asset settings\\n @param tokenAddress The underlying token address for the associated yVault\\n @return yVault instance\\n */\\n function getYVault(address tokenAddress) internal view returns (IVault) {\\n return\\n IVault(\\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\\n keccak256(\\\"yVaultAddress\\\")\\n ]\\n );\\n }\\n}\\n\",\"keccak256\":\"0x4c18d46f924a3a24d596971d39857477b618dad13dee55decc271bdccf915ee5\",\"license\":\"MIT\"},\"contracts/escrow/escrow/ILoansEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ILoansEscrow {\\n function init() external;\\n\\n /**\\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\\n * @param dappAddress address of the target contract address\\n * @param dappData encoded abi of the function in our contract we want to call\\n * @return the called data in bytes\\n */\\n function callDapp(address dappAddress, bytes calldata dappData)\\n external\\n returns (bytes memory);\\n\\n /**\\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\\n * @param token address of the respective ERC20 token to approve for the spender\\n * @param spender address of the respective spender who is approved by the token contract\\n */\\n function setTokenAllowance(address token, address spender) external;\\n\\n /**\\n * @notice it allows user to claim their escrow tokens\\n * @dev only the owner (TellerDiamond) can make this call on behalf of the users\\n * @param token address of the respective token contract to claim tokens from\\n * @param to address where the tokens should be transferred to\\n * @param amount uint256 amount of tokens to be claimed\\n */\\n function claimToken(\\n address token,\\n address to,\\n uint256 amount\\n ) external;\\n}\\n\",\"keccak256\":\"0xaf67fc4454ffaa4d2f7e46fe7101876e8ebdb1a5426c30f87b8e18cc573ac019\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when a user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when a user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n * @return ERC20 token\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n * @return balance_ the balance of the account\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice It calculates the total supply of the underlying asset.\\n * @return totalSupply_ the total supply denoted in the underlying asset.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given market.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n \\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfill the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n * @return mintAmount_ the amount minted of the specified token\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n * @return address of the strategy contract\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n * @param state boolean value that resembles the platform's state\\n */\\n function restrict(bool state) external virtual;\\n\\n /**\\n * @notice it initializes the Teller Token\\n * @param admin address of the admin to the respective Teller Token\\n * @param underlying address of the ERC20 token\\n */\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xf30ac4ef491851477ff9a3dd04974ebe74b529c37a3ef4e05798c3f734ceeb3d\",\"license\":\"MIT\"},\"contracts/lending/ttoken/data.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Role ID used to pull funds for the asset it manages (i.e. TellerDiamond)\\nbytes32 constant CONTROLLER = keccak256(\\\"CONTROLLER\\\");\\n// Role ID used to for accounts to call special methods that modify its state\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\n\\nuint256 constant EXCHANGE_RATE_FACTOR = 1e18;\\nuint256 constant ONE_HUNDRED_PERCENT = 10000;\\n\",\"keccak256\":\"0x0c5f8ce14f4efd59a314373363524e0428b5b7e8a6ee907b35ee1d7ffe886fdf\",\"license\":\"MIT\"},\"contracts/lending/ttoken/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { ERC20, IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\nstruct Store {\\n ERC20 underlying;\\n address strategy;\\n uint256 totalBorrowed;\\n uint256 totalRepaid;\\n uint256 totalInterestRepaid;\\n uint8 decimals;\\n bool restricted;\\n}\\n\\nbytes32 constant POSITION = keccak256(\\\"ttoken.storage.position\\\");\\n\\n/**\\n * @notice it saves the Store struct in a hashed slot\\n */\\nfunction store() pure returns (Store storage s_) {\\n bytes32 position = POSITION;\\n assembly {\\n s_.slot := position\\n }\\n}\\n\",\"keccak256\":\"0x735419ace476d14c4413fad3e9b2cd04573e45736e9ed27b4e223db8316f9905\",\"license\":\"MIT\"},\"contracts/lending/ttoken/strategies/ITTokenStrategy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ITTokenStrategy {\\n event StrategyRebalanced(\\n string indexed strategyName,\\n address indexed sender\\n );\\n\\n /**\\n * @notice it returns the total supply of an underlying asset in a Teller token.\\n * @return uint256 the underlying supply\\n */\\n function totalUnderlyingSupply() external returns (uint256);\\n\\n /**\\n * @notice it rebalances the underlying asset held by the Teller Token.\\n *\\n */\\n function rebalance() external;\\n\\n /**\\n * @notice it withdraws amount of tokens in a pool\\n * @param amount amount to withdraw\\n */\\n\\n function withdraw(uint256 amount) external;\\n}\\n\",\"keccak256\":\"0x05a6c007e6ced27d12d365bf3715283a9310f707e6f642025e94ef596ea8527e\",\"license\":\"MIT\"},\"contracts/lending/ttoken/strategies/TTokenStrategy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { ERC165 } from \\\"@openzeppelin/contracts/utils/introspection/ERC165.sol\\\";\\nimport { ITTokenStrategy } from \\\"./ITTokenStrategy.sol\\\";\\n\\nabstract contract TTokenStrategy is ITTokenStrategy, ERC165 {\\n /**\\n * @notice it checks if interface is supported according to the ERC165 standard\\n * @param interfaceId Id of the interface in question\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override\\n returns (bool)\\n {\\n return\\n ERC165.supportsInterface(interfaceId) ||\\n interfaceId == type(ITTokenStrategy).interfaceId;\\n }\\n}\\n\",\"keccak256\":\"0x64e5f359e2d5fc766a45bb4d8894fb9fb2d7d56d3bb97977622c74e9415f7312\",\"license\":\"MIT\"},\"contracts/lending/ttoken/strategies/aave/TTokenAaveStrategy_1.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// contracts\\nimport {\\n RolesMods\\n} from \\\"../../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN } from \\\"../../data.sol\\\";\\n\\n// Interfaces\\nimport { IAToken } from \\\"../../../../shared/interfaces/IAToken.sol\\\";\\nimport {\\n IAaveLendingPool\\n} from \\\"../../../../shared/interfaces/IAaveLendingPool.sol\\\";\\nimport { TTokenStrategy } from \\\"../TTokenStrategy.sol\\\";\\n\\n// Libraries\\nimport {\\n SafeERC20\\n} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { NumbersLib } from \\\"../../../../shared/libraries/NumbersLib.sol\\\";\\nimport { LibDapps } from \\\"../../../../escrow/dapps/libraries/LibDapps.sol\\\";\\n\\n// Storage\\nimport \\\"../../storage.sol\\\" as TokenStorage;\\nimport \\\"./storage.sol\\\" as AaveStorage;\\n\\ncontract TTokenAaveStrategy_1 is RolesMods, TTokenStrategy {\\n function() pure returns (TokenStorage.Store storage)\\n private constant tokenStore = TokenStorage.store;\\n\\n function() pure returns (AaveStorage.Store storage)\\n private constant aaveStore = AaveStorage.store;\\n\\n string public constant NAME = \\\"AaveStrategy_1\\\";\\n\\n /* External Functions */\\n\\n function totalUnderlyingSupply() external override returns (uint256) {\\n return\\n tokenStore().underlying.balanceOf(address(this)) +\\n aaveStore().aToken.balanceOf(address(this));\\n }\\n\\n /**\\n * @notice Rebalances the underlying asset held by the Teller Token.\\n *\\n * This strategy looks at the ratio of held underlying asset balance and balance deposited into\\n * Aave. Based on the store {balanceRatioMin} and {balanceRatioMax} values, will deposit or\\n * withdraw to keep the ratio within that range.\\n */\\n function rebalance() public override {\\n (uint256 storedBal, uint256 aaveBal, uint16 storedRatio) =\\n _getBalanceInfo();\\n if (storedRatio > aaveStore().balanceRatioMax) {\\n // Calculate median ratio to rebalance to\\n uint16 medianRatio =\\n (aaveStore().balanceRatioMax + aaveStore().balanceRatioMin) / 2;\\n uint256 requiredBal =\\n NumbersLib.percent(storedBal + aaveBal, medianRatio);\\n uint256 amountToDeposit = storedBal - requiredBal;\\n\\n IAaveLendingPool lendingPool = LibDapps.getAaveLendingPool();\\n\\n // Approve Aave lending pool\\n SafeERC20.safeIncreaseAllowance(\\n tokenStore().underlying,\\n address(lendingPool),\\n amountToDeposit\\n );\\n // Deposit into Aave\\n lendingPool.deposit(\\n address(tokenStore().underlying),\\n amountToDeposit,\\n address(this),\\n 0 // TODO get referral code from Aave when applicable\\n );\\n\\n emit StrategyRebalanced(NAME, msg.sender);\\n } else {\\n // Withdraw tokens from Aave\\n _withdraw(0, storedBal, aaveBal, storedRatio);\\n\\n emit StrategyRebalanced(NAME, msg.sender);\\n }\\n }\\n\\n /**\\n * @notice Rebalances the TToken funds by indicating a minimum {amount} of underlying tokens that must be present\\n * after the call.\\n * @notice If the minimum amount is present, no rebalance happens.\\n * @param amount Amount of underlying tokens that must be available.\\n */\\n function withdraw(uint256 amount) external override {\\n (uint256 storedBal, uint256 aaveBal, uint16 storedRatio) =\\n _getBalanceInfo();\\n if (storedBal < amount) {\\n _withdraw(amount, storedBal, aaveBal, storedRatio);\\n }\\n }\\n\\n /**\\n * @dev Gets balances and the current ratio of the underlying asset stored on the TToken.\\n */\\n function _getBalanceInfo()\\n internal\\n returns (\\n uint256 storedBalance_,\\n uint256 aaveBalance_,\\n uint16 storedRatio_\\n )\\n {\\n storedBalance_ = tokenStore().underlying.balanceOf(address(this));\\n aaveBalance_ = aaveStore().aToken.balanceOf(address(this));\\n storedRatio_ = NumbersLib.ratioOf(\\n storedBalance_,\\n storedBalance_ + aaveBalance_\\n );\\n }\\n\\n /**\\n * @dev Rebalances funds stored on the TToken by indicating an extra {amount} to withdraw.\\n */\\n function _withdraw(\\n uint256 amount,\\n uint256 storedBal,\\n uint256 aaveBal,\\n uint16 storedRatio\\n ) internal {\\n // Calculate amount to rebalance\\n uint16 medianRatio =\\n (aaveStore().balanceRatioMax + aaveStore().balanceRatioMin) / 2;\\n uint256 requiredBal =\\n NumbersLib.percent(\\n storedBal + aaveBal - amount,\\n medianRatio - storedRatio\\n );\\n uint256 redeemAmount = requiredBal - storedBal + amount;\\n // Withdraw tokens from the Aave lending pool if needed\\n IAaveLendingPool lendingPool = LibDapps.getAaveLendingPool();\\n lendingPool.withdraw(\\n address(tokenStore().underlying),\\n redeemAmount,\\n address(this)\\n );\\n }\\n\\n /**\\n * @notice Sets the Aave token that should be used to manage the underlying Teller Token asset.\\n * @param aTokenAddress Address of the Aave token that has the same underlying asset as the TToken.\\n * @param balanceRatioMin Percentage indicating the _ limit of underlying token balance should remain on the TToken\\n * @param balanceRatioMax Percentage indicating the _ limit of underlying token balance should remain on the TToken\\n */\\n function init(\\n address aTokenAddress,\\n uint16 balanceRatioMin,\\n uint16 balanceRatioMax\\n ) external {\\n aaveStore().aToken = IAToken(aTokenAddress);\\n aaveStore().balanceRatioMin = balanceRatioMin;\\n aaveStore().balanceRatioMax = balanceRatioMax;\\n }\\n}\\n\",\"keccak256\":\"0x2943d7491694ab010f07be8895107f8862aaba43a1557f5432b3740e690e2577\",\"license\":\"MIT\"},\"contracts/lending/ttoken/strategies/aave/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { IAToken } from \\\"../../../../shared/interfaces/IAToken.sol\\\";\\n\\nstruct Store {\\n IAToken aToken;\\n uint16 balanceRatioMax;\\n uint16 balanceRatioMin;\\n}\\n\\nbytes32 constant POSITION = keccak256(\\\"ttoken.strategy.aave.storage.position\\\");\\n\\nfunction store() pure returns (Store storage s_) {\\n bytes32 position = POSITION;\\n assembly {\\n s_.slot := position\\n }\\n}\\n\",\"keccak256\":\"0xb2e3db5d27ee5a943e12e4c7d96560525dc97b54c3008d677015b97f8e761af3\",\"license\":\"MIT\"},\"contracts/market/collateral/ICollateralEscrow.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ICollateralEscrow {\\n /**\\n * @notice it initializes an escrow\\n * @param tokenAddress the address of the collateral token to be stored\\n * @param isWETH check if it's wrapped Ethereum\\n */\\n function init(address tokenAddress, bool isWETH) external;\\n\\n /**\\n * @notice it deposits an amount of the respective collateral token into the escrow\\n * @param loanID the ID of the loan\\n * @param amount the amount of collateral tokens to be deposited\\n */\\n function deposit(uint256 loanID, uint256 amount) external payable;\\n\\n /**\\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\\n * @dev only the TellerDiamond can make this call on behalf of the borrower\\n * @param loanID identifier of the loan\\n * @param amount number of collateral tokens to send\\n * @param receiver payable address to transfer money to\\n */\\n function withdraw(\\n uint256 loanID,\\n uint256 amount,\\n address payable receiver\\n ) external;\\n\\n /**\\n * @notice it returns the supply of the respective loan\\n * @param loanID the respective loan ID\\n * @return supply_ the amount in collateral of the respective loan\\n */\\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\\n\\n /**\\n * @notice it returns the total supply of the collateral token held by the contract\\n * @return supply_ the total amount of collateral\\n */\\n function totalSupply() external view returns (uint256 supply_);\\n}\\n\",\"keccak256\":\"0x900fed2311f919ba1451a6583ddbf9f3bc8afa8f5189500fff51f0c049258ed3\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x417b75f5d92be67993efc54db7d453be5b5058a9a54d8916380e0281d3299526\",\"license\":\"MIT\"},\"contracts/settings/platform/libraries/PlatformSettingsLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AppStorageLib } from \\\"../../../storage/app.sol\\\";\\nimport \\\"../names.sol\\\" as NAMES;\\nimport {\\n RolesMods\\n} from \\\"../../../contexts2/access-control/roles/RolesMods.sol\\\";\\nimport { ADMIN, AUTHORIZED } from \\\"../../../shared/roles.sol\\\";\\nimport { RolesLib } from \\\"../../../contexts2/access-control/roles/RolesLib.sol\\\";\\n\\n// It defines a platform settings. It includes: value, min, and max values.\\nstruct PlatformSetting {\\n uint256 value;\\n uint256 min;\\n uint256 max;\\n bool exists;\\n}\\n\\n/**\\n * @notice Utility library of inline functions on the PlatformSetting struct.\\n *\\n * @author develop@teller.finance\\n */\\nlibrary PlatformSettingsLib {\\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\\n return AppStorageLib.store().platformSettings[name];\\n }\\n\\n /**\\n * @notice It gets the current \\\"NFTInterestRate\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getNFTInterestRate() internal view returns (uint16 value_) {\\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequiredSubmissionsPercentage\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequiredSubmissionsPercentageValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumTolerance\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"ResponseExpiryLength\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getResponseExpiryLengthValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"SafetyInterval\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.SAFETY_INTERVAL).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"TermsExpiryTime\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"LiquidateRewardPercent\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getLiquidateRewardPercent()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"MaximumLoanDuration\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getMaximumLoanDurationValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"RequestLoanTermsRateLimit\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getRequestLoanTermsRateLimitValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"CollateralBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getCollateralBufferValue() internal view returns (uint256 value_) {\\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\\n }\\n\\n /**\\n * @notice It gets the current \\\"OverCollateralizedBuffer\\\" setting's value\\n * @return value_ the current value.\\n */\\n function getOverCollateralizedBufferValue()\\n internal\\n view\\n returns (uint256 value_)\\n {\\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\\n }\\n}\\n\",\"keccak256\":\"0x44294be1af9f913b2ed391a40cd4b646537a4b463b8d5ff1fac8ead3988966c1\",\"license\":\"MIT\"},\"contracts/settings/platform/names.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @dev The setting name for loans taken out with an NFT.\\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\\n */\\nbytes32 constant NFT_INTEREST_RATE = keccak256(\\\"NFTInterestRate\\\");\\n\\n/**\\n @dev The setting name for the required subsmission settings.\\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\\n */\\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\\n \\\"RequiredSubmissionsPercentage\\\"\\n);\\n\\n/**\\n @dev The setting name for the maximum tolerance settings.\\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\\n @dev This is a percentage value with 2 decimal places.\\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\\n @dev The max value is 100% => 10000\\n */\\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\\\"MaximumTolerance\\\");\\n/**\\n @dev The setting name for the response expiry length settings.\\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\\n */\\n\\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\\\"ResponseExpiryLength\\\");\\n\\n/**\\n @dev The setting name for the safety interval settings.\\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\\n */\\nbytes32 constant SAFETY_INTERVAL = keccak256(\\\"SafetyInterval\\\");\\n\\n/**\\n @dev The setting name for the term expiry time settings.\\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\\n */\\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\\\"TermsExpiryTime\\\");\\n\\n/**\\n @dev The setting name for the liquidation reward percent setting.\\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\\n i.e. an ETH liquidation price at 5% is stored as 500\\n */\\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\\\"LiquidateRewardPercent\\\");\\n\\n/**\\n @dev The setting name for the maximum loan duration settings.\\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\\n */\\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\\\"MaximumLoanDuration\\\");\\n\\n/**\\n @dev The setting name for the request loan terms rate limit settings.\\n @dev The request loan terms rate limit setting is defined in seconds.\\n */\\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\\n \\\"RequestLoanTermsRateLimit\\\"\\n);\\n\\n/**\\n @dev The setting name for the collateral buffer.\\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\\n e.g.: collateral buffer at 100% is stored as 10000.\\n */\\nbytes32 constant COLLATERAL_BUFFER = keccak256(\\\"CollateralBuffer\\\");\\n\\n/**\\n @dev The setting name for the over collateralized buffer.\\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\\n e.g.: over collateralized buffer at 130% is stored as 13000.\\n */\\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\\n \\\"OverCollateralizedBuffer\\\"\\n);\\n\",\"keccak256\":\"0xd68a7df42b2bbba6f935d5890b7b37997c1432e25ae113827b8bde87f94fd86f\",\"license\":\"MIT\"},\"contracts/shared/interfaces/DataTypes.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nlibrary DataTypes {\\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\\n struct ReserveData {\\n //stores the reserve configuration\\n ReserveConfigurationMap configuration;\\n //the liquidity index. Expressed in ray\\n uint128 liquidityIndex;\\n //variable borrow index. Expressed in ray\\n uint128 variableBorrowIndex;\\n //the current supply rate. Expressed in ray\\n uint128 currentLiquidityRate;\\n //the current variable borrow rate. Expressed in ray\\n uint128 currentVariableBorrowRate;\\n //the current stable borrow rate. Expressed in ray\\n uint128 currentStableBorrowRate;\\n uint40 lastUpdateTimestamp;\\n //tokens addresses\\n address aTokenAddress;\\n address stableDebtTokenAddress;\\n address variableDebtTokenAddress;\\n //address of the interest rate strategy\\n address interestRateStrategyAddress;\\n //the id of the reserve. Represents the position in the list of the active reserves\\n uint8 id;\\n }\\n\\n struct ReserveConfigurationMap {\\n //bit 0-15: LTV\\n //bit 16-31: Liq. threshold\\n //bit 32-47: Liq. bonus\\n //bit 48-55: Decimals\\n //bit 56: Reserve is active\\n //bit 57: reserve is frozen\\n //bit 58: borrowing is enabled\\n //bit 59: stable rate borrowing enabled\\n //bit 60-63: reserved\\n //bit 64-79: reserve factor\\n uint256 data;\\n }\\n\\n struct UserConfigurationMap {\\n uint256 data;\\n }\\n\\n enum InterestRateMode { NONE, STABLE, VARIABLE }\\n}\\n\",\"keccak256\":\"0xf4301e0bd269f4662f1c1a0ed4f217cd78d670e43d51a025d55878b972d0a8e7\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/IAToken.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\ninterface IAToken {\\n /**\\n * @dev Mints `amount` aTokens to `user`\\n * @param user The address receiving the minted tokens\\n * @param amount The amount of tokens getting minted\\n * @param index The new liquidity index of the reserve\\n * @return `true` if the the previous balance of the user was 0\\n */\\n function mint(\\n address user,\\n uint256 amount,\\n uint256 index\\n ) external returns (bool);\\n\\n /**\\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\\n * @param user The owner of the aTokens, getting them burned\\n * @param receiverOfUnderlying The address that will receive the underlying\\n * @param amount The amount being burned\\n * @param index The new liquidity index of the reserve\\n **/\\n function burn(\\n address user,\\n address receiverOfUnderlying,\\n uint256 amount,\\n uint256 index\\n ) external;\\n\\n /**\\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\\n * assets in borrow(), withdraw() and flashLoan()\\n * @param user The recipient of the aTokens\\n * @param amount The amount getting transferred\\n * @return The amount transferred\\n **/\\n function transferUnderlyingTo(address user, uint256 amount)\\n external\\n returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\\n * @param user The user whose balance is calculated\\n * @return The scaled balance of the user\\n **/\\n function scaledBalanceOf(address user) external view returns (uint256);\\n\\n /**\\n * @dev Returns the scaled balance of the user and the scaled total supply.\\n * @param user The address of the user\\n * @return The scaled balance of the user\\n * @return The scaled balance and the scaled total supply\\n **/\\n function getScaledUserBalanceAndSupply(address user)\\n external\\n view\\n returns (uint256, uint256);\\n\\n /**\\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\\n * @return The scaled total supply\\n **/\\n function scaledTotalSupply() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf715e63b83c55fcd3476280a0ab871ed763754b3f5404ec779903652a3e7838e\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/IAaveLendingPool.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAaveLendingPoolAddressesProvider.sol\\\";\\nimport \\\"./DataTypes.sol\\\";\\n\\ninterface IAaveLendingPool {\\n /**\\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\\n * @param asset The address of the underlying asset to deposit\\n * @param amount The amount to be deposited\\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\\n * is a different wallet\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function deposit(\\n address asset,\\n uint256 amount,\\n address onBehalfOf,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\\n * @param asset The address of the underlying asset to withdraw\\n * @param amount The underlying amount to be withdrawn\\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\\n * @param to Address that will receive the underlying, same as msg.sender if the user\\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\\n * different wallet\\n * @return The final amount withdrawn\\n **/\\n function withdraw(\\n address asset,\\n uint256 amount,\\n address to\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\\n * corresponding debt token (StableDebtToken or VariableDebtToken)\\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\\n * @param asset The address of the underlying asset to borrow\\n * @param amount The amount to be borrowed\\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\\n * if he has been given credit delegation allowance\\n **/\\n function borrow(\\n address asset,\\n uint256 amount,\\n uint256 interestRateMode,\\n uint16 referralCode,\\n address onBehalfOf\\n ) external;\\n\\n /**\\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\\n * @param asset The address of the borrowed underlying asset previously borrowed\\n * @param amount The amount to repay\\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\\n * other borrower whose debt should be removed\\n * @return The final amount repaid\\n **/\\n function repay(\\n address asset,\\n uint256 amount,\\n uint256 rateMode,\\n address onBehalfOf\\n ) external returns (uint256);\\n\\n /**\\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\\n * @param asset The address of the underlying asset borrowed\\n * @param rateMode The rate mode that the user wants to swap to\\n **/\\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\\n\\n /**\\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\\n * - Users can be rebalanced if the following conditions are satisfied:\\n * 1. Usage ratio is above 95%\\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\\n * borrowed at a stable rate and depositors are not earning enough\\n * @param asset The address of the underlying asset borrowed\\n * @param user The address of the user to be rebalanced\\n **/\\n function rebalanceStableBorrowRate(address asset, address user) external;\\n\\n /**\\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\\n * @param asset The address of the underlying asset deposited\\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\\n **/\\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\\n external;\\n\\n /**\\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\\n * @param user The address of the borrower getting liquidated\\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\\n * to receive the underlying collateral asset directly\\n **/\\n function liquidationCall(\\n address collateralAsset,\\n address debtAsset,\\n address user,\\n uint256 debtToCover,\\n bool receiveAToken\\n ) external;\\n\\n /**\\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\\n * as long as the amount taken plus a fee is returned.\\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\\n * For further details please visit https://developers.aave.com\\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\\n * @param assets The addresses of the assets being flash-borrowed\\n * @param amounts The amounts amounts being flash-borrowed\\n * @param modes Types of the debt to open if the flash loan is not returned:\\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\\n * @param params Variadic packed params to pass to the receiver as extra information\\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\\n * 0 if the action is executed directly by the user, without any middle-man\\n **/\\n function flashLoan(\\n address receiverAddress,\\n address[] calldata assets,\\n uint256[] calldata amounts,\\n uint256[] calldata modes,\\n address onBehalfOf,\\n bytes calldata params,\\n uint16 referralCode\\n ) external;\\n\\n /**\\n * @dev Returns the user account data across all the reserves\\n * @param user The address of the user\\n * @return totalCollateralETH the total collateral in ETH of the user\\n * @return totalDebtETH the total debt in ETH of the user\\n * @return availableBorrowsETH the borrowing power left of the user\\n * @return currentLiquidationThreshold the liquidation threshold of the user\\n * @return ltv the loan to value of the user\\n * @return healthFactor the current health factor of the user\\n **/\\n function getUserAccountData(address user)\\n external\\n view\\n returns (\\n uint256 totalCollateralETH,\\n uint256 totalDebtETH,\\n uint256 availableBorrowsETH,\\n uint256 currentLiquidationThreshold,\\n uint256 ltv,\\n uint256 healthFactor\\n );\\n\\n /**\\n * @dev Returns the configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The configuration of the reserve\\n **/\\n function getConfiguration(address asset)\\n external\\n view\\n returns (DataTypes.ReserveConfigurationMap memory);\\n\\n /**\\n * @dev Returns the configuration of the user across all the reserves\\n * @param user The user address\\n * @return The configuration of the user\\n **/\\n function getUserConfiguration(address user)\\n external\\n view\\n returns (DataTypes.UserConfigurationMap memory);\\n\\n /**\\n * @dev Returns the normalized income normalized income of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve's normalized income\\n */\\n function getReserveNormalizedIncome(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the normalized variable debt per unit of asset\\n * @param asset The address of the underlying asset of the reserve\\n * @return The reserve normalized variable debt\\n */\\n function getReserveNormalizedVariableDebt(address asset)\\n external\\n view\\n returns (uint256);\\n\\n /**\\n * @dev Returns the state and configuration of the reserve\\n * @param asset The address of the underlying asset of the reserve\\n * @return The state of the reserve\\n **/\\n function getReserveData(address asset)\\n external\\n view\\n returns (DataTypes.ReserveData memory);\\n\\n function finalizeTransfer(\\n address asset,\\n address from,\\n address to,\\n uint256 amount,\\n uint256 balanceFromAfter,\\n uint256 balanceToBefore\\n ) external;\\n\\n function getReservesList() external view returns (address[] memory);\\n\\n function getAddressesProvider()\\n external\\n view\\n returns (IAaveLendingPoolAddressesProvider);\\n\\n function paused() external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8fb5cf82d1c19d0c61151dfb8cf6f6c2a17a15b63600b75f359fe4e9e3acc23f\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/IAaveLendingPoolAddressesProvider.sol\":{\"content\":\"// SPDX-License-Identifier: agpl-3.0\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title LendingPoolAddressesProvider contract\\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\\n * - Owned by the Aave Governance\\n * @author Aave\\n **/\\ninterface IAaveLendingPoolAddressesProvider {\\n function getMarketId() external view returns (string memory);\\n\\n function getAddress(bytes32 id) external view returns (address);\\n\\n function getLendingPool() external view returns (address);\\n\\n function getPriceOracle() external view returns (address);\\n\\n function getLendingRateOracle() external view returns (address);\\n}\\n\",\"keccak256\":\"0x9d21dbefac677da74786c27ad0fe1b148c00df63f7a2616d75c2b97c756007b3\",\"license\":\"agpl-3.0\"},\"contracts/shared/interfaces/IUniswapV2Router.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n @notice This interface defines the different functions available for a UniswapV2Router.\\n @author develop@teller.finance\\n */\\ninterface IUniswapV2Router {\\n function factory() external pure returns (address);\\n\\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 amountADesired,\\n uint256 amountBDesired,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n returns (\\n uint256 amountA,\\n uint256 amountB,\\n uint256 liquidity\\n );\\n\\n function addLiquidityETH(\\n address token,\\n uint256 amountTokenDesired,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n )\\n external\\n payable\\n returns (\\n uint256 amountToken,\\n uint256 amountETH,\\n uint256 liquidity\\n );\\n\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETH(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint256 liquidity,\\n uint256 amountAMin,\\n uint256 amountBMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountA, uint256 amountB);\\n\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint256 liquidity,\\n uint256 amountTokenMin,\\n uint256 amountETHMin,\\n address to,\\n uint256 deadline,\\n bool approveMax,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256 amountToken, uint256 amountETH);\\n\\n function quote(\\n uint256 amountA,\\n uint256 reserveA,\\n uint256 reserveB\\n ) external pure returns (uint256 amountB);\\n\\n function getAmountOut(\\n uint256 amountIn,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountOut);\\n\\n function getAmountIn(\\n uint256 amountOut,\\n uint256 reserveIn,\\n uint256 reserveOut\\n ) external pure returns (uint256 amountIn);\\n\\n function getAmountsOut(uint256 amountIn, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n function getAmountsIn(uint256 amountOut, address[] calldata path)\\n external\\n view\\n returns (uint256[] memory amounts);\\n\\n /**\\n @notice It returns the address of the canonical WETH address;\\n */\\n function WETH() external pure returns (address);\\n\\n /**\\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\\n */\\n function swapExactTokensForTokens(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountIn The amount of input tokens to send.\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the ETH.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\\n */\\n function swapExactTokensForETH(\\n uint256 amountIn,\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n /**\\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\\n @param to Recipient of the output tokens.\\n @param deadline Unix timestamp after which the transaction will revert.\\n @return amounts The input token amount and all subsequent output token amounts.\\n */\\n function swapExactETHForTokens(\\n uint256 amountOutMin,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n\\n function swapTokensForExactTokens(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapTokensForExactETH(\\n uint256 amountOut,\\n uint256 amountInMax,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external returns (uint256[] memory amounts);\\n\\n function swapETHForExactTokens(\\n uint256 amountOut,\\n address[] calldata path,\\n address to,\\n uint256 deadline\\n ) external payable returns (uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x208769886b3db8f03ef1fa26f1caee189038dfc744b9a499402fc4e4c0090c38\",\"license\":\"MIT\"},\"contracts/shared/libraries/CacheLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nenum CacheType { Address, Uint, Int, Byte, Bool }\\n\\n/**\\n * @notice This struct manages the cache of the library instance.\\n * @param addresses A mapping of address values mapped to cache keys in bytes.\\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\\n * @param ints A mapping of int values mapped to cache keys names in bytes.\\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\\n */\\nstruct Cache {\\n // Mapping of cache keys names to address values.\\n mapping(bytes32 => address) addresses;\\n // Mapping of cache keys names to uint256 values.\\n mapping(bytes32 => uint256) uints;\\n // Mapping of cache keys names to int256 values.\\n mapping(bytes32 => int256) ints;\\n // Mapping of cache keys names to bytes32 values.\\n mapping(bytes32 => bytes32) bites;\\n // Mapping of cache keys names to bool values.\\n mapping(bytes32 => bool) bools;\\n}\\n\\nlibrary CacheLib {\\n // The constant for the initialization check\\n bytes32 private constant INITIALIZED = keccak256(\\\"Initialized\\\");\\n\\n /**\\n * @notice Initializes the cache instance.\\n * @param cache The current cache\\n */\\n function initialize(Cache storage cache) internal {\\n requireNotExists(cache);\\n cache.bools[INITIALIZED] = true;\\n }\\n\\n /**\\n * @notice Checks whether the current cache does not, throwing an error if it does.\\n * @param cache The current cache\\n */\\n function requireNotExists(Cache storage cache) internal view {\\n require(!exists(cache), \\\"CACHE_ALREADY_EXISTS\\\");\\n }\\n\\n /**\\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\\n * @param cache The current cache\\n */\\n function requireExists(Cache storage cache) internal view {\\n require(exists(cache), \\\"CACHE_DOES_NOT_EXIST\\\");\\n }\\n\\n /**\\n * @notice Tests whether the current cache exists or not.\\n * @param cache The current cache.\\n * @return bool True if the cache exists.\\n */\\n function exists(Cache storage cache) internal view returns (bool) {\\n return cache.bools[INITIALIZED];\\n }\\n\\n /**\\n * @notice it updates the cache with a key, value and cache type\\n * @param cache cache to update\\n * @param key the memory reference to the value in bytes32\\n * @param value the value to update at the key\\n * @param cacheType the enum type of cache to update\\n */\\n function update(\\n Cache storage cache,\\n bytes32 key,\\n bytes32 value,\\n CacheType cacheType\\n ) internal {\\n requireExists(cache);\\n\\n assembly {\\n mstore(0, value)\\n }\\n if (cacheType == CacheType.Address) {\\n address addr;\\n assembly {\\n addr := mload(0)\\n }\\n cache.addresses[key] = addr;\\n } else if (cacheType == CacheType.Uint) {\\n uint256 ui;\\n assembly {\\n ui := mload(0)\\n }\\n cache.uints[key] = ui;\\n } else if (cacheType == CacheType.Int) {\\n int256 i;\\n assembly {\\n i := mload(0)\\n }\\n cache.ints[key] = i;\\n } else if (cacheType == CacheType.Byte) {\\n cache.bites[key] = value;\\n } else if (cacheType == CacheType.Bool) {\\n bool b;\\n assembly {\\n b := mload(0)\\n }\\n cache.bools[key] = b;\\n }\\n }\\n\\n /**\\n * @notice it deletes the cache values at the specified key\\n * @param cache the cache to delete keys from\\n * @param keysToClear the keys to delete\\n * @param keyTypes the types of keys to target different parts of the cache\\n */\\n function clearCache(\\n Cache storage cache,\\n bytes32[5] memory keysToClear,\\n CacheType[5] memory keyTypes\\n ) internal {\\n requireExists(cache);\\n require(\\n keysToClear.length == keyTypes.length,\\n \\\"ARRAY_LENGTHS_MISMATCH\\\"\\n );\\n for (uint256 i; i <= keysToClear.length; i++) {\\n if (keyTypes[i] == CacheType.Address) {\\n delete cache.addresses[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Uint) {\\n delete cache.uints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Int) {\\n delete cache.ints[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Byte) {\\n delete cache.bites[keysToClear[i]];\\n } else if (keyTypes[i] == CacheType.Bool) {\\n delete cache.bools[keysToClear[i]];\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb896b539792b98bda4fb9f25b44550c74fa663914683d69824d7415436f2601f\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n /**\\n * @notice it returns the absolute number of a specified parameter\\n * @param self the number to be returned in it's absolute\\n * @return the absolute number\\n */\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0x4f750cde25d4b1db919abf3192d58ed6aef617d03637e1e9e2dc31b70dcc32a3\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersList.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\nimport \\\"./NumbersLib.sol\\\";\\n\\n/**\\n * @dev Utility library of inline functions on NumbersList.Values\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersList {\\n using NumbersLib for uint256;\\n\\n // Holds values to calculate the threshold of a list of numbers\\n struct Values {\\n uint256 count; // The total number of numbers added\\n uint256 max; // The maximum number that was added\\n uint256 min; // The minimum number that was added\\n uint256 sum; // The total sum of the numbers that were added\\n }\\n\\n /**\\n * @dev Add to the sum while keeping track of min and max values\\n * @param self The Value this function was called on\\n * @param newValue Number to increment sum by\\n */\\n function addValue(Values memory self, uint256 newValue) internal pure {\\n if (self.max < newValue) {\\n self.max = newValue;\\n }\\n if (self.min > newValue || self.count == 0) {\\n self.min = newValue;\\n }\\n self.sum = self.sum + (newValue);\\n self.count = self.count + 1;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the number of times the sum has updated\\n */\\n function valuesCount(Values memory self) internal pure returns (uint256) {\\n return self.count;\\n }\\n\\n /**\\n * @dev Checks if the sum has been changed\\n * @param self The Value this function was called on\\n * @return boolean\\n */\\n function isEmpty(Values memory self) internal pure returns (bool) {\\n return valuesCount(self) == 0;\\n }\\n\\n /**\\n * @param self The Value this function was called on\\n * @return the average number that was used to calculate the sum\\n */\\n function getAverage(Values memory self) internal pure returns (uint256) {\\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\\n }\\n\\n /**\\n * @dev Checks if the min and max numbers are within the acceptable tolerance\\n * @param self The Value this function was called on\\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\\n * @return boolean\\n */\\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\\n internal\\n pure\\n returns (bool)\\n {\\n if (isEmpty(self)) {\\n return false;\\n }\\n uint256 average = getAverage(self);\\n uint256 toleranceAmount = average.percent(tolerancePercentage);\\n\\n uint256 minTolerance = average - toleranceAmount;\\n if (self.min < minTolerance) {\\n return false;\\n }\\n\\n uint256 maxTolerance = average + toleranceAmount;\\n if (self.max > maxTolerance) {\\n return false;\\n }\\n return true;\\n }\\n}\\n\",\"keccak256\":\"0xfd64d3765eb776aaebf1c6eeb8af33ad4a9bd89bad676300542086c1fefd44da\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"},\"contracts/storage/app.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { TellerNFT } from \\\"../nft/TellerNFT.sol\\\";\\n\\n// Interfaces\\n\\n// Libraries\\nimport {\\n PlatformSetting\\n} from \\\"../settings/platform/libraries/PlatformSettingsLib.sol\\\";\\nimport { Cache } from \\\"../shared/libraries/CacheLib.sol\\\";\\nimport {\\n UpgradeableBeaconFactory\\n} from \\\"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\\\";\\n\\nstruct AppStorage {\\n // is it initialized\\n bool initialized;\\n // is it platform restricted\\n bool platformRestricted;\\n // mapping between contract IDs and if they're paused\\n mapping(bytes32 => bool) paused;\\n //p\\n mapping(bytes32 => PlatformSetting) platformSettings;\\n mapping(address => Cache) assetSettings;\\n mapping(string => address) assetAddresses;\\n mapping(address => bool) cTokenRegistry;\\n TellerNFT nft;\\n UpgradeableBeaconFactory loansEscrowBeacon;\\n UpgradeableBeaconFactory collateralEscrowBeacon;\\n address nftLiquidationController;\\n UpgradeableBeaconFactory tTokenBeacon;\\n address wrappedNativeToken;\\n}\\n\\nlibrary AppStorageLib {\\n function store() internal pure returns (AppStorage storage s) {\\n assembly {\\n s.slot := 0\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4504c5c460972a25cd1f0e6eb1d8dd84a668be75a3aeb89a47a49c2327c12923\",\"license\":\"MIT\"},\"contracts/storage/market.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Libraries\\nimport { Counters } from \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport {\\n EnumerableSet\\n} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"../shared/libraries/NumbersList.sol\\\";\\n\\n// Interfaces\\nimport { ILoansEscrow } from \\\"../escrow/escrow/ILoansEscrow.sol\\\";\\nimport { ICollateralEscrow } from \\\"../market/collateral/ICollateralEscrow.sol\\\";\\nimport { ITToken } from \\\"../lending/ttoken/ITToken.sol\\\";\\n\\n// DEPRECATED\\nstruct LoanTerms {\\n // Max size the loan max be taken out with\\n uint256 maxLoanAmount;\\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\\n uint32 termsExpiry;\\n}\\n\\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\\n\\nstruct Loan {\\n // Account that owns the loan\\n address payable borrower;\\n // The asset lent out for the loan\\n address lendingToken;\\n // The token used as collateral for the loan\\n address collateralToken;\\n // The total amount of the loan size taken out\\n uint256 borrowedAmount;\\n // The id of the loan for internal tracking\\n uint128 id;\\n // How long in seconds until the loan must be repaid\\n uint32 duration;\\n // The timestamp at which the loan became active\\n uint32 loanStartTime;\\n // The interest rate given for repaying the loan\\n uint16 interestRate;\\n // Ratio used to determine amount of collateral required based on the collateral asset price\\n uint16 collateralRatio;\\n // The status of the loan\\n LoanStatus status;\\n}\\n\\nstruct LoanDebt {\\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\\n uint256 principalOwed;\\n // The total interest owed by the borrower for the loan, reduces on loan repayments\\n uint256 interestOwed;\\n}\\n\\nstruct LoanRequest {\\n LoanUserRequest request;\\n LoanConsensusResponse[] responses;\\n}\\n\\n/**\\n * @notice Borrower request object to take out a loan\\n * @param borrower The wallet address of the borrower\\n * @param assetAddress The address of the asset for the requested loan\\n * @param amount The amount of tokens requested by the borrower for the loan\\n * @param requestNonce The nonce of the borrower wallet address required for authentication\\n * @param duration The length of time in seconds that the loan has been requested for\\n * @param requestTime The timestamp at which the loan was requested\\n */\\nstruct LoanUserRequest {\\n address payable borrower;\\n address assetAddress;\\n uint256 amount;\\n uint32 requestNonce;\\n uint32 duration;\\n uint32 requestTime;\\n}\\n\\n/**\\n * @notice Borrower response object to take out a loan\\n * @param signer The wallet address of the signer validating the interest request of the lender\\n * @param assetAddress The address of the asset for the requested loan\\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\\n * @param responseTime The timestamp at which the response was sent\\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\\n * @param signature The signature generated by the signer in the format of the above Signature struct\\n */\\nstruct LoanConsensusResponse {\\n address signer;\\n address assetAddress;\\n uint256 maxLoanAmount;\\n uint32 responseTime;\\n uint16 interestRate;\\n uint16 collateralRatio;\\n Signature signature;\\n}\\n\\n/**\\n * @notice Represents a user signature\\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\\n */\\nstruct Signature {\\n uint8 v;\\n bytes32 r;\\n bytes32 s;\\n}\\n\\nstruct MarketStorage {\\n // Holds the index for the next loan ID\\n Counters.Counter loanIDCounter;\\n // Maps loanIDs to loan data\\n mapping(uint256 => Loan) loans;\\n // Maps loanID to loan debt (total owed left)\\n mapping(uint256 => LoanDebt) loanDebt;\\n // Maps loanID to loan terms\\n mapping(uint256 => LoanTerms) _loanTerms; // DEPRECATED: DO NOT REMOVE\\n // Maps loanIDs to escrow address to list of held tokens\\n mapping(uint256 => ILoansEscrow) loanEscrows;\\n // Maps loanIDs to list of tokens owned by a loan escrow\\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\\n mapping(address => ICollateralEscrow) collateralEscrows;\\n // Maps accounts to owned loan IDs\\n mapping(address => uint128[]) borrowerLoans;\\n // Maps lending token to overall amount of interest collected from loans\\n mapping(address => ITToken) tTokens;\\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\\n mapping(address => EnumerableSet.AddressSet) signers;\\n // Maps lending token to list of allowed collateral tokens\\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\\n}\\n\\nbytes32 constant MARKET_STORAGE_POS = keccak256(\\\"teller.market.storage\\\");\\n\\nlibrary MarketStorageLib {\\n function store() internal pure returns (MarketStorage storage s) {\\n bytes32 pos = MARKET_STORAGE_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb7e05aeec806b5621512def93f4a389b4ef88c50ef9fe7115a33f57db2f2304b\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "kind": "dev", + "methods": { + "init(address,uint16,uint16)": { + "params": { + "aTokenAddress": "Address of the Aave token that has the same underlying asset as the TToken.", + "balanceRatioMax": "Percentage indicating the _ limit of underlying token balance should remain on the TToken", + "balanceRatioMin": "Percentage indicating the _ limit of underlying token balance should remain on the TToken" + } + }, + "supportsInterface(bytes4)": { + "params": { + "interfaceId": "Id of the interface in question" + } + }, + "totalUnderlyingSupply()": { + "returns": { + "_0": "uint256 the underlying supply" + } + }, + "withdraw(uint256)": { + "params": { + "amount": "Amount of underlying tokens that must be available." + } + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "init(address,uint16,uint16)": { + "notice": "Sets the Aave token that should be used to manage the underlying Teller Token asset." + }, + "rebalance()": { + "notice": "Rebalances the underlying asset held by the Teller Token. This strategy looks at the ratio of held underlying asset balance and balance deposited into Aave. Based on the store {balanceRatioMin} and {balanceRatioMax} values, will deposit or withdraw to keep the ratio within that range." + }, + "supportsInterface(bytes4)": { + "notice": "it checks if interface is supported according to the ERC165 standard" + }, + "totalUnderlyingSupply()": { + "notice": "it returns the total supply of an underlying asset in a Teller token." + }, + "withdraw(uint256)": { + "notice": "Rebalances the TToken funds by indicating a minimum {amount} of underlying tokens that must be present after the call.If the minimum amount is present, no rebalance happens." + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/TTokenBeaconFactory.json b/deployments/polygon_mumbai/TTokenBeaconFactory.json new file mode 100644 index 000000000..78061c825 --- /dev/null +++ b/deployments/polygon_mumbai/TTokenBeaconFactory.json @@ -0,0 +1,286 @@ +{ + "address": "0x29385cD1Cc03Df08f8e7BfEa0eF3e073598A190C", + "abi": [ + { + "inputs": [ + { + "internalType": "address payable", + "name": "proxyAddress_", + "type": "address" + }, + { + "internalType": "address", + "name": "implementation_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "implementation", + "type": "address" + } + ], + "name": "Upgraded", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes", + "name": "initData", + "type": "bytes" + } + ], + "name": "cloneProxy", + "outputs": [ + { + "internalType": "address payable", + "name": "proxy_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "implementation", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "proxyAddress", + "outputs": [ + { + "internalType": "contract InitializeableBeaconProxy", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "renounceOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newImplementation", + "type": "address" + } + ], + "name": "upgradeTo", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "UpgradeableBeaconFactory", + "transactionHash": "0x83b1e300f10120fbfd234c9af450d3e269ad362fcaebb514e8dc15dc5471e97c", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x29385cD1Cc03Df08f8e7BfEa0eF3e073598A190C", + "transactionIndex": 0, + "gasUsed": "481877", + "logsBloom": "0x00000000000000000000000000008000000000000000000000800000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000800101000000000000000100000000004000000000020000000000000000000800200000000000000080000000000000400000000000000000000000000000000000000000000080000000000000000000200000000080000000000000000000000000000000000000000000000000004000000000000100000001000000040000000000000000000000100040000020000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0x8986f64ccee4c0b4a1991c8211da44462fea3ff03f97344bfe029058f2dec466", + "transactionHash": "0x83b1e300f10120fbfd234c9af450d3e269ad362fcaebb514e8dc15dc5471e97c", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692434, + "transactionHash": "0x83b1e300f10120fbfd234c9af450d3e269ad362fcaebb514e8dc15dc5471e97c", + "address": "0x29385cD1Cc03Df08f8e7BfEa0eF3e073598A190C", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 0, + "blockHash": "0x8986f64ccee4c0b4a1991c8211da44462fea3ff03f97344bfe029058f2dec466" + }, + { + "transactionIndex": 0, + "blockNumber": 15692434, + "transactionHash": "0x83b1e300f10120fbfd234c9af450d3e269ad362fcaebb514e8dc15dc5471e97c", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000be188d6641e8b680743a4815dfa0f6208038960f" + ], + "data": "0x00000000000000000000000000000000000000000000000000335beff6501c000000000000000000000000000000000000000000000000003ffb8f713958500000000000000000000000000000000000000000000000007e5850532ee49849500000000000000000000000000000000000000000000000003fc833814308340000000000000000000000000000000000000000000000007e5883af1edae86550", + "logIndex": 1, + "blockHash": "0x8986f64ccee4c0b4a1991c8211da44462fea3ff03f97344bfe029058f2dec466" + } + ], + "blockNumber": 15692434, + "cumulativeGasUsed": "481877", + "status": 1, + "byzantium": true + }, + "args": [ + "0xbC71607119F3daf4A7F3baDd7bBA9A1fd072D9B1", + "0x49379d04a0b66F7ee94f4b813b2c151a7b97FE29" + ], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address payable\",\"name\":\"proxyAddress_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"implementation_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"initData\",\"type\":\"bytes\"}],\"name\":\"cloneProxy\",\"outputs\":[{\"internalType\":\"address payable\",\"name\":\"proxy_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"implementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxyAddress\",\"outputs\":[{\"internalType\":\"contract InitializeableBeaconProxy\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their implementation contract, which is where they will delegate all function calls. An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\",\"events\":{\"Upgraded(address)\":{\"details\":\"Emitted when the implementation returned by the beacon is changed.\"}},\"kind\":\"dev\",\"methods\":{\"cloneProxy(bytes)\":{\"params\":{\"initData\":\"the data to initialize after the proxy is cloned\"},\"returns\":{\"proxy_\":\"the cloned proxy\"}},\"constructor\":{\"details\":\"Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the beacon.\"},\"implementation()\":{\"details\":\"Returns the current implementation address.\"},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"},\"upgradeTo(address)\":{\"details\":\"Upgrades the beacon to a new implementation. Emits an {Upgraded} event. Requirements: - msg.sender must be the owner of the contract. - `newImplementation` must be a contract.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"cloneProxy(bytes)\":{\"notice\":\"it clones the proxy contract at an address\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":\"UpgradeableBeaconFactory\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor () {\\n address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender);\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner;\\n }\\n}\\n\",\"keccak256\":\"0x1cae4f85f114ff17b90414f5da67365b1d00337abb5bce9bf944eb78a2c0673c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create(0, ptr, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\\n instance := create2(0, ptr, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\\n mstore(add(ptr, 0x14), shl(0x60, implementation))\\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\\n mstore(add(ptr, 0x38), shl(0x60, deployer))\\n mstore(add(ptr, 0x4c), salt)\\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\\n predicted := keccak256(add(ptr, 0x37), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x90dec20805396efc780a82c62578626103e03278bc1f48b61bb3aba52a61617c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc706395df88dc1d459f21e51c57ab8820af80d1e8c3c14933a651794d78a429f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\\n *\\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\\n * conflict with the storage layout of the implementation behind the proxy.\\n *\\n * _Available since v3.4._\\n */\\ncontract InitializeableBeaconProxy is Proxy {\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 private constant _BEACON_SLOT =\\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Initializes the proxy with `beacon`.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\\n * constructor.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract with the interface {IBeacon}.\\n */\\n function initialize(address beacon, bytes memory data) external payable {\\n assert(\\n _BEACON_SLOT ==\\n bytes32(uint256(keccak256(\\\"eip1967.proxy.beacon\\\")) - 1)\\n );\\n require(_beacon() == address(0), \\\"Beacon: already initialized\\\");\\n\\n _setBeacon(beacon, data);\\n }\\n\\n /**\\n * @dev Returns the current beacon address.\\n */\\n function _beacon() internal view virtual returns (address beacon) {\\n bytes32 slot = _BEACON_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n beacon := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Returns the current implementation address of the associated beacon.\\n */\\n function _implementation()\\n internal\\n view\\n virtual\\n override\\n returns (address)\\n {\\n return IBeacon(_beacon()).implementation();\\n }\\n\\n /**\\n * @dev Changes the proxy to use a new beacon.\\n *\\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\\n *\\n * Requirements:\\n *\\n * - `beacon` must be a contract.\\n * - The implementation returned by `beacon` must be a contract.\\n */\\n function _setBeacon(address beacon, bytes memory data) internal virtual {\\n bytes32 slot = _BEACON_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, beacon)\\n }\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(\\n _implementation(),\\n data,\\n \\\"BeaconProxy: function call failed\\\"\\n );\\n }\\n }\\n\\n receive() external payable override {\\n // Needed to receive ETH without data\\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\\n }\\n}\\n\",\"keccak256\":\"0x48aefbbc0c51b106f4d69580fa802dc6c5d7573fee24cb7d08f5370d79a2e6f2\",\"license\":\"MIT\"},\"contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"./InitializeableBeaconProxy.sol\\\";\\n\\n/**\\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\\n * implementation contract, which is where they will delegate all function calls.\\n *\\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\\n */\\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\\n address private _implementation;\\n InitializeableBeaconProxy public proxyAddress;\\n\\n /**\\n * @dev Emitted when the implementation returned by the beacon is changed.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\\n * beacon.\\n */\\n constructor(address payable proxyAddress_, address implementation_) {\\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\\n _setImplementation(implementation_);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function implementation() public view virtual override returns (address) {\\n return _implementation;\\n }\\n\\n /**\\n * @notice it clones the proxy contract at an address\\n * @param initData the data to initialize after the proxy is cloned\\n * @return proxy_ the cloned proxy\\n */\\n function cloneProxy(bytes memory initData)\\n external\\n returns (address payable proxy_)\\n {\\n proxy_ = payable(Clones.clone(address(proxyAddress)));\\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\\n }\\n\\n /**\\n * @dev Upgrades the beacon to a new implementation.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * Requirements:\\n *\\n * - msg.sender must be the owner of the contract.\\n * - `newImplementation` must be a contract.\\n */\\n function upgradeTo(address newImplementation) public virtual onlyOwner {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Sets the implementation contract address for this beacon\\n *\\n * Requirements:\\n *\\n * - `newImplementation` must be a contract.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(\\n Address.isContract(newImplementation),\\n \\\"UpgradeableBeacon: implementation is not a contract\\\"\\n );\\n _implementation = newImplementation;\\n }\\n}\\n\",\"keccak256\":\"0xd25191f91a4d8e64085aa73ecc7c18939d87aea17241ebb2aa9035021898d9d9\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "0x608060405234801561001057600080fd5b506004361061007d5760003560e01c80635c60da1b1161005b5780635c60da1b146100d9578063715018a6146100ea5780638da5cb5b146100f2578063f2fde38b146101035761007d565b806323f5c02d146100825780633659cfe6146100b15780634ecc58d2146100c6575b600080fd5b600254610095906001600160a01b031681565b6040516001600160a01b03909116815260200160405180910390f35b6100c46100bf36600461049c565b610116565b005b6100956100d43660046104ca565b610189565b6001546001600160a01b0316610095565b6100c4610209565b6000546001600160a01b0316610095565b6100c461011136600461049c565b61027d565b6000546001600160a01b031633146101495760405162461bcd60e51b8152600401610140906105d7565b60405180910390fd5b61015281610371565b6040516001600160a01b038216907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a250565b6002546000906101a1906001600160a01b0316610404565b60405163347d5e2560e21b81529091506001600160a01b0382169063d1f57894906101d29030908690600401610574565b600060405180830381600087803b1580156101ec57600080fd5b505af1158015610200573d6000803e3d6000fd5b50505050919050565b6000546001600160a01b031633146102335760405162461bcd60e51b8152600401610140906105d7565b600080546040516001600160a01b03909116907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a3600080546001600160a01b0319169055565b6000546001600160a01b031633146102a75760405162461bcd60e51b8152600401610140906105d7565b6001600160a01b03811661030c5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608401610140565b600080546040516001600160a01b03808516939216917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e091a3600080546001600160a01b0319166001600160a01b0392909216919091179055565b803b15155b919050565b61037a81610367565b6103e25760405162461bcd60e51b815260206004820152603360248201527f5570677261646561626c65426561636f6e3a20696d706c656d656e746174696f6044820152721b881a5cc81b9bdd08184818dbdb9d1c9858dd606a1b6064820152608401610140565b600180546001600160a01b0319166001600160a01b0392909216919091179055565b6000604051733d602d80600a3d3981f3363d3d373d3d3d363d7360601b81528260601b60148201526e5af43d82803e903d91602b57fd5bf360881b60288201526037816000f09150506001600160a01b03811661036c5760405162461bcd60e51b8152602060048201526016602482015275115490cc4c4d8dce8818dc99585d194819985a5b195960521b6044820152606401610140565b6000602082840312156104ad578081fd5b81356001600160a01b03811681146104c3578182fd5b9392505050565b6000602082840312156104db578081fd5b813567ffffffffffffffff808211156104f2578283fd5b818401915084601f830112610505578283fd5b8135818111156105175761051761060c565b604051601f8201601f19908116603f0116810190838211818310171561053f5761053f61060c565b81604052828152876020848701011115610557578586fd5b826020860160208301379182016020019490945295945050505050565b600060018060a01b038416825260206040818401528351806040850152825b818110156105af57858101830151858201606001528201610593565b818111156105c05783606083870101525b50601f01601f191692909201606001949350505050565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b634e487b7160e01b600052604160045260246000fdfea264697066735822122082a5de87655532a71f5758f186767aba13e1131e65f3a7cf6a66bbadc426ed3164736f6c63430008030033", + "devdoc": { + "details": "This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their implementation contract, which is where they will delegate all function calls. An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.", + "events": { + "Upgraded(address)": { + "details": "Emitted when the implementation returned by the beacon is changed." + } + }, + "kind": "dev", + "methods": { + "cloneProxy(bytes)": { + "params": { + "initData": "the data to initialize after the proxy is cloned" + }, + "returns": { + "proxy_": "the cloned proxy" + } + }, + "constructor": { + "details": "Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the beacon." + }, + "implementation()": { + "details": "Returns the current implementation address." + }, + "owner()": { + "details": "Returns the address of the current owner." + }, + "renounceOwnership()": { + "details": "Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner." + }, + "transferOwnership(address)": { + "details": "Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner." + }, + "upgradeTo(address)": { + "details": "Upgrades the beacon to a new implementation. Emits an {Upgraded} event. Requirements: - msg.sender must be the owner of the contract. - `newImplementation` must be a contract." + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "cloneProxy(bytes)": { + "notice": "it clones the proxy contract at an address" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [ + { + "astId": 3103, + "contract": "contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol:UpgradeableBeaconFactory", + "label": "_owner", + "offset": 0, + "slot": "0", + "type": "t_address" + }, + { + "astId": 25428, + "contract": "contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol:UpgradeableBeaconFactory", + "label": "_implementation", + "offset": 0, + "slot": "1", + "type": "t_address" + }, + { + "astId": 25431, + "contract": "contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol:UpgradeableBeaconFactory", + "label": "proxyAddress", + "offset": 0, + "slot": "2", + "type": "t_contract(InitializeableBeaconProxy)25414" + } + ], + "types": { + "t_address": { + "encoding": "inplace", + "label": "address", + "numberOfBytes": "20" + }, + "t_contract(InitializeableBeaconProxy)25414": { + "encoding": "inplace", + "label": "contract InitializeableBeaconProxy", + "numberOfBytes": "20" + } + } + } +} diff --git a/deployments/polygon_mumbai/TToken_V1.json b/deployments/polygon_mumbai/TToken_V1.json new file mode 100644 index 000000000..1c25d6737 --- /dev/null +++ b/deployments/polygon_mumbai/TToken_V1.json @@ -0,0 +1,1076 @@ +{ + "address": "0x49379d04a0b66F7ee94f4b813b2c151a7b97FE29", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "owner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "spender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + } + ], + "name": "Approval", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tTokenAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "underlyingAmount", + "type": "uint256" + } + ], + "name": "Mint", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tTokenAmount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "underlyingAmount", + "type": "uint256" + } + ], + "name": "Redeem", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "from", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + } + ], + "name": "Transfer", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + }, + { + "internalType": "address", + "name": "spender", + "type": "address" + } + ], + "name": "allowance", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "spender", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "approve", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "balanceOf", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "balanceOfUnderlying", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "currentTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "tvl_", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "newLoanAmount", + "type": "uint256" + } + ], + "name": "debtRatioFor", + "outputs": [ + { + "internalType": "uint16", + "name": "ratio_", + "type": "uint16" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "decimals", + "outputs": [ + { + "internalType": "uint8", + "name": "", + "type": "uint8" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "spender", + "type": "address" + }, + { + "internalType": "uint256", + "name": "subtractedValue", + "type": "uint256" + } + ], + "name": "decreaseAllowance", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "exchangeRate", + "outputs": [ + { + "internalType": "uint256", + "name": "rate_", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "recipient", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "fundLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getMarketState", + "outputs": [ + { + "internalType": "uint256", + "name": "totalSupplied", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "totalBorrowed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "totalRepaid", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "totalInterestRepaid", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "totalOnLoan", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getStrategy", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "grantRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasRole", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "spender", + "type": "address" + }, + { + "internalType": "uint256", + "name": "addedValue", + "type": "uint256" + } + ], + "name": "increaseAllowance", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "internalType": "address", + "name": "underlying", + "type": "address" + } + ], + "name": "initialize", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "mint", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "name", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "rebalance", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "redeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "redeemUnderlying", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + } + ], + "name": "renounceRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestAmount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "restrict", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "revokeRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "strategy", + "type": "address" + }, + { + "internalType": "bytes", + "name": "initData", + "type": "bytes" + } + ], + "name": "setStrategy", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "symbol", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "totalSupply", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "totalUnderlyingSupply", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "recipient", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "transfer", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "internalType": "address", + "name": "recipient", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "transferFrom", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "underlying", + "outputs": [ + { + "internalType": "contract ERC20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + } + ], + "artifactName": "TToken_V1", + "transactionHash": "0x4257ce438733e40c02429959ddfb5f879c25d11689657599ca85730e76449723", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x49379d04a0b66F7ee94f4b813b2c151a7b97FE29", + "transactionIndex": 1, + "gasUsed": "2335870", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000800100000000000000000100000000004000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000080000000000000000000200000000000000000000000000000000000000000000000000000000000004000000000000100000001000000000000000000000000000000100040000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0xecef11f62bee29e2109f0061074a6232ebcf3dac52a4ca2fdd7a94f0eeacc6a9", + "transactionHash": "0x4257ce438733e40c02429959ddfb5f879c25d11689657599ca85730e76449723", + "logs": [ + { + "transactionIndex": 1, + "blockNumber": 15692430, + "transactionHash": "0x4257ce438733e40c02429959ddfb5f879c25d11689657599ca85730e76449723", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000be188d6641e8b680743a4815dfa0f6208038960f" + ], + "data": "0x00000000000000000000000000000000000000000000000000f8f5d777bea80000000000000000000000000000000000000000000000000040f48548b116f80000000000000000000000000000000000000000000000007e5743e40bdd0655500000000000000000000000000000000000000000000000003ffb8f713958500000000000000000000000000000000000000000000000007e583cd9e354c4fd50", + "logIndex": 2, + "blockHash": "0xecef11f62bee29e2109f0061074a6232ebcf3dac52a4ca2fdd7a94f0eeacc6a9" + } + ], + "blockNumber": 15692430, + "cumulativeGasUsed": "2356870", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tTokenAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"underlyingAmount\",\"type\":\"uint256\"}],\"name\":\"Mint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tTokenAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"underlyingAmount\",\"type\":\"uint256\"}],\"name\":\"Redeem\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOfUnderlying\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"currentTVL\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"tvl_\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newLoanAmount\",\"type\":\"uint256\"}],\"name\":\"debtRatioFor\",\"outputs\":[{\"internalType\":\"uint16\",\"name\":\"ratio_\",\"type\":\"uint16\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"exchangeRate\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"rate_\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"fundLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getMarketState\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"totalSupplied\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalBorrowed\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalRepaid\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalInterestRepaid\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalOnLoan\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getStrategy\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"grantRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"hasRole\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"underlying\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rebalance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"redeem\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"redeemUnderlying\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"}],\"name\":\"renounceRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"interestAmount\",\"type\":\"uint256\"}],\"name\":\"repayLoan\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"state\",\"type\":\"bool\"}],\"name\":\"restrict\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"revokeRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"strategy\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"initData\",\"type\":\"bytes\"}],\"name\":\"setStrategy\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalUnderlyingSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"underlying\",\"outputs\":[{\"internalType\":\"contract ERC20\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"develop@teller.finance\",\"kind\":\"dev\",\"methods\":{\"allowance(address,address)\":{\"details\":\"See {IERC20-allowance}.\"},\"approve(address,uint256)\":{\"details\":\"See {IERC20-approve}. Requirements: - `spender` cannot be the zero address.\"},\"balanceOf(address)\":{\"details\":\"See {IERC20-balanceOf}.\"},\"balanceOfUnderlying(address)\":{\"params\":{\"account\":\"Address to calculate the underlying balance.\"},\"returns\":{\"_0\":\"balance_ the balance of the account\"}},\"currentTVL()\":{\"returns\":{\"tvl_\":\"The value locked in the pool. Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\"}},\"debtRatioFor(uint256)\":{\"params\":{\"newLoanAmount\":\"the new loan amount to consider the StD ratio.\"},\"returns\":{\"ratio_\":\"Whether debt ratio for lending pool is valid.\"}},\"decimals()\":{\"returns\":{\"_0\":\"decimals of the token\"}},\"decreaseAllowance(address,uint256)\":{\"details\":\"Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`.\"},\"exchangeRate()\":{\"returns\":{\"rate_\":\"The current exchange rate.\"}},\"fundLoan(address,uint256)\":{\"params\":{\"amount\":\"Funds requested to fulfil the loan.\",\"recipient\":\"The account to send the funds to.\"}},\"getMarketState()\":{\"returns\":{\"totalBorrowed\":\"Total amount borrowed through loans.\",\"totalInterestRepaid\":\"The total amount interest repaid till the current timestamp.\",\"totalOnLoan\":\"Total amount currently deployed in loans.\",\"totalRepaid\":\"The total amount repaid till the current timestamp.\",\"totalSupplied\":\"Total amount of the underlying asset supplied.\"}},\"getStrategy()\":{\"returns\":{\"_0\":\"address of the strategy contract\"}},\"grantRole(bytes32,address)\":{\"params\":{\"account\":\"Address to give the {role} to. Requirements: - Sender must be role admin.\",\"role\":\"Encoding of the role to give.\"}},\"hasRole(bytes32,address)\":{\"params\":{\"account\":\"Address to check the {role} for.\",\"role\":\"Encoding of the role to check.\"}},\"increaseAllowance(address,uint256)\":{\"details\":\"Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address.\"},\"initialize(address,address)\":{\"params\":{\"admin\":\"address of the admin to the respective Teller Token\",\"underlying\":\"address of the ERC20 token\"}},\"mint(uint256)\":{\"params\":{\"amount\":\"The amount of underlying tokens to use to mint.\"},\"returns\":{\"_0\":\"Amount of TTokens minted.\"}},\"name()\":{\"details\":\"Returns the name of the token.\"},\"redeem(uint256)\":{\"params\":{\"amount\":\"The amount of Teller tokens to redeem.\"}},\"redeemUnderlying(uint256)\":{\"params\":{\"amount\":\"The amount of underlying tokens to redeem.\"}},\"renounceRole(bytes32)\":{\"params\":{\"role\":\"Encoding of the role to remove.\"}},\"repayLoan(uint256,uint256)\":{\"params\":{\"amount\":\"Funds deposited back into the pool to repay the principal amount of a loan.\",\"interestAmount\":\"Interest value paid into the pool from a loan.\"}},\"restrict(bool)\":{\"params\":{\"state\":\"boolean value that resembles the platform's state\"}},\"revokeRole(bytes32,address)\":{\"params\":{\"account\":\"Address to remove the {role} from. Requirements: - Sender must be role admin.\",\"role\":\"Encoding of the role to remove.\"}},\"setStrategy(address,bytes)\":{\"params\":{\"initData\":\"Optional data to initialize the strategy. Requirements: - Sender must have ADMIN role\",\"strategy\":\"Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\"}},\"symbol()\":{\"details\":\"Returns the symbol of the token, usually a shorter version of the name.\"},\"totalSupply()\":{\"details\":\"See {IERC20-totalSupply}.\"},\"totalUnderlyingSupply()\":{\"returns\":{\"_0\":\"totalSupply_ the total supply denoted in the underlying asset.\"}},\"transfer(address,uint256)\":{\"details\":\"See {IERC20-transfer}. Requirements: - `recipient` cannot be the zero address. - the caller must have a balance of at least `amount`.\"},\"transferFrom(address,address,uint256)\":{\"details\":\"See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. Requirements: - `sender` and `recipient` cannot be the zero address. - `sender` must have a balance of at least `amount`. - the caller must have allowance for ``sender``'s tokens of at least `amount`.\"},\"underlying()\":{\"returns\":{\"_0\":\"ERC20 token that is the underlying asset\"}}},\"version\":1},\"userdoc\":{\"events\":{\"Mint(address,uint256,uint256)\":{\"notice\":\"This event is emitted when a user deposits tokens into the pool.\"},\"Redeem(address,uint256,uint256)\":{\"notice\":\"This event is emitted when a user withdraws tokens from the pool.\"}},\"kind\":\"user\",\"methods\":{\"balanceOfUnderlying(address)\":{\"notice\":\"The balance of an {account} denoted in underlying value.\"},\"currentTVL()\":{\"notice\":\"Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\"},\"debtRatioFor(uint256)\":{\"notice\":\"It validates whether supply to debt (StD) ratio is valid including the loan amount.\"},\"decimals()\":{\"notice\":\"it returns the decimal places of the respective TToken\"},\"exchangeRate()\":{\"notice\":\"It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\"},\"fundLoan(address,uint256)\":{\"notice\":\"Called by the Teller Diamond contract when a loan has been taken out and requires funds.\"},\"getMarketState()\":{\"notice\":\"It calculates the market state values across a given markets.Returns values that represent the global state across the market.\"},\"getStrategy()\":{\"notice\":\"Gets the strategy used for balancing funds.\"},\"grantRole(bytes32,address)\":{\"notice\":\"Grants an account a new role.\"},\"hasRole(bytes32,address)\":{\"notice\":\"Checks if an account has a specific role.\"},\"initialize(address,address)\":{\"notice\":\"it initializes the Teller Token\"},\"mint(uint256)\":{\"notice\":\"Deposit underlying token amount into LP and mint tokens.\"},\"rebalance()\":{\"notice\":\"Rebalances the funds controlled by Teller Token according to the current strategy. See {TTokenStrategy}.\"},\"redeem(uint256)\":{\"notice\":\"Redeem supplied Teller token underlying value.\"},\"redeemUnderlying(uint256)\":{\"notice\":\"Redeem supplied underlying value.\"},\"renounceRole(bytes32)\":{\"notice\":\"Removes a role from the sender.\"},\"repayLoan(uint256,uint256)\":{\"notice\":\"Called by the Teller Diamond contract when a loan has been repaid.\"},\"restrict(bool)\":{\"notice\":\"Sets the restricted state of the platform.\"},\"revokeRole(bytes32,address)\":{\"notice\":\"Removes a role from an account.\"},\"setStrategy(address,bytes)\":{\"notice\":\"Sets a new strategy to use for balancing funds.\"},\"totalUnderlyingSupply()\":{\"notice\":\"It calculates the total supply of the underlying asset.\"},\"underlying()\":{\"notice\":\"The token that is the underlying assets for this Teller token.\"}},\"notice\":\"This contract represents a lending pool for an asset within Teller protocol.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/lending/ttoken/TToken_V1.sol\":\"TToken_V1\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0x9c2d7425f3343ea340d6ea67e9d90109d4d846bb013c2572096ec88c9e74946b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x8d4a0f2b5b760b5e2c19ed3c108d83897a4dfd5bfed97a93867918df19191e5e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x6795c369a4eefa78468e38966f7851fbc2dda5e5b9ccd3fa2b45970e2e4d3abd\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping (address => uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The defaut value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor (string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance\\\");\\n _approve(sender, _msgSender(), currentAllowance - amount);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[sender] = senderBalance - amount;\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n _balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _balances[account] = accountBalance - amount;\\n _totalSupply -= amount;\\n\\n emit Transfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\\n}\\n\",\"keccak256\":\"0xfeccdcbf67b2006a715e5af1a4c7556004d95b2806552b5cc54e46e8eb7e887b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xf8e8d118a7a8b2e134181f7da655f6266aa3a0f9134b2605747139fcb0c5d835\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x83fe24f5c04a56091e50f4a345ff504c8bff658a76d4c43b16878c8f940c53b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n // solhint-disable-next-line max-line-length\\n require((value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) { // Return data is optional\\n // solhint-disable-next-line max-line-length\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x99f5c21018d796db7833a2100bb0e7411999e248a3c950fb526eee5d2bf47cb7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x069b2631bb5b5193a58ccf7a06266c7361bd2c20095667af4402817605627f45\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xf930d2df426bfcfc1f7415be724f04081c96f4fb9ec8d0e3a521c07692dface0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/ERC165Checker.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165.sol\\\";\\n\\n/**\\n * @dev Library used to query support of an interface declared via {IERC165}.\\n *\\n * Note that these functions return the actual result of the query: they do not\\n * `revert` if an interface is not supported. It is up to the caller to decide\\n * what to do in these cases.\\n */\\nlibrary ERC165Checker {\\n // As per the EIP-165 spec, no interface should ever match 0xffffffff\\n bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;\\n\\n /**\\n * @dev Returns true if `account` supports the {IERC165} interface,\\n */\\n function supportsERC165(address account) internal view returns (bool) {\\n // Any contract that implements ERC165 must explicitly indicate support of\\n // InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid\\n return _supportsERC165Interface(account, type(IERC165).interfaceId) &&\\n !_supportsERC165Interface(account, _INTERFACE_ID_INVALID);\\n }\\n\\n /**\\n * @dev Returns true if `account` supports the interface defined by\\n * `interfaceId`. Support for {IERC165} itself is queried automatically.\\n *\\n * See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) {\\n // query support of both ERC165 as per the spec and support of _interfaceId\\n return supportsERC165(account) &&\\n _supportsERC165Interface(account, interfaceId);\\n }\\n\\n /**\\n * @dev Returns a boolean array where each value corresponds to the\\n * interfaces passed in and whether they're supported or not. This allows\\n * you to batch check interfaces for a contract where your expectation\\n * is that some interfaces may not be supported.\\n *\\n * See {IERC165-supportsInterface}.\\n *\\n * _Available since v3.4._\\n */\\n function getSupportedInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool[] memory) {\\n // an array of booleans corresponding to interfaceIds and whether they're supported or not\\n bool[] memory interfaceIdsSupported = new bool[](interfaceIds.length);\\n\\n // query support of ERC165 itself\\n if (supportsERC165(account)) {\\n // query support of each interface in interfaceIds\\n for (uint256 i = 0; i < interfaceIds.length; i++) {\\n interfaceIdsSupported[i] = _supportsERC165Interface(account, interfaceIds[i]);\\n }\\n }\\n\\n return interfaceIdsSupported;\\n }\\n\\n /**\\n * @dev Returns true if `account` supports all the interfaces defined in\\n * `interfaceIds`. Support for {IERC165} itself is queried automatically.\\n *\\n * Batch-querying can lead to gas savings by skipping repeated checks for\\n * {IERC165} support.\\n *\\n * See {IERC165-supportsInterface}.\\n */\\n function supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) {\\n // query support of ERC165 itself\\n if (!supportsERC165(account)) {\\n return false;\\n }\\n\\n // query support of each interface in _interfaceIds\\n for (uint256 i = 0; i < interfaceIds.length; i++) {\\n if (!_supportsERC165Interface(account, interfaceIds[i])) {\\n return false;\\n }\\n }\\n\\n // all interfaces supported\\n return true;\\n }\\n\\n /**\\n * @notice Query if a contract implements an interface, does not check ERC165 support\\n * @param account The address of the contract to query for support of an interface\\n * @param interfaceId The interface identifier, as specified in ERC-165\\n * @return true if the contract at account indicates support of the interface with\\n * identifier interfaceId, false otherwise\\n * @dev Assumes that account contains a contract that supports ERC165, otherwise\\n * the behavior of this method is undefined. This precondition can be checked\\n * with {supportsERC165}.\\n * Interface identification is specified in ERC-165.\\n */\\n function _supportsERC165Interface(address account, bytes4 interfaceId) private view returns (bool) {\\n bytes memory encodedParams = abi.encodeWithSelector(IERC165(account).supportsInterface.selector, interfaceId);\\n (bool success, bytes memory result) = account.staticcall{ gas: 30000 }(encodedParams);\\n if (result.length < 32) return false;\\n return success && abi.decode(result, (bool));\\n }\\n}\\n\",\"keccak256\":\"0xa3c1d99239060855105fa0ad23c710be3c8db7013c470c48e2450f416312fd98\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesFacet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesMods } from \\\"./RolesMods.sol\\\";\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\nimport { ADMIN } from \\\"../../../shared/roles.sol\\\";\\n\\ncontract RolesFacet is RolesMods {\\n /**\\n * @notice Checks if an account has a specific role.\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n function hasRole(bytes32 role, address account)\\n external\\n view\\n returns (bool)\\n {\\n return RolesLib.hasRole(role, account);\\n }\\n\\n /**\\n * @notice Grants an account a new role.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.grantRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from an account.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function revokeRole(bytes32 role, address account)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n RolesLib.revokeRole(role, account);\\n }\\n\\n /**\\n * @notice Removes a role from the sender.\\n * @param role Encoding of the role to remove.\\n */\\n function renounceRole(bytes32 role) external {\\n RolesLib.revokeRole(role, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x3d02fb1286754a6da3419c81632d23e9444b1fe8cd64283e15fcb07a9b201815\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { AccessControlStorageLib, AccessControlStorage } from \\\"../storage.sol\\\";\\n\\nlibrary RolesLib {\\n function s() private pure returns (AccessControlStorage storage) {\\n return AccessControlStorageLib.store();\\n }\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @notice Checks if an account has a specific role.\\n */\\n function hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool)\\n {\\n return s().roles[role][account];\\n }\\n\\n /**\\n * @dev Gives an account a new role.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account already has the role, no event is emitted.\\n * @param role Encoding of the role to give.\\n * @param account Address to give the {role} to.\\n */\\n function grantRole(bytes32 role, address account) internal {\\n if (hasRole(role, account)) return;\\n s().roles[role][account] = true;\\n emit RoleGranted(role, account, msg.sender);\\n }\\n\\n /**\\n * @dev Removes a role from an account.\\n * @dev Should only use when circumventing admin checking.\\n * @dev If account does not already have the role, no event is emitted.\\n * @param role Encoding of the role to remove.\\n * @param account Address to remove the {role} from.\\n */\\n function revokeRole(bytes32 role, address account) internal {\\n if (!hasRole(role, account)) return;\\n s().roles[role][account] = false;\\n emit RoleRevoked(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x36d0f5db441d2c3db7ee04d84c88ce9b14251cff4387702e96965c51acd1bc84\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/roles/RolesMods.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RolesLib } from \\\"./RolesLib.sol\\\";\\n\\nabstract contract RolesMods {\\n /**\\n * @notice Requires that the {account} has {role}\\n * @param role Encoding of the role to check.\\n * @param account Address to check the {role} for.\\n */\\n modifier authorized(bytes32 role, address account) {\\n require(\\n RolesLib.hasRole(role, account),\\n \\\"AccessControl: not authorized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x25eeaba823d4fc9c52d82a77cfdb409550ad985fc49b30a5560c1f313c1ca905\",\"license\":\"MIT\"},\"contracts/contexts2/access-control/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct AccessControlStorage {\\n mapping(bytes32 => mapping(address => bool)) roles;\\n mapping(address => address) owners;\\n mapping(bytes32 => bool) entered;\\n}\\n\\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\\n \\\"teller.access_control.storage\\\"\\n);\\n\\nlibrary AccessControlStorageLib {\\n function store() internal pure returns (AccessControlStorage storage s) {\\n bytes32 pos = ACCESS_CONTROL_POS;\\n assembly {\\n s.slot := pos\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf667fb8d6beb59fc6f37d60ada6b811b5861512fedc661c483b9eca042e96112\",\"license\":\"MIT\"},\"contracts/lending/ttoken/ITToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n ERC20Upgradeable\\n} from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\nimport {\\n RolesFacet\\n} from \\\"../../contexts2/access-control/roles/RolesFacet.sol\\\";\\n\\n/**\\n * @notice This contract acts as an interface for the Teller token (TToken).\\n *\\n * @author develop@teller.finance\\n */\\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\\n /**\\n * @notice This event is emitted when a user deposits tokens into the pool.\\n */\\n event Mint(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice This event is emitted when a user withdraws tokens from the pool.\\n */\\n event Redeem(\\n address indexed sender,\\n uint256 tTokenAmount,\\n uint256 underlyingAmount\\n );\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n * @return ERC20 token\\n */\\n function underlying() external view virtual returns (ERC20);\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n * @return balance_ the balance of the account\\n */\\n function balanceOfUnderlying(address account)\\n external\\n virtual\\n returns (uint256 balance_);\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() external virtual returns (uint256 rate_);\\n\\n /**\\n * @notice It calculates the total supply of the underlying asset.\\n * @return totalSupply_ the total supply denoted in the underlying asset.\\n */\\n function totalUnderlyingSupply()\\n external\\n virtual\\n returns (uint256 totalSupply_);\\n\\n /**\\n * @notice It calculates the market state values across a given market.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n virtual\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n );\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() external virtual returns (uint256 tvl_);\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n virtual\\n returns (uint16 ratio_);\\n \\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfill the loan.\\n */\\n function fundLoan(address recipient, uint256 amount) external virtual;\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\\n\\n /**\\n * @notice Increase account supply of specified token amount.\\n * @param amount The amount of underlying tokens to use to mint.\\n * @return mintAmount_ the amount minted of the specified token\\n */\\n function mint(uint256 amount)\\n external\\n virtual\\n returns (uint256 mintAmount_);\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external virtual;\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external virtual;\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() external virtual;\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n virtual;\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n * @return address of the strategy contract\\n */\\n function getStrategy() external view virtual returns (address);\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n * @param state boolean value that resembles the platform's state\\n */\\n function restrict(bool state) external virtual;\\n\\n /**\\n * @notice it initializes the Teller Token\\n * @param admin address of the admin to the respective Teller Token\\n * @param underlying address of the ERC20 token\\n */\\n function initialize(address admin, address underlying) external virtual;\\n}\\n\",\"keccak256\":\"0xf30ac4ef491851477ff9a3dd04974ebe74b529c37a3ef4e05798c3f734ceeb3d\",\"license\":\"MIT\"},\"contracts/lending/ttoken/TToken_V1.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport {\\n CONTROLLER,\\n ADMIN,\\n EXCHANGE_RATE_FACTOR,\\n ONE_HUNDRED_PERCENT\\n} from \\\"./data.sol\\\";\\nimport { ITTokenStrategy } from \\\"./strategies/ITTokenStrategy.sol\\\";\\nimport { ERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\n// Utils\\nimport { Address } from \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\n// Interfaces\\nimport { ITToken } from \\\"./ITToken.sol\\\";\\nimport { ICErc20 } from \\\"../../shared/interfaces/ICErc20.sol\\\";\\n\\n// Libraries\\nimport {\\n IERC20,\\n SafeERC20\\n} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport {\\n ERC165Checker\\n} from \\\"@openzeppelin/contracts/utils/introspection/ERC165Checker.sol\\\";\\nimport { RolesLib } from \\\"../../contexts2/access-control/roles/RolesLib.sol\\\";\\nimport { NumbersLib } from \\\"../../shared/libraries/NumbersLib.sol\\\";\\n\\n// Storage\\nimport \\\"./storage.sol\\\" as Storage;\\n\\n/**\\n * @notice This contract represents a lending pool for an asset within Teller protocol.\\n * @author develop@teller.finance\\n */\\ncontract TToken_V1 is ITToken {\\n function() pure returns (Storage.Store storage) private constant s =\\n Storage.store;\\n\\n /* Modifiers */\\n\\n /**\\n * @notice Checks if the LP is restricted or has the CONTROLLER role.\\n *\\n * The LP being restricted means that only the Teller protocol may\\n * lend/borrow funds.\\n */\\n modifier notRestricted {\\n require(\\n !s().restricted || RolesLib.hasRole(CONTROLLER, _msgSender()),\\n \\\"Teller: platform restricted\\\"\\n );\\n _;\\n }\\n\\n /* Public Functions */\\n\\n /**\\n * @notice it returns the decimal places of the respective TToken\\n * @return decimals of the token\\n */\\n function decimals() public view override returns (uint8) {\\n return s().decimals;\\n }\\n\\n /**\\n * @notice The token that is the underlying assets for this Teller token.\\n * @return ERC20 token that is the underlying asset\\n */\\n function underlying() public view override returns (ERC20) {\\n return s().underlying;\\n }\\n\\n /**\\n * @notice The balance of an {account} denoted in underlying value.\\n * @param account Address to calculate the underlying balance.\\n * @return balance_ the balance of the account\\n */\\n function balanceOfUnderlying(address account)\\n public\\n override\\n returns (uint256)\\n {\\n return _valueInUnderlying(balanceOf(account), exchangeRate());\\n }\\n\\n /**\\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\\n * @return rate_ The current exchange rate.\\n */\\n function exchangeRate() public override returns (uint256 rate_) {\\n if (totalSupply() == 0) {\\n return EXCHANGE_RATE_FACTOR;\\n }\\n\\n rate_ = (currentTVL() * EXCHANGE_RATE_FACTOR) / totalSupply();\\n }\\n\\n /**\\n * @notice It calculates the total supply of the underlying asset.\\n * @return totalSupply_ the total supply denoted in the underlying asset.\\n */\\n function totalUnderlyingSupply() public override returns (uint256) {\\n bytes memory data =\\n _delegateStrategy(\\n abi.encodeWithSelector(\\n ITTokenStrategy.totalUnderlyingSupply.selector\\n )\\n );\\n return abi.decode(data, (uint256));\\n }\\n\\n /**\\n * @notice It calculates the market state values across a given markets.\\n * @notice Returns values that represent the global state across the market.\\n * @return totalSupplied Total amount of the underlying asset supplied.\\n * @return totalBorrowed Total amount borrowed through loans.\\n * @return totalRepaid The total amount repaid till the current timestamp.\\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\\n * @return totalOnLoan Total amount currently deployed in loans.\\n */\\n function getMarketState()\\n external\\n override\\n returns (\\n uint256 totalSupplied,\\n uint256 totalBorrowed,\\n uint256 totalRepaid,\\n uint256 totalInterestRepaid,\\n uint256 totalOnLoan\\n )\\n {\\n totalSupplied = totalUnderlyingSupply();\\n totalBorrowed = s().totalBorrowed;\\n totalRepaid = s().totalRepaid;\\n totalInterestRepaid = s().totalInterestRepaid;\\n totalOnLoan = totalBorrowed - totalRepaid;\\n }\\n\\n /**\\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\\n * @return tvl_ The value locked in the pool.\\n *\\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\\n */\\n function currentTVL() public override returns (uint256 tvl_) {\\n tvl_ += totalUnderlyingSupply();\\n tvl_ += s().totalBorrowed;\\n tvl_ -= s().totalRepaid;\\n }\\n\\n /**\\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\\n * @param newLoanAmount the new loan amount to consider the StD ratio.\\n * @return ratio_ Whether debt ratio for lending pool is valid.\\n */\\n function debtRatioFor(uint256 newLoanAmount)\\n external\\n override\\n returns (uint16 ratio_)\\n {\\n uint256 onLoan = s().totalBorrowed - s().totalRepaid;\\n uint256 supplied = totalUnderlyingSupply() + onLoan;\\n if (supplied > 0) {\\n ratio_ = NumbersLib.ratioOf(onLoan + newLoanAmount, supplied);\\n }\\n }\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\\n * @param recipient The account to send the funds to.\\n * @param amount Funds requested to fulfil the loan.\\n */\\n function fundLoan(address recipient, uint256 amount)\\n external\\n override\\n authorized(CONTROLLER, _msgSender())\\n {\\n // If TToken is not holding enough funds to cover the loan, call the strategy to try to withdraw\\n uint256 balance = s().underlying.balanceOf(address(this));\\n if (balance < amount) {\\n _delegateStrategy(\\n abi.encodeWithSelector(\\n ITTokenStrategy.withdraw.selector,\\n amount - balance\\n )\\n );\\n }\\n\\n // Increase total borrowed amount\\n s().totalBorrowed += amount;\\n\\n // Transfer tokens to recipient\\n SafeERC20.safeTransfer(s().underlying, recipient, amount);\\n }\\n\\n /**\\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\\n * @param interestAmount Interest value paid into the pool from a loan.\\n */\\n function repayLoan(uint256 amount, uint256 interestAmount)\\n external\\n override\\n authorized(CONTROLLER, _msgSender())\\n {\\n s().totalRepaid += amount;\\n s().totalInterestRepaid += interestAmount;\\n }\\n\\n /**\\n * @notice Deposit underlying token amount into LP and mint tokens.\\n * @param amount The amount of underlying tokens to use to mint.\\n * @return Amount of TTokens minted.\\n */\\n function mint(uint256 amount)\\n external\\n override\\n notRestricted\\n returns (uint256)\\n {\\n require(amount > 0, \\\"Teller: cannot mint 0\\\");\\n require(\\n amount <= s().underlying.balanceOf(_msgSender()),\\n \\\"Teller: insufficient underlying\\\"\\n );\\n\\n // Calculate amount of tokens to mint\\n uint256 mintAmount = _valueOfUnderlying(amount, exchangeRate());\\n\\n // Transfer tokens from lender\\n SafeERC20.safeTransferFrom(\\n s().underlying,\\n _msgSender(),\\n address(this),\\n amount\\n );\\n\\n // Mint Teller token value of underlying\\n _mint(_msgSender(), mintAmount);\\n\\n emit Mint(_msgSender(), mintAmount, amount);\\n\\n return mintAmount;\\n }\\n\\n /**\\n * @notice Redeem supplied Teller token underlying value.\\n * @param amount The amount of Teller tokens to redeem.\\n */\\n function redeem(uint256 amount) external override {\\n require(amount > 0, \\\"Teller: cannot withdraw 0\\\");\\n require(\\n amount <= balanceOf(_msgSender()),\\n \\\"Teller: redeem amount exceeds balance\\\"\\n );\\n\\n // Accrue interest and calculate exchange rate\\n uint256 underlyingAmount = _valueInUnderlying(amount, exchangeRate());\\n require(\\n underlyingAmount <= totalUnderlyingSupply(),\\n \\\"Teller: redeem ttoken lp not enough supply\\\"\\n );\\n\\n // Burn Teller Tokens and transfer underlying\\n _redeem(amount, underlyingAmount);\\n }\\n\\n /**\\n * @notice Redeem supplied underlying value.\\n * @param amount The amount of underlying tokens to redeem.\\n */\\n function redeemUnderlying(uint256 amount) external override {\\n require(amount > 0, \\\"Teller: cannot withdraw 0\\\");\\n require(\\n amount <= totalUnderlyingSupply(),\\n \\\"Teller: redeem ttoken lp not enough supply\\\"\\n );\\n\\n // Accrue interest and calculate exchange rate\\n uint256 rate = exchangeRate();\\n uint256 tokenValue = _valueOfUnderlying(amount, rate);\\n\\n // Make sure sender has adequate balance\\n require(\\n tokenValue <= balanceOf(_msgSender()),\\n \\\"Teller: redeem amount exceeds balance\\\"\\n );\\n\\n // Burn Teller Tokens and transfer underlying\\n _redeem(tokenValue, amount);\\n }\\n\\n /**\\n * @dev Redeem an {amount} of Teller Tokens and transfers {underlyingAmount} to the caller.\\n * @param amount Total amount of Teller Tokens to burn.\\n * @param underlyingAmount Total amount of underlying asset tokens to transfer to caller.\\n *\\n * This function should only be called by {redeem} and {redeemUnderlying} after the exchange\\n * rate and both token values have been calculated to use.\\n */\\n function _redeem(uint256 amount, uint256 underlyingAmount) internal {\\n // Burn Teller tokens\\n _burn(_msgSender(), amount);\\n\\n // Make sure enough funds are available to redeem\\n _delegateStrategy(\\n abi.encodeWithSelector(\\n ITTokenStrategy.withdraw.selector,\\n underlyingAmount\\n )\\n );\\n\\n // Transfer funds back to lender\\n SafeERC20.safeTransfer(s().underlying, _msgSender(), underlyingAmount);\\n\\n emit Redeem(_msgSender(), amount, underlyingAmount);\\n }\\n\\n /**\\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\\n *\\n * See {TTokenStrategy}.\\n */\\n function rebalance() public override {\\n _delegateStrategy(\\n abi.encodeWithSelector(ITTokenStrategy.rebalance.selector)\\n );\\n }\\n\\n /**\\n * @notice Sets a new strategy to use for balancing funds.\\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\\n * @param initData Optional data to initialize the strategy.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function setStrategy(address strategy, bytes calldata initData)\\n external\\n override\\n authorized(ADMIN, _msgSender())\\n {\\n require(\\n ERC165Checker.supportsInterface(\\n strategy,\\n type(ITTokenStrategy).interfaceId\\n ),\\n \\\"Teller: strategy does not support ITTokenStrategy\\\"\\n );\\n s().strategy = strategy;\\n if (initData.length > 0) {\\n _delegateStrategy(initData);\\n }\\n }\\n\\n /**\\n * @notice Gets the strategy used for balancing funds.\\n * @return address of the strategy contract\\n */\\n function getStrategy() external view override returns (address) {\\n return s().strategy;\\n }\\n\\n /**\\n * @notice Sets the restricted state of the platform.\\n * @param state boolean value that resembles the platform's state\\n */\\n function restrict(bool state)\\n public\\n override\\n authorized(ADMIN, _msgSender())\\n {\\n s().restricted = state;\\n }\\n\\n /**\\n * @notice it initializes the Teller Token\\n * @param admin address of the admin to the respective Teller Token\\n * @param underlying address of the ERC20 token\\n */\\n function initialize(address admin, address underlying)\\n external\\n override\\n initializer\\n {\\n require(\\n Address.isContract(msg.sender),\\n \\\"Teller: controller not contract\\\"\\n );\\n require(\\n Address.isContract(underlying),\\n \\\"Teller: underlying token not contract\\\"\\n );\\n\\n RolesLib.grantRole(CONTROLLER, msg.sender);\\n RolesLib.grantRole(ADMIN, admin);\\n\\n s().underlying = ERC20(underlying);\\n __ERC20_init(\\n string(abi.encodePacked(\\\"Teller \\\", s().underlying.name())),\\n string(abi.encodePacked(\\\"t\\\", s().underlying.symbol()))\\n );\\n s().decimals = s().underlying.decimals();\\n // Platform restricted by default\\n s().restricted = true;\\n }\\n\\n /**\\n * @notice it retrieves the value of the underlying token\\n * @param amount the amount of tokens to calculate the value of\\n * @param rate the exchangeRate() to divide with the amount * exchange_rate_factor\\n * @return value_ the underlying value of the token amount\\n */\\n function _valueOfUnderlying(uint256 amount, uint256 rate)\\n internal\\n pure\\n returns (uint256 value_)\\n {\\n value_ = (amount * EXCHANGE_RATE_FACTOR) / rate;\\n }\\n\\n /**\\n * @notice it retrives the value in the underlying tokens\\n *\\n */\\n function _valueInUnderlying(uint256 amount, uint256 rate)\\n internal\\n pure\\n returns (uint256 value_)\\n {\\n value_ = (amount * (rate)) / EXCHANGE_RATE_FACTOR;\\n }\\n\\n /**\\n * @notice Delegates data to call on the strategy contract.\\n * @param callData Data to call the strategy contract with.\\n *\\n * Requirements:\\n * - Sender must have ADMIN role\\n */\\n function _delegateStrategy(bytes memory callData)\\n internal\\n returns (bytes memory)\\n {\\n return Address.functionDelegateCall(s().strategy, callData);\\n }\\n}\\n\",\"keccak256\":\"0x8248ba2a8326e823dab1a7448a676be50089760f24cb82acc9e4ee12068c3912\",\"license\":\"MIT\"},\"contracts/lending/ttoken/data.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Role ID used to pull funds for the asset it manages (i.e. TellerDiamond)\\nbytes32 constant CONTROLLER = keccak256(\\\"CONTROLLER\\\");\\n// Role ID used to for accounts to call special methods that modify its state\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\n\\nuint256 constant EXCHANGE_RATE_FACTOR = 1e18;\\nuint256 constant ONE_HUNDRED_PERCENT = 10000;\\n\",\"keccak256\":\"0x0c5f8ce14f4efd59a314373363524e0428b5b7e8a6ee907b35ee1d7ffe886fdf\",\"license\":\"MIT\"},\"contracts/lending/ttoken/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { ERC20, IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/ERC20.sol\\\";\\n\\nstruct Store {\\n ERC20 underlying;\\n address strategy;\\n uint256 totalBorrowed;\\n uint256 totalRepaid;\\n uint256 totalInterestRepaid;\\n uint8 decimals;\\n bool restricted;\\n}\\n\\nbytes32 constant POSITION = keccak256(\\\"ttoken.storage.position\\\");\\n\\n/**\\n * @notice it saves the Store struct in a hashed slot\\n */\\nfunction store() pure returns (Store storage s_) {\\n bytes32 position = POSITION;\\n assembly {\\n s_.slot := position\\n }\\n}\\n\",\"keccak256\":\"0x735419ace476d14c4413fad3e9b2cd04573e45736e9ed27b4e223db8316f9905\",\"license\":\"MIT\"},\"contracts/lending/ttoken/strategies/ITTokenStrategy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface ITTokenStrategy {\\n event StrategyRebalanced(\\n string indexed strategyName,\\n address indexed sender\\n );\\n\\n /**\\n * @notice it returns the total supply of an underlying asset in a Teller token.\\n * @return uint256 the underlying supply\\n */\\n function totalUnderlyingSupply() external returns (uint256);\\n\\n /**\\n * @notice it rebalances the underlying asset held by the Teller Token.\\n *\\n */\\n function rebalance() external;\\n\\n /**\\n * @notice it withdraws amount of tokens in a pool\\n * @param amount amount to withdraw\\n */\\n\\n function withdraw(uint256 amount) external;\\n}\\n\",\"keccak256\":\"0x05a6c007e6ced27d12d365bf3715283a9310f707e6f642025e94ef596ea8527e\",\"license\":\"MIT\"},\"contracts/shared/interfaces/ICErc20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IComptroller.sol\\\";\\n\\ninterface ICErc20 {\\n /*** User Interface ***/\\n\\n /**\\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\\n */\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n /**\\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemTokens The number of cTokens to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n /**\\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param redeemAmount The amount of underlying to be redeemed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which redeemed funds shall be transferred.\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n /**\\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\\n @param borrowAmount The amount of the underlying asset to be borrowed.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account to which borrowed funds shall be transferred.\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n /**\\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\\n @param borrower The account which borrowed the asset to be repaid.\\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\\n @return 0 on success, otherwise an Error code\\n @dev msg.sender The account which shall repay the borrow.\\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\\n */\\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\\n external\\n returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n\\n /** End Admin Functions */\\n\\n function underlying() external view returns (address);\\n\\n /**\\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\\n */\\n function exchangeRateCurrent() external returns (uint256);\\n\\n function exchangeRateStored() external view returns (uint256);\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() external;\\n\\n function decimals() external view returns (uint8);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\\n @param account The account to get the underlying balance of.\\n @return The amount of underlying currently owned by the account.\\n */\\n function balanceOfUnderlying(address account) external returns (uint256);\\n\\n function comptroller() external view returns (IComptroller);\\n}\\n\",\"keccak256\":\"0xe64ba9069b31f8149d63171b24b9fdef3a587b0461c3d4c8ac5976519bcde332\",\"license\":\"MIT\"},\"contracts/shared/interfaces/IComptroller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IComptroller {\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens)\\n external\\n returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n /**\\n * @notice Checks if the account should be allowed to mint tokens in the given market\\n * @param cToken The market to verify the mint against\\n * @param minter The account which would get the minted tokens\\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates mint and reverts on rejection. May emit logs.\\n * @param cToken Asset being minted\\n * @param minter The address minting the tokens\\n * @param mintAmount The amount of the underlying asset being minted\\n * @param mintTokens The number of tokens being minted\\n */\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to redeem tokens in the given market\\n * @param cToken The market to verify the redeem against\\n * @param redeemer The account which would redeem the tokens\\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates redeem and reverts on rejection. May emit logs.\\n * @param cToken Asset being redeemed\\n * @param redeemer The address redeeming the tokens\\n * @param redeemAmount The amount of the underlying asset being redeemed\\n * @param redeemTokens The number of tokens being redeemed\\n */\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\\n * @param cToken The market to verify the borrow against\\n * @param borrower The account which would borrow the asset\\n * @param borrowAmount The amount of underlying the account would borrow\\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates borrow and reverts on rejection. May emit logs.\\n * @param cToken Asset whose underlying is being borrowed\\n * @param borrower The address borrowing the underlying\\n * @param borrowAmount The amount of the underlying asset requested to borrow\\n */\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to repay a borrow in the given market\\n * @param cToken The market to verify the repay against\\n * @param payer The account which would repay the asset\\n * @param borrower The account which would borrowed the asset\\n * @param repayAmount The amount of the underlying asset the account would repay\\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\\n * @param cToken Asset being repaid\\n * @param payer The address repaying the borrow\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param borrowerIndex the index of the borrower\\n */\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n /**\\n * @notice Checks if the liquidation should be allowed to occur\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n */\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the seizing of assets should be allowed to occur\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates seize and reverts on rejection. May emit logs.\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n /**\\n * @notice Checks if the account should be allowed to transfer tokens in the given market\\n * @param cToken The market to verify the transfer against\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n /**\\n * @notice Validates transfer and reverts on rejection. May emit logs.\\n * @param cToken Asset being transferred\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n */\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in all markets\\n * @param holder The address to claim COMP for\\n */\\n function claimComp(address holder) external;\\n\\n /**\\n * @notice Claim all the comp accrued by holder in the specified markets\\n * @param holder The address to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n */\\n function claimComp(address holder, address[] calldata cTokens) external;\\n\\n /**\\n * @notice Claim all comp accrued by the holders\\n * @param holders The addresses to claim COMP for\\n * @param cTokens The list of markets to claim COMP in\\n * @param borrowers Whether or not to claim COMP earned by borrowing\\n * @param suppliers Whether or not to claim COMP earned by supplying\\n */\\n function claimComp(\\n address[] calldata holders,\\n address[] calldata cTokens,\\n bool borrowers,\\n bool suppliers\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n /**\\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\\n * @param cTokenBorrowed The address of the borrowed cToken\\n * @param cTokenCollateral The address of the collateral cToken\\n * @param repayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\\n */\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n\\n /**\\n * @notice Return the address of the COMP token\\n * @return The address of COMP\\n */\\n function getCompAddress() external view returns (address);\\n}\\n\",\"keccak256\":\"0x38a824a4a21ce9370fa581a616d1bb9d311f27d8982a6b96ebeba90bd5fd0adb\",\"license\":\"MIT\"},\"contracts/shared/libraries/NumbersLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Utility library for uint256 numbers\\n *\\n * @author develop@teller.finance\\n */\\nlibrary NumbersLib {\\n /**\\n * @dev It represents 100% with 2 decimal places.\\n */\\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\\n\\n /**\\n * @notice Returns a percentage value of a number.\\n * @param self The number to get a percentage of.\\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\\n */\\n function percent(uint256 self, uint16 percentage)\\n internal\\n pure\\n returns (uint256)\\n {\\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\\n }\\n\\n function percent(int256 self, uint256 percentage)\\n internal\\n pure\\n returns (int256)\\n {\\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\\n }\\n\\n /**\\n * @notice it returns the absolute number of a specified parameter\\n * @param self the number to be returned in it's absolute\\n * @return the absolute number\\n */\\n function abs(int256 self) internal pure returns (uint256) {\\n return self >= 0 ? uint256(self) : uint256(-1 * self);\\n }\\n\\n /**\\n * @notice Returns a ratio percentage of {num1} to {num2}.\\n * @param num1 The number used to get the ratio for.\\n * @param num2 The number used to get the ratio from.\\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\\n */\\n function ratioOf(uint256 num1, uint256 num2)\\n internal\\n pure\\n returns (uint16)\\n {\\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\\n }\\n}\\n\",\"keccak256\":\"0x4f750cde25d4b1db919abf3192d58ed6aef617d03637e1e9e2dc31b70dcc32a3\",\"license\":\"MIT\"},\"contracts/shared/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev the roles for the user to assign, revoke and check in functions\\n */\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant PAUSER = keccak256(\\\"PAUSER\\\");\\nbytes32 constant AUTHORIZED = keccak256(\\\"AUTHORIZED\\\");\\n\",\"keccak256\":\"0x711c08f4fb19dd5c1c76acf9bd08ac1dcd9df9ce143f5195c043d56d4650c8da\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "author": "develop@teller.finance", + "kind": "dev", + "methods": { + "allowance(address,address)": { + "details": "See {IERC20-allowance}." + }, + "approve(address,uint256)": { + "details": "See {IERC20-approve}. Requirements: - `spender` cannot be the zero address." + }, + "balanceOf(address)": { + "details": "See {IERC20-balanceOf}." + }, + "balanceOfUnderlying(address)": { + "params": { + "account": "Address to calculate the underlying balance." + }, + "returns": { + "_0": "balance_ the balance of the account" + } + }, + "currentTVL()": { + "returns": { + "tvl_": "The value locked in the pool. Note: This value includes the amount that is on loan (including ones that were sent to EOAs)." + } + }, + "debtRatioFor(uint256)": { + "params": { + "newLoanAmount": "the new loan amount to consider the StD ratio." + }, + "returns": { + "ratio_": "Whether debt ratio for lending pool is valid." + } + }, + "decimals()": { + "returns": { + "_0": "decimals of the token" + } + }, + "decreaseAllowance(address,uint256)": { + "details": "Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`." + }, + "exchangeRate()": { + "returns": { + "rate_": "The current exchange rate." + } + }, + "fundLoan(address,uint256)": { + "params": { + "amount": "Funds requested to fulfil the loan.", + "recipient": "The account to send the funds to." + } + }, + "getMarketState()": { + "returns": { + "totalBorrowed": "Total amount borrowed through loans.", + "totalInterestRepaid": "The total amount interest repaid till the current timestamp.", + "totalOnLoan": "Total amount currently deployed in loans.", + "totalRepaid": "The total amount repaid till the current timestamp.", + "totalSupplied": "Total amount of the underlying asset supplied." + } + }, + "getStrategy()": { + "returns": { + "_0": "address of the strategy contract" + } + }, + "grantRole(bytes32,address)": { + "params": { + "account": "Address to give the {role} to. Requirements: - Sender must be role admin.", + "role": "Encoding of the role to give." + } + }, + "hasRole(bytes32,address)": { + "params": { + "account": "Address to check the {role} for.", + "role": "Encoding of the role to check." + } + }, + "increaseAllowance(address,uint256)": { + "details": "Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address." + }, + "initialize(address,address)": { + "params": { + "admin": "address of the admin to the respective Teller Token", + "underlying": "address of the ERC20 token" + } + }, + "mint(uint256)": { + "params": { + "amount": "The amount of underlying tokens to use to mint." + }, + "returns": { + "_0": "Amount of TTokens minted." + } + }, + "name()": { + "details": "Returns the name of the token." + }, + "redeem(uint256)": { + "params": { + "amount": "The amount of Teller tokens to redeem." + } + }, + "redeemUnderlying(uint256)": { + "params": { + "amount": "The amount of underlying tokens to redeem." + } + }, + "renounceRole(bytes32)": { + "params": { + "role": "Encoding of the role to remove." + } + }, + "repayLoan(uint256,uint256)": { + "params": { + "amount": "Funds deposited back into the pool to repay the principal amount of a loan.", + "interestAmount": "Interest value paid into the pool from a loan." + } + }, + "restrict(bool)": { + "params": { + "state": "boolean value that resembles the platform's state" + } + }, + "revokeRole(bytes32,address)": { + "params": { + "account": "Address to remove the {role} from. Requirements: - Sender must be role admin.", + "role": "Encoding of the role to remove." + } + }, + "setStrategy(address,bytes)": { + "params": { + "initData": "Optional data to initialize the strategy. Requirements: - Sender must have ADMIN role", + "strategy": "Address to the new strategy contract. Must implement the {ITTokenStrategy} interface." + } + }, + "symbol()": { + "details": "Returns the symbol of the token, usually a shorter version of the name." + }, + "totalSupply()": { + "details": "See {IERC20-totalSupply}." + }, + "totalUnderlyingSupply()": { + "returns": { + "_0": "totalSupply_ the total supply denoted in the underlying asset." + } + }, + "transfer(address,uint256)": { + "details": "See {IERC20-transfer}. Requirements: - `recipient` cannot be the zero address. - the caller must have a balance of at least `amount`." + }, + "transferFrom(address,address,uint256)": { + "details": "See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. Requirements: - `sender` and `recipient` cannot be the zero address. - `sender` must have a balance of at least `amount`. - the caller must have allowance for ``sender``'s tokens of at least `amount`." + }, + "underlying()": { + "returns": { + "_0": "ERC20 token that is the underlying asset" + } + } + }, + "version": 1 + }, + "userdoc": { + "events": { + "Mint(address,uint256,uint256)": { + "notice": "This event is emitted when a user deposits tokens into the pool." + }, + "Redeem(address,uint256,uint256)": { + "notice": "This event is emitted when a user withdraws tokens from the pool." + } + }, + "kind": "user", + "methods": { + "balanceOfUnderlying(address)": { + "notice": "The balance of an {account} denoted in underlying value." + }, + "currentTVL()": { + "notice": "Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool." + }, + "debtRatioFor(uint256)": { + "notice": "It validates whether supply to debt (StD) ratio is valid including the loan amount." + }, + "decimals()": { + "notice": "it returns the decimal places of the respective TToken" + }, + "exchangeRate()": { + "notice": "It calculates the current exchange rate for a whole Teller Token based of the underlying token balance." + }, + "fundLoan(address,uint256)": { + "notice": "Called by the Teller Diamond contract when a loan has been taken out and requires funds." + }, + "getMarketState()": { + "notice": "It calculates the market state values across a given markets.Returns values that represent the global state across the market." + }, + "getStrategy()": { + "notice": "Gets the strategy used for balancing funds." + }, + "grantRole(bytes32,address)": { + "notice": "Grants an account a new role." + }, + "hasRole(bytes32,address)": { + "notice": "Checks if an account has a specific role." + }, + "initialize(address,address)": { + "notice": "it initializes the Teller Token" + }, + "mint(uint256)": { + "notice": "Deposit underlying token amount into LP and mint tokens." + }, + "rebalance()": { + "notice": "Rebalances the funds controlled by Teller Token according to the current strategy. See {TTokenStrategy}." + }, + "redeem(uint256)": { + "notice": "Redeem supplied Teller token underlying value." + }, + "redeemUnderlying(uint256)": { + "notice": "Redeem supplied underlying value." + }, + "renounceRole(bytes32)": { + "notice": "Removes a role from the sender." + }, + "repayLoan(uint256,uint256)": { + "notice": "Called by the Teller Diamond contract when a loan has been repaid." + }, + "restrict(bool)": { + "notice": "Sets the restricted state of the platform." + }, + "revokeRole(bytes32,address)": { + "notice": "Removes a role from an account." + }, + "setStrategy(address,bytes)": { + "notice": "Sets a new strategy to use for balancing funds." + }, + "totalUnderlyingSupply()": { + "notice": "It calculates the total supply of the underlying asset." + }, + "underlying()": { + "notice": "The token that is the underlying assets for this Teller token." + } + }, + "notice": "This contract represents a lending pool for an asset within Teller protocol.", + "version": 1 + }, + "storageLayout": { + "storage": [ + { + "astId": 635, + "contract": "contracts/lending/ttoken/TToken_V1.sol:TToken_V1", + "label": "_initialized", + "offset": 0, + "slot": "0", + "type": "t_bool" + }, + { + "astId": 638, + "contract": "contracts/lending/ttoken/TToken_V1.sol:TToken_V1", + "label": "_initializing", + "offset": 1, + "slot": "0", + "type": "t_bool" + }, + { + "astId": 2833, + "contract": "contracts/lending/ttoken/TToken_V1.sol:TToken_V1", + "label": "__gap", + "offset": 0, + "slot": "1", + "type": "t_array(t_uint256)50_storage" + }, + { + "astId": 694, + "contract": "contracts/lending/ttoken/TToken_V1.sol:TToken_V1", + "label": "_balances", + "offset": 0, + "slot": "51", + "type": "t_mapping(t_address,t_uint256)" + }, + { + "astId": 700, + "contract": "contracts/lending/ttoken/TToken_V1.sol:TToken_V1", + "label": "_allowances", + "offset": 0, + "slot": "52", + "type": "t_mapping(t_address,t_mapping(t_address,t_uint256))" + }, + { + "astId": 702, + "contract": "contracts/lending/ttoken/TToken_V1.sol:TToken_V1", + "label": "_totalSupply", + "offset": 0, + "slot": "53", + "type": "t_uint256" + }, + { + "astId": 704, + "contract": "contracts/lending/ttoken/TToken_V1.sol:TToken_V1", + "label": "_name", + "offset": 0, + "slot": "54", + "type": "t_string_storage" + }, + { + "astId": 706, + "contract": "contracts/lending/ttoken/TToken_V1.sol:TToken_V1", + "label": "_symbol", + "offset": 0, + "slot": "55", + "type": "t_string_storage" + }, + { + "astId": 1208, + "contract": "contracts/lending/ttoken/TToken_V1.sol:TToken_V1", + "label": "__gap", + "offset": 0, + "slot": "56", + "type": "t_array(t_uint256)45_storage" + } + ], + "types": { + "t_address": { + "encoding": "inplace", + "label": "address", + "numberOfBytes": "20" + }, + "t_array(t_uint256)45_storage": { + "base": "t_uint256", + "encoding": "inplace", + "label": "uint256[45]", + "numberOfBytes": "1440" + }, + "t_array(t_uint256)50_storage": { + "base": "t_uint256", + "encoding": "inplace", + "label": "uint256[50]", + "numberOfBytes": "1600" + }, + "t_bool": { + "encoding": "inplace", + "label": "bool", + "numberOfBytes": "1" + }, + "t_mapping(t_address,t_mapping(t_address,t_uint256))": { + "encoding": "mapping", + "key": "t_address", + "label": "mapping(address => mapping(address => uint256))", + "numberOfBytes": "32", + "value": "t_mapping(t_address,t_uint256)" + }, + "t_mapping(t_address,t_uint256)": { + "encoding": "mapping", + "key": "t_address", + "label": "mapping(address => uint256)", + "numberOfBytes": "32", + "value": "t_uint256" + }, + "t_string_storage": { + "encoding": "bytes", + "label": "string", + "numberOfBytes": "32" + }, + "t_uint256": { + "encoding": "inplace", + "label": "uint256", + "numberOfBytes": "32" + } + } + } +} diff --git a/deployments/polygon_mumbai/TellerDiamond.json b/deployments/polygon_mumbai/TellerDiamond.json new file mode 100644 index 000000000..0aabbe2c1 --- /dev/null +++ b/deployments/polygon_mumbai/TellerDiamond.json @@ -0,0 +1,3173 @@ +{ + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bool", + "name": "restriction", + "type": "bool" + }, + { + "indexed": true, + "internalType": "address", + "name": "pauser", + "type": "address" + } + ], + "name": "PlatformRestricted", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "addressesToAdd", + "type": "address[]" + } + ], + "name": "addAuthorizedAddressList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getNFTLiquidationController", + "outputs": [ + { + "internalType": "address", + "name": "controller_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasAuthorization", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "components": [ + { + "internalType": "string", + "name": "sym", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "internalType": "struct InitAssets[]", + "name": "assets", + "type": "tuple[]" + }, + { + "internalType": "address[]", + "name": "cTokens", + "type": "address[]" + }, + { + "internalType": "address", + "name": "tellerNFT", + "type": "address" + }, + { + "internalType": "address", + "name": "loansEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralEscrowBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "tTokenBeacon", + "type": "address" + }, + { + "internalType": "address", + "name": "nftLiquidationController", + "type": "address" + }, + { + "internalType": "address", + "name": "wrappedNativeToken", + "type": "address" + }, + { + "internalType": "address", + "name": "nftDictionary", + "type": "address" + } + ], + "internalType": "struct InitArgs", + "name": "_args", + "type": "tuple" + } + ], + "name": "init", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "removeAuthorizedAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "setNFTLiquidationController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldMax", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newMax", + "type": "uint256" + } + ], + "name": "PlatformSettingBoundariesUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "minValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "maxValue", + "type": "uint256" + } + ], + "name": "PlatformSettingCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "settingName", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "PlatformSettingUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "createPlatformSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + } + ], + "name": "getPlatformSetting", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "exists", + "type": "bool" + } + ], + "internalType": "struct PlatformSetting", + "name": "setting_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "newValue", + "type": "uint256" + } + ], + "name": "updatePlatformSetting", + "outputs": [ + { + "internalType": "uint256", + "name": "oldValue", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "name", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "min", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "max", + "type": "uint256" + } + ], + "name": "updatePlatformSettingBoundaries", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetAToken", + "outputs": [ + { + "internalType": "contract IAToken", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetCToken", + "outputs": [ + { + "internalType": "contract ICErc20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxLoanAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetMaxTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetPPool", + "outputs": [ + { + "internalType": "contract PrizePoolInterface", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getAssetPPoolTicket", + "outputs": [ + { + "internalType": "contract IERC20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "name": "AssetSettingsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "createAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getMaxTVLAmount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "isAssetSettingInitialized", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "components": [ + { + "internalType": "bytes32", + "name": "key", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "value", + "type": "bytes32" + }, + { + "internalType": "enum CacheType", + "name": "cacheType", + "type": "uint8" + } + ], + "internalType": "struct AssetSettingRequest", + "name": "request", + "type": "tuple" + } + ], + "name": "updateAssetSetting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "UnPaused", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + } + ], + "name": "isPaused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "id", + "type": "bytes32" + }, + { + "internalType": "bool", + "name": "state", + "type": "bool" + } + ], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getPriceFor", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "uint256", + "name": "srcAmount", + "type": "uint256" + } + ], + "name": "getValueFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "addChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "getChainlinkAggregatorFor", + "outputs": [ + { + "internalType": "address", + "name": "agg", + "type": "address" + }, + { + "internalType": "bool", + "name": "found", + "type": "bool" + }, + { + "internalType": "bool", + "name": "inverse", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "isChainlinkTokenSupported", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "src", + "type": "address" + }, + { + "internalType": "address", + "name": "dst", + "type": "address" + } + ], + "name": "removeChainlinkAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "LendingPoolInitialized", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getTTokenFor", + "outputs": [ + { + "internalType": "address", + "name": "tToken_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "initLendingPool", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "lendingPoolDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "collateralTokens", + "type": "address[]" + } + ], + "name": "addCollateralTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "depositCollateral", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getCollateralTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanCollateral", + "outputs": [ + { + "internalType": "uint256", + "name": "supply_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "withdrawCollateral", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountBorrowed", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "withNFT", + "type": "bool" + } + ], + "name": "LoanTakenOut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanUserRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanConsensusResponse[]", + "name": "responses", + "type": "tuple[]" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "collateralAmount", + "type": "uint256" + } + ], + "name": "takeOutLoan", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "requestNonce", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "requestTime", + "type": "uint32" + } + ], + "internalType": "struct LoanUserRequest", + "name": "request", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "responseTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "components": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "internalType": "struct Signature", + "name": "signature", + "type": "tuple" + } + ], + "internalType": "struct LoanConsensusResponse[]", + "name": "responses", + "type": "tuple[]" + } + ], + "internalType": "struct LoanRequest", + "name": "request", + "type": "tuple" + }, + { + "internalType": "uint16[]", + "name": "nftIDs", + "type": "uint16[]" + } + ], + "name": "takeOutLoanWithNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "borrower", + "type": "address" + } + ], + "name": "getBorrowerLoans", + "outputs": [ + { + "internalType": "uint128[]", + "name": "loanIDs", + "type": "uint128[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getCollateralNeededInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "neededInLendingTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "neededInCollateralTokens", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "escrowLoanValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getDebtOwed", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "principalOwed", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "interestOwed", + "type": "uint256" + } + ], + "internalType": "struct LoanDebt", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getEscrowTokens", + "outputs": [ + { + "internalType": "address[]", + "name": "tokens_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amountBorrow", + "type": "uint256" + } + ], + "name": "getInterestOwedFor", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoan", + "outputs": [ + { + "components": [ + { + "internalType": "address payable", + "name": "borrower", + "type": "address" + }, + { + "internalType": "address", + "name": "lendingToken", + "type": "address" + }, + { + "internalType": "address", + "name": "collateralToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "borrowedAmount", + "type": "uint256" + }, + { + "internalType": "uint128", + "name": "id", + "type": "uint128" + }, + { + "internalType": "uint32", + "name": "duration", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "loanStartTime", + "type": "uint32" + }, + { + "internalType": "uint16", + "name": "interestRate", + "type": "uint16" + }, + { + "internalType": "uint16", + "name": "collateralRatio", + "type": "uint16" + }, + { + "internalType": "enum LoanStatus", + "name": "status", + "type": "uint8" + } + ], + "internalType": "struct Loan", + "name": "loan_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrow", + "outputs": [ + { + "internalType": "address", + "name": "escrow_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanEscrowValue", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanTerms", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "maxLoanAmount", + "type": "uint256" + }, + { + "internalType": "uint32", + "name": "termsExpiry", + "type": "uint32" + } + ], + "internalType": "struct LoanTerms", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getTotalOwed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "liquidator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokensIn", + "type": "uint256" + } + ], + "name": "LoanLiquidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "borrower", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amountPaid", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "payer", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalOwed", + "type": "uint256" + } + ], + "name": "LoanRepaid", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "TokensClaimed", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "claimTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "escrowRepay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLiquidationReward", + "outputs": [ + { + "internalType": "uint256", + "name": "inLending_", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "inCollateral_", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "liquidateLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "repayLoan", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "addSigner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + } + ], + "name": "addSigners", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "isSigner", + "outputs": [ + { + "internalType": "bool", + "name": "isSigner_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + } + ], + "name": "getLoanNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "loanNFTs", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "nftOwner", + "type": "address" + } + ], + "name": "getStakedNFTs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "staked_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "nftIDs", + "type": "uint256[]" + } + ], + "name": "stakeNFTs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterDeposit", + "type": "uint256" + } + ], + "name": "AaveDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "aTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceBeforeDeposit", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "aTokenBalanceAfterWithdrawal", + "type": "uint256" + } + ], + "name": "AaveWithdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveDeposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "aaveWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "aaveWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "ticketAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokenBalance", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "creditBalanceAfter", + "type": "uint256" + } + ], + "name": "PoolTogetherDeposited", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "ticketAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokenBalance", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "creditBalanceAfter", + "type": "uint256" + } + ], + "name": "PoolTogetherWithdrawal", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "poolTogetherDepositTicket", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "poolTogetherWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "loanID", + "type": "uint256" + }, + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + } + ], + "name": "poolTogetherWithdrawAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "5667000", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000800000000000000000008000002000000000000000000000000000000000000000000000000000800101000001000000040900000000000000000000020000020000008000000800000000000000000080000000100000400020000000000000000000004000001000000000000000000000000000000000200000000000000000000000100000000000008000000000001040000000005000000000000100000001000000000000000000000020000100100000000020000000000000000000000000000000000000000000020000000000000000108000", + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694", + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000ab3ea92a73b116eb4fd092106de715b2aca65a54", + "logIndex": 2, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000c275dc8be39f50d12f66b6a63629c39da5bae5bd" + ], + "data": "0x000000000000000000000000000000000000000000000000025bff31ba43a00000000000000000000000000000000000000000000000000039eb94ebc31428000000000000000000000000000000000000000000000000b41811ed8f531c41d5000000000000000000000000000000000000000000000000378f95ba08d088000000000000000000000000000000000000000000000000b41a6decc10d5fe1d5", + "logIndex": 7, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000ab3ea92a73b116eb4fd092106de715b2aca65a54", + "logIndex": 2, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694", + "args": ["0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54"], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000c275dc8be39f50d12f66b6a63629c39da5bae5bd" + ], + "data": "0x000000000000000000000000000000000000000000000000025bff31ba43a00000000000000000000000000000000000000000000000000039eb94ebc31428000000000000000000000000000000000000000000000000b41811ed8f531c41d5000000000000000000000000000000000000000000000000378f95ba08d088000000000000000000000000000000000000000000000000b41a6decc10d5fe1d5", + "logIndex": 7, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + } + ], + "blockNumber": 15692496, + "cumulativeGasUsed": "5667000", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0x00C864C47Ed6B60f8C0588Da0d1065fB87d69B80", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0xd8a2d36d", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0x23Ba2174906E6668FF841829F923cFAEf2Ee228e", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x092B2Ee3864fd374EE1786Ed31d7824Af63e3BED", + "functionSelectors": [ + "0x82f205cc", + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3", + "0x46e482fd", + "0xc676d298" + ], + "action": 0 + }, + { + "facetAddress": "0xF8441De2A5Ec87402989bB3691aa0d9926607302", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0xAb5ABA751Fb9ff85b66B107BDC745882aA49B930", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0x7339d372116d8A56A9984814Ce1175377C58Fd7E", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0xB8030DBf749Ab84a59FE06D2346Ad2Cb856a9C49", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x50a0DE2C69Ca270F8FBB4732EEA85552B89D7A5b", + "functionSelectors": ["0x9912dde8", "0x5a601668", "0x8a4f4f92"], + "action": 0 + }, + { + "facetAddress": "0xe42b077B892a0B282F2B636C017199d5a55B192b", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0xB53dD2fE8B837E7877dfb43c046D75D5648A9005", + "functionSelectors": ["0xea40e51a", "0xfe5d095b"], + "action": 0 + }, + { + "facetAddress": "0x802ff89ABeEe5F98eDDF38E20eF17F246F2c5d36", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0x4d046a028556D0404dE776B78EAC6e9E89ac3395", + "functionSelectors": [ + "0x46e04a2f", + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0xF1743209a10923d484b5e9B65e1Caf4eF7f6C372", + "functionSelectors": ["0x2239f556", "0x46efd16c", "0x78b248e4"], + "action": 0 + }, + { + "facetAddress": "0xf98880D3d29c0337fb457d2adc1443849e4C0d59", + "functionSelectors": ["0xa7baf6fc", "0x6f70d212", "0x0f48a482"], + "action": 0 + }, + { + "facetAddress": "0x61504A238e2DD5f6a6D027384816d8C944fe78b0", + "functionSelectors": ["0x71d78fbc", "0xf6376124", "0x33c72dfe"], + "action": 0 + }, + { + "facetAddress": "0x76F35684665469FB1Bce0F2Abe0F34e3791ee3c9", + "functionSelectors": ["0x8d3900ba", "0xc9fe48fc", "0x1bb0a63e"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "0x608060405260405162002d4538038062002d45833981016040819052620000269162000db2565b604080516000808252602082019092526200004e918491620000f560201b620000db1760201c565b620000688160000151620002b560201b6200027d1760201c565b60006200007f6200031760201b620003021760201c565b6301ffc9a760e01b600090815260039091016020526040808220805460ff1990811660019081179092556307e4c70760e21b845282842080548216831790556348e2b09360e01b845282842080548216831790556307f5828d60e41b845291909220805490911690911790555062001442915050565b60005b8351811015620002665760008482815181106200011157fe5b6020026020010151602001519050600060028111156200012d57fe5b8160028111156200013a57fe5b14156200018957620001838583815181106200015257fe5b6020026020010151600001518684815181106200016b57fe5b6020026020010151604001516200033b60201b60201c565b6200025c565b60018160028111156200019857fe5b1415620001e15762000183858381518110620001b057fe5b602002602001015160000151868481518110620001c957fe5b6020026020010151604001516200054e60201b60201c565b6002816002811115620001f057fe5b14156200023957620001838583815181106200020857fe5b6020026020010151600001518684815181106200022157fe5b6020026020010151604001516200077860201b60201c565b60405162461bcd60e51b815260040162000253906200117c565b60405180910390fd5b50600101620000f8565b507f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb6738383836040516200029c9392919062000f25565b60405180910390a1620002b082826200083f565b505050565b6000620002c162000317565b6004810180546001600160a01b038581166001600160a01b031983168117909355604051939450169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c90565b60008151116200035f5760405162461bcd60e51b81526004016200025390620010d4565b60006200036b62000317565b90506001600160a01b038316620003965760405162461bcd60e51b81526004016200025390620011c3565b6001600160a01b038316600090815260018201602052604090205461ffff81166200043c57620003e08460405180606001604052806024815260200162002d21602491396200097c565b6002820180546001600160a01b038616600081815260018087016020908152604083208201805461ffff191661ffff90961695909517909455845490810185559381529190912090910180546001600160a01b03191690911790555b60005b8351811015620005475760008482815181106200045857fe5b6020908102919091018101516001600160e01b031981166000908152918690526040909120549091506001600160a01b03168015620004ab5760405162461bcd60e51b81526004016200025390620012ba565b506001600160a01b0386166000818152600186810160209081526040808420805480850182559085528285206008820401805463ffffffff60079093166004026101000a928302191660e089901c929092029190911790556001600160e01b0319909516835287905292902080546001600160a01b03191690911761ffff60a01b1916600160a01b61ffff86160217905591820191016200043f565b5050505050565b6000815111620005725760405162461bcd60e51b81526004016200025390620010d4565b60006200057e62000317565b90506001600160a01b038316620005a95760405162461bcd60e51b81526004016200025390620011c3565b6001600160a01b038316600090815260018201602052604090205461ffff81166200064f57620005f38460405180606001604052806024815260200162002d21602491396200097c565b6002820180546001600160a01b038616600081815260018087016020908152604083208201805461ffff191661ffff90961695909517909455845490810185559381529190912090910180546001600160a01b03191690911790555b60005b8351811015620005475760008482815181106200066b57fe5b6020908102919091018101516001600160e01b031981166000908152918690526040909120549091506001600160a01b03908116908716811415620006c45760405162461bcd60e51b8152600401620002539062001317565b620006d08183620009a0565b506001600160e01b03198116600081815260208681526040808320805461ffff60a01b1916600160a01b61ffff8a16021781556001600160a01b038b168085526001808b018552928520805480850182559086528486206008820401805463ffffffff60079093166004026101000a928302191660e09990991c91909102979097179096559390925286905281546001600160a01b0319169092179055918201910162000652565b60008151116200079c5760405162461bcd60e51b81526004016200025390620010d4565b6000620007a862000317565b90506001600160a01b03831615620007d45760405162461bcd60e51b8152600401620002539062001374565b60005b825181101562000839576000838281518110620007f057fe5b6020908102919091018101516001600160e01b031981166000908152918590526040909120549091506001600160a01b03166200082e8183620009a0565b5050600101620007d7565b50505050565b6001600160a01b0382166200087657805115620008705760405162461bcd60e51b8152600401620002539062001031565b62000978565b60008151116200089a5760405162461bcd60e51b815260040162000253906200120f565b6001600160a01b0382163014620008d057620008d08260405180606001604052806028815260200162002cf9602891396200097c565b600080836001600160a01b031683604051620008ed919062000f07565b600060405180830381855af49150503d80600081146200092a576040519150601f19603f3d011682016040523d82523d6000602084013e6200092f565b606091505b50915091508162000839578051156200095e578060405162461bcd60e51b815260040162000253919062001015565b60405162461bcd60e51b815260040162000253906200108e565b5050565b813b8181620008395760405162461bcd60e51b815260040162000253919062001015565b6000620009ac62000317565b90506001600160a01b038316620009d75760405162461bcd60e51b815260040162000253906200111f565b6001600160a01b03831630141562000a035760405162461bcd60e51b815260040162000253906200126c565b6001600160e01b03198216600090815260208281526040808320546001600160a01b03871684526001850190925290912054600160a01b90910461ffff16906000190180821462000b27576001600160a01b0385166000908152600184016020526040812080548390811062000a7557fe5b600091825260208083206008830401546001600160a01b038a168452600188019091526040909220805460079092166004026101000a90920460e01b92508291908590811062000ac157fe5b600091825260208083206008830401805463ffffffff60079094166004026101000a938402191660e09590951c929092029390931790556001600160e01b031992909216825284905260409020805461ffff60a01b1916600160a01b61ffff8516021790555b6001600160a01b0385166000908152600184016020526040902080548062000b4b57fe5b60008281526020808220600860001990940193840401805463ffffffff600460078716026101000a0219169055919092556001600160e01b0319861682528490526040902080546001600160b01b031916905580620005475760028301546001600160a01b03861660009081526001858101602052604090912001546000199091019061ffff1680821462000c6357600085600201838154811062000bec57fe5b6000918252602090912001546002870180546001600160a01b03909216925082918490811062000c1857fe5b600091825260208083209190910180546001600160a01b0319166001600160a01b0394851617905592909116815260018781019092526040902001805461ffff191661ffff83161790555b8460020180548062000c7157fe5b60008281526020808220830160001990810180546001600160a01b03191690559092019092556001600160a01b03891682526001878101909152604090912001805461ffff1916905550505050505050565b80516001600160a01b038116811462000cdb57600080fd5b919050565b600082601f83011262000cf1578081fd5b8151602062000d0a62000d0483620013f5565b620013d1565b828152818101908583018385028701840188101562000d27578586fd5b855b8581101562000d5d5781516001600160e01b03198116811462000d4a578788fd5b8452928401929084019060010162000d29565b5090979650505050505050565b60006020828403121562000d7c578081fd5b604051602081016001600160401b038111828210171562000d9957fe5b60405290508062000daa8362000cc3565b905292915050565b6000806040838503121562000dc5578182fd5b82516001600160401b038082111562000ddc578384fd5b818501915085601f83011262000df0578384fd5b8151602062000e0362000d0483620013f5565b82815281810190858301885b8581101562000eaa57815188016060818e03601f1901121562000e30578a8bfd5b604051606081018181108a8211171562000e4657fe5b60405262000e5682880162000cc3565b815260408201516003811062000e6a578c8dfd5b8188015260608201518981111562000e80578c8dfd5b62000e908f898386010162000ce0565b604083015250855250928401929084019060010162000e0f565b5050809750505062000ebf8882890162000d6a565b9450505050509250929050565b6001600160a01b03169052565b6000815180845262000ef381602086016020860162001413565b601f01601f19169290920160200192915050565b6000825162000f1b81846020870162001413565b9190910192915050565b606080825284518282018190526000919060809081850190602080820287018401818b01875b8481101562000fe257898303607f19018652815180516001600160a01b0316845284810151898501906003811062000f7f57fe5b858701526040918201519185018a9052815190819052908501908a90898601905b8083101562000fcc5783516001600160e01b031916825292870192600192909201919087019062000fa0565b5097860197945050509083019060010162000f4b565b505062000ff28289018b62000ecc565b878103604089015262001006818a62000ed9565b9b9a5050505050505050505050565b6000602082526200102a602083018462000ed9565b9392505050565b6020808252603c908201527f4c69624469616d6f6e644375743a205f696e697420697320616464726573732860408201527f3029206275745f63616c6c64617461206973206e6f7420656d70747900000000606082015260800190565b60208082526026908201527f4c69624469616d6f6e644375743a205f696e69742066756e6374696f6e2072656040820152651d995c9d195960d21b606082015260800190565b6020808252602b908201527f4c69624469616d6f6e644375743a204e6f2073656c6563746f727320696e206660408201526a1858d95d081d1bc818dd5d60aa1b606082015260800190565b60208082526037908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f76652066756e6360408201527f74696f6e207468617420646f65736e2774206578697374000000000000000000606082015260800190565b60208082526027908201527f4c69624469616d6f6e644375743a20496e636f727265637420466163657443756040820152663a20b1ba34b7b760c91b606082015260800190565b6020808252602c908201527f4c69624469616d6f6e644375743a204164642066616365742063616e2774206260408201526b65206164647265737328302960a01b606082015260800190565b6020808252603d908201527f4c69624469616d6f6e644375743a205f63616c6c6461746120697320656d707460408201527f7920627574205f696e6974206973206e6f742061646472657373283029000000606082015260800190565b6020808252602e908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f766520696d6d7560408201526d3a30b1363290333ab731ba34b7b760911b606082015260800190565b60208082526035908201527f4c69624469616d6f6e644375743a2043616e2774206164642066756e6374696f60408201527f6e207468617420616c7265616479206578697374730000000000000000000000606082015260800190565b60208082526038908201527f4c69624469616d6f6e644375743a2043616e2774207265706c6163652066756e60408201527f6374696f6e20776974682073616d652066756e6374696f6e0000000000000000606082015260800190565b60208082526036908201527f4c69624469616d6f6e644375743a2052656d6f7665206661636574206164647260408201527f657373206d757374206265206164647265737328302900000000000000000000606082015260800190565b6040518181016001600160401b0381118282101715620013ed57fe5b604052919050565b60006001600160401b038211156200140957fe5b5060209081020190565b60005b838110156200143057818101518382015260200162001416565b83811115620008395750506000910152565b6118a780620014526000396000f3fe60806040523661000b57005b600080357fffffffff000000000000000000000000000000000000000000000000000000001681527fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c6020819052604090912054819073ffffffffffffffffffffffffffffffffffffffff16806100b7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906115f3565b60405180910390fd5b3660008037600080366000845af43d6000803e8080156100d6573d6000f35b3d6000fd5b60005b83518110156102325760008482815181106100f557fe5b60200260200101516020015190506000600281111561011057fe5b81600281111561011c57fe5b141561015f5761015a85838151811061013157fe5b60200260200101516000015186848151811061014957fe5b602002602001015160400151610326565b610229565b600181600281111561016d57fe5b14156101ab5761015a85838151811061018257fe5b60200260200101516000015186848151811061019a57fe5b60200260200101516040015161065e565b60028160028111156101b957fe5b14156101f75761015a8583815181106101ce57fe5b6020026020010151600001518684815181106101e657fe5b6020026020010151604001516109ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611539565b506001016100de565b507f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb67383838360405161026693929190611282565b60405180910390a16102788282610acb565b505050565b6000610287610302565b60048101805473ffffffffffffffffffffffffffffffffffffffff8581167fffffffffffffffffffffffff000000000000000000000000000000000000000083168117909355604051939450169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c90565b6000815111610361576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b600061036b610302565b905073ffffffffffffffffffffffffffffffffffffffff83166103ba576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166104ab5761040d8460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106104c557fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff168015610554576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906116e2565b5073ffffffffffffffffffffffffffffffffffffffff86166000818152600186810160209081526040808420805480850182559085528285206008820401805463ffffffff60079093166004026101000a928302191660e089901c929092029190911790557fffffffff00000000000000000000000000000000000000000000000000000000909516835287905292902080547fffffffffffffffffffffffff0000000000000000000000000000000000000000169091177fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff86160217905591820191016104ae565b5050505050565b6000815111610699576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006106a3610302565b905073ffffffffffffffffffffffffffffffffffffffff83166106f2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611596565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260018201602052604090205461ffff81166107e3576107458460405180606001604052806024815260200161184e60249139610c81565b60028201805473ffffffffffffffffffffffffffffffffffffffff861660008181526001808701602090815260408320820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff90961695909517909455845490810185559381529190912090910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690911790555b60005b83518110156106575760008482815181106107fd57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529186905260409091205490915073ffffffffffffffffffffffffffffffffffffffff908116908716811415610892576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061173f565b61089c8183610cbc565b507fffffffff00000000000000000000000000000000000000000000000000000000811660008181526020868152604080832080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8a160217815573ffffffffffffffffffffffffffffffffffffffff8b168085526001808b018552928520805480850182559086528486206008820401805463ffffffff60079093166004026101000a928302191660e09990991c91909102979097179096559390925286905281547fffffffffffffffffffffffff000000000000000000000000000000000000000016909217905591820191016107e6565b60008151116109e6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061147f565b60006109f0610302565b905073ffffffffffffffffffffffffffffffffffffffff831615610a40576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae9061179c565b60005b8251811015610ac5576000838281518110610a5a57fe5b6020908102919091018101517fffffffff00000000000000000000000000000000000000000000000000000000811660009081529185905260409091205490915073ffffffffffffffffffffffffffffffffffffffff16610abb8183610cbc565b5050600101610a43565b50505050565b73ffffffffffffffffffffffffffffffffffffffff8216610b2457805115610b1f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906113c5565b610c7d565b6000815111610b5f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611628565b73ffffffffffffffffffffffffffffffffffffffff82163014610b9e57610b9e8260405180606001604052806028815260200161182660289139610c81565b6000808373ffffffffffffffffffffffffffffffffffffffff1683604051610bc69190611266565b600060405180830381855af49150503d8060008114610c01576040519150601f19603f3d011682016040523d82523d6000602084013e610c06565b606091505b509150915081610ac557805115610c4b57806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611422565b5050565b813b8181610ac5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae91906113ab565b6000610cc6610302565b905073ffffffffffffffffffffffffffffffffffffffff8316610d15576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae906114dc565b73ffffffffffffffffffffffffffffffffffffffff8316301415610d65576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100ae90611685565b7fffffffff0000000000000000000000000000000000000000000000000000000082166000908152602082815260408083205473ffffffffffffffffffffffffffffffffffffffff8716845260018501909252909120547401000000000000000000000000000000000000000090910461ffff16907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01808214610f375773ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260408120805483908110610e3657fe5b6000918252602080832060088304015473ffffffffffffffffffffffffffffffffffffffff8a168452600188019091526040909220805460079092166004026101000a90920460e01b925082919085908110610e8e57fe5b600091825260208083206008830401805463ffffffff60079094166004026101000a938402191660e09590951c929092029390931790557fffffffff000000000000000000000000000000000000000000000000000000009290921682528490526040902080547fffffffffffffffffffff0000ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000061ffff8516021790555b73ffffffffffffffffffffffffffffffffffffffff851660009081526001840160205260409020805480610f6757fe5b6000828152602080822060087fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90940193840401805463ffffffff600460078716026101000a0219169055919092557fffffffff00000000000000000000000000000000000000000000000000000000861682528490526040902080547fffffffffffffffffffff000000000000000000000000000000000000000000001690558061065757600283015473ffffffffffffffffffffffffffffffffffffffff861660009081526001858101602052604090912001547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9091019061ffff1680821461114357600085600201838154811061107e57fe5b60009182526020909120015460028701805473ffffffffffffffffffffffffffffffffffffffff90921692508291849081106110b657fe5b600091825260208083209190910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff9485161790559290911681526001878101909252604090200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00001661ffff83161790555b8460020180548061115057fe5b6000828152602080822083017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90810180547fffffffffffffffffffffffff000000000000000000000000000000000000000016905590920190925573ffffffffffffffffffffffffffffffffffffffff89168252600187810190915260409091200180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000016905550505050505050565b73ffffffffffffffffffffffffffffffffffffffff169052565b600081518084526112348160208601602086016117f9565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b600082516112788184602087016117f9565b9190910192915050565b606080825284518282018190526000919060809081850190602080820287018401818b01875b8481101561137c577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff808a8403018652815188840173ffffffffffffffffffffffffffffffffffffffff8251168552858201516003811061130457fe5b858701526040918201519185018a9052815190819052908501908a90898601905b808310156113675783517fffffffff00000000000000000000000000000000000000000000000000000000168252928701926001929092019190870190611325565b509786019794505050908301906001016112a8565b505061138a8289018b611202565b878103604089015261139c818a61121c565b9b9a5050505050505050505050565b6000602082526113be602083018461121c565b9392505050565b6020808252603c908201527f4c69624469616d6f6e644375743a205f696e697420697320616464726573732860408201527f3029206275745f63616c6c64617461206973206e6f7420656d70747900000000606082015260800190565b60208082526026908201527f4c69624469616d6f6e644375743a205f696e69742066756e6374696f6e20726560408201527f7665727465640000000000000000000000000000000000000000000000000000606082015260800190565b6020808252602b908201527f4c69624469616d6f6e644375743a204e6f2073656c6563746f727320696e206660408201527f6163657420746f20637574000000000000000000000000000000000000000000606082015260800190565b60208082526037908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f76652066756e6360408201527f74696f6e207468617420646f65736e2774206578697374000000000000000000606082015260800190565b60208082526027908201527f4c69624469616d6f6e644375743a20496e636f7272656374204661636574437560408201527f74416374696f6e00000000000000000000000000000000000000000000000000606082015260800190565b6020808252602c908201527f4c69624469616d6f6e644375743a204164642066616365742063616e2774206260408201527f6520616464726573732830290000000000000000000000000000000000000000606082015260800190565b6020808252818101527f4469616d6f6e643a2046756e6374696f6e20646f6573206e6f74206578697374604082015260600190565b6020808252603d908201527f4c69624469616d6f6e644375743a205f63616c6c6461746120697320656d707460408201527f7920627574205f696e6974206973206e6f742061646472657373283029000000606082015260800190565b6020808252602e908201527f4c69624469616d6f6e644375743a2043616e27742072656d6f766520696d6d7560408201527f7461626c652066756e6374696f6e000000000000000000000000000000000000606082015260800190565b60208082526035908201527f4c69624469616d6f6e644375743a2043616e2774206164642066756e6374696f60408201527f6e207468617420616c7265616479206578697374730000000000000000000000606082015260800190565b60208082526038908201527f4c69624469616d6f6e644375743a2043616e2774207265706c6163652066756e60408201527f6374696f6e20776974682073616d652066756e6374696f6e0000000000000000606082015260800190565b60208082526036908201527f4c69624469616d6f6e644375743a2052656d6f7665206661636574206164647260408201527f657373206d757374206265206164647265737328302900000000000000000000606082015260800190565b60005b838110156118145781810151838201526020016117fc565b83811115610ac5575050600091015256fe4c69624469616d6f6e644375743a205f696e6974206164647265737320686173206e6f20636f64654c69624469616d6f6e644375743a204e657720666163657420686173206e6f20636f6465a264697066735822122054a3c3a118803545231f43700030cb5e290869be0182196a4a05e7d4a1b71d7e64736f6c634300070600334c69624469616d6f6e644375743a205f696e6974206164647265737320686173206e6f20636f64654c69624469616d6f6e644375743a204e657720666163657420686173206e6f20636f6465", + "deployedBytecode": "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", + "facets": [ + { + "facetAddress": "0x00C864C47Ed6B60f8C0588Da0d1065fB87d69B80", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0xd8a2d36d", + "0x70712939", + "0x6e4d22c2" + ] + }, + { + "facetAddress": "0x23Ba2174906E6668FF841829F923cFAEf2Ee228e", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ] + }, + { + "facetAddress": "0x092B2Ee3864fd374EE1786Ed31d7824Af63e3BED", + "functionSelectors": [ + "0x82f205cc", + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3", + "0x46e482fd", + "0xc676d298" + ] + }, + { + "facetAddress": "0xF8441De2A5Ec87402989bB3691aa0d9926607302", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ] + }, + { + "facetAddress": "0xAb5ABA751Fb9ff85b66B107BDC745882aA49B930", + "functionSelectors": ["0x241b71bb", "0xbb14516c"] + }, + { + "facetAddress": "0x7339d372116d8A56A9984814Ce1175377C58Fd7E", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"] + }, + { + "facetAddress": "0xB8030DBf749Ab84a59FE06D2346Ad2Cb856a9C49", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ] + }, + { + "facetAddress": "0x50a0DE2C69Ca270F8FBB4732EEA85552B89D7A5b", + "functionSelectors": ["0x9912dde8", "0x5a601668", "0x8a4f4f92"] + }, + { + "facetAddress": "0xe42b077B892a0B282F2B636C017199d5a55B192b", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ] + }, + { + "facetAddress": "0xB53dD2fE8B837E7877dfb43c046D75D5648A9005", + "functionSelectors": ["0xea40e51a", "0xfe5d095b"] + }, + { + "facetAddress": "0x802ff89ABeEe5F98eDDF38E20eF17F246F2c5d36", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ] + }, + { + "facetAddress": "0x4d046a028556D0404dE776B78EAC6e9E89ac3395", + "functionSelectors": [ + "0x46e04a2f", + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ] + }, + { + "facetAddress": "0xF1743209a10923d484b5e9B65e1Caf4eF7f6C372", + "functionSelectors": ["0x2239f556", "0x46efd16c", "0x78b248e4"] + }, + { + "facetAddress": "0xf98880D3d29c0337fb457d2adc1443849e4C0d59", + "functionSelectors": ["0xa7baf6fc", "0x6f70d212", "0x0f48a482"] + }, + { + "facetAddress": "0x61504A238e2DD5f6a6D027384816d8C944fe78b0", + "functionSelectors": ["0x71d78fbc", "0xf6376124", "0x33c72dfe"] + }, + { + "facetAddress": "0x76F35684665469FB1Bce0F2Abe0F34e3791ee3c9", + "functionSelectors": ["0x8d3900ba", "0xc9fe48fc", "0x1bb0a63e"] + } + ], + "diamondCut": [ + { + "facetAddress": "0x00C864C47Ed6B60f8C0588Da0d1065fB87d69B80", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0xd8a2d36d", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0x23Ba2174906E6668FF841829F923cFAEf2Ee228e", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x092B2Ee3864fd374EE1786Ed31d7824Af63e3BED", + "functionSelectors": [ + "0x82f205cc", + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3", + "0x46e482fd", + "0xc676d298" + ], + "action": 0 + }, + { + "facetAddress": "0xF8441De2A5Ec87402989bB3691aa0d9926607302", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0xAb5ABA751Fb9ff85b66B107BDC745882aA49B930", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0x7339d372116d8A56A9984814Ce1175377C58Fd7E", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0xB8030DBf749Ab84a59FE06D2346Ad2Cb856a9C49", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x50a0DE2C69Ca270F8FBB4732EEA85552B89D7A5b", + "functionSelectors": ["0x9912dde8", "0x5a601668", "0x8a4f4f92"], + "action": 0 + }, + { + "facetAddress": "0xe42b077B892a0B282F2B636C017199d5a55B192b", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0xB53dD2fE8B837E7877dfb43c046D75D5648A9005", + "functionSelectors": ["0xea40e51a", "0xfe5d095b"], + "action": 0 + }, + { + "facetAddress": "0x802ff89ABeEe5F98eDDF38E20eF17F246F2c5d36", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0x4d046a028556D0404dE776B78EAC6e9E89ac3395", + "functionSelectors": [ + "0x46e04a2f", + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0xF1743209a10923d484b5e9B65e1Caf4eF7f6C372", + "functionSelectors": ["0x2239f556", "0x46efd16c", "0x78b248e4"], + "action": 0 + }, + { + "facetAddress": "0xf98880D3d29c0337fb457d2adc1443849e4C0d59", + "functionSelectors": ["0xa7baf6fc", "0x6f70d212", "0x0f48a482"], + "action": 0 + }, + { + "facetAddress": "0x61504A238e2DD5f6a6D027384816d8C944fe78b0", + "functionSelectors": ["0x71d78fbc", "0xf6376124", "0x33c72dfe"], + "action": 0 + }, + { + "facetAddress": "0x76F35684665469FB1Bce0F2Abe0F34e3791ee3c9", + "functionSelectors": ["0x8d3900ba", "0xc9fe48fc", "0x1bb0a63e"], + "action": 0 + } + ], + "execute": { + "methodName": "init", + "args": [ + { + "admin": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "assets": [ + { + "sym": "AAVE", + "addr": "0xc2132D05D31c914a87C6611C10748AEb04B58e8F" + }, + { + "sym": "ADAI", + "addr": "0x639cB7b21ee2161DF9c882483C9D55c90c20Ca3e" + }, + { + "sym": "PCDAI", + "addr": "0xfecfa775643eb8c0f755491ba4569e501764da51" + }, + { + "sym": "WETH", + "addr": "0x3C68CE8504087f89c640D02d133646d98e64ddd9" + }, + { + "sym": "WMATIC", + "addr": "0x9c3C9283D3e44854697Cd22D3Faa240Cfb032889" + }, + { + "sym": "DAI", + "addr": "0x001B3B4d0F3714Ca98ba10F6042DaEbF0B1B7b6F" + }, + { + "sym": "USDC", + "addr": "0x2058A9D7613eEE744279e3856Ef0eAda5FCbaA7e" + }, + { + "sym": "USDT", + "addr": "0xBD21A10F619BE90d6066c941b04e340841F1F989" + }, + { + "sym": "LINK", + "addr": "0x326C977E6efc84E512bB9C30f76E30c160eD06FB" + }, + { + "sym": "WBTC", + "addr": "0x0d787a4a1548f673ed375445535a6c7A1EE56180" + } + ], + "cTokens": [ + "0x639cB7b21ee2161DF9c882483C9D55c90c20Ca3e", + "0x2271e3Fef9e15046d09E1d78a8FF038c691E9Cf9", + "0x7aE20397Ca327721F013BB9e140C707F82871b56" + ], + "tellerNFT": "0xfd7f9D58340DC9849e46752314a6A85d24446bbF", + "loansEscrowBeacon": "0xa49e48c4486275CA15eDdB86f5f30E02D04Ef68a", + "collateralEscrowBeacon": "0x3748F2e8a0E4609684805698EEa7855871D10467", + "tTokenBeacon": "0x29385cD1Cc03Df08f8e7BfEa0eF3e073598A190C", + "nftLiquidationController": "0x95143890162bd671d77ae9b771881a1cb76c29a4", + "wrappedNativeToken": "0x9c3C9283D3e44854697Cd22D3Faa240Cfb032889", + "nftDictionary": "0x60FD8B742dFc3f9c51C436EE15a1341886199791" + } + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/TellerDiamond_DiamondProxy.json b/deployments/polygon_mumbai/TellerDiamond_DiamondProxy.json new file mode 100644 index 000000000..bd0f35793 --- /dev/null +++ b/deployments/polygon_mumbai/TellerDiamond_DiamondProxy.json @@ -0,0 +1,674 @@ +{ + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "5667000", + "logsBloom": "0x0000000400000000000a000000008010000000000000800000800000000000200000000000000000800000000000000000008000002000000000000000000000000000000000000000000000000000800101000001000000040900000000000000000000020000020000008000000800000000000000000080000000100000400020000000000000000000004000001000000000000000000000000000000000200000000000000000000000100000000000008000000000001040000000005000000000000100000001000000000000000000000020000100100000000020000000000000000000000000000000000000000000020000000000000000108000", + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694", + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000ab3ea92a73b116eb4fd092106de715b2aca65a54", + "logIndex": 2, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000ab3ea92a73b116eb4fd092106de715b2aca65a5400000000000000000000000000000000000000000000000000000000000012c0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000046000000000000000000000000000000000000000000000000000000000000005a000000000000000000000000000000000000000000000000000000000000006a00000000000000000000000000000000000000000000000000000000000000760000000000000000000000000000000000000000000000000000000000000082000000000000000000000000000000000000000000000000000000000000009200000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000b200000000000000000000000000000000000000000000000000000000000000be00000000000000000000000000000000000000000000000000000000000000da00000000000000000000000000000000000000000000000000000000000000ec00000000000000000000000000000000000000000000000000000000000000fa00000000000000000000000000000000000000000000000000000000000001080000000000000000000000000000000000000000000000000000000000000116000000000000000000000000000c864c47ed6b60f8c0588da0d1065fb87d69b8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000742f1181e000000000000000000000000000000000000000000000000000000006eade577000000000000000000000000000000000000000000000000000000004dc2304d00000000000000000000000000000000000000000000000000000000ad21879e00000000000000000000000000000000000000000000000000000000d8a2d36d0000000000000000000000000000000000000000000000000000000070712939000000000000000000000000000000000000000000000000000000006e4d22c20000000000000000000000000000000000000000000000000000000000000000000000000000000023ba2174906e6668ff841829f923cfaef2ee228e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000049dec88b900000000000000000000000000000000000000000000000000000000ce19912900000000000000000000000000000000000000000000000000000000d10a0aec0000000000000000000000000000000000000000000000000000000074b1d75d00000000000000000000000000000000000000000000000000000000000000000000000000000000092b2ee3864fd374ee1786ed31d7824af63e3bed00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000682f205cc00000000000000000000000000000000000000000000000000000000c76d202d00000000000000000000000000000000000000000000000000000000839bb9a6000000000000000000000000000000000000000000000000000000008e756bb30000000000000000000000000000000000000000000000000000000046e482fd00000000000000000000000000000000000000000000000000000000c676d29800000000000000000000000000000000000000000000000000000000000000000000000000000000f8441de2a5ec87402989bb3691aa0d9926607302000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004fee2792b00000000000000000000000000000000000000000000000000000000bf6d79ab00000000000000000000000000000000000000000000000000000000c1c52f8800000000000000000000000000000000000000000000000000000000ec1c2bb500000000000000000000000000000000000000000000000000000000000000000000000000000000ab5aba751fb9ff85b66b107bdc745882aa49b930000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002241b71bb00000000000000000000000000000000000000000000000000000000bb14516c000000000000000000000000000000000000000000000000000000000000000000000000000000007339d372116d8a56a9984814ce1175377c58fd7e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000235a7206d00000000000000000000000000000000000000000000000000000000c05b1ec300000000000000000000000000000000000000000000000000000000000000000000000000000000b8030dbf749ab84a59fe06d2346ad2cb856a9c49000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004961113df0000000000000000000000000000000000000000000000000000000010d94006000000000000000000000000000000000000000000000000000000008fe2b41400000000000000000000000000000000000000000000000000000000020ce3a60000000000000000000000000000000000000000000000000000000000000000000000000000000050a0de2c69ca270f8fbb4732eea85552b89d7a5b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000039912dde8000000000000000000000000000000000000000000000000000000005a601668000000000000000000000000000000000000000000000000000000008a4f4f9200000000000000000000000000000000000000000000000000000000000000000000000000000000e42b077b892a0b282f2b636c017199d5a55b192b00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000513abaf0700000000000000000000000000000000000000000000000000000000ece1373200000000000000000000000000000000000000000000000000000000ed903f7a00000000000000000000000000000000000000000000000000000000010d573000000000000000000000000000000000000000000000000000000000767a7b0500000000000000000000000000000000000000000000000000000000000000000000000000000000b53dd2fe8b837e7877dfb43c046d75d5648a9005000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002ea40e51a00000000000000000000000000000000000000000000000000000000fe5d095b00000000000000000000000000000000000000000000000000000000000000000000000000000000802ff89abeee5f98eddf38e20ef17f246f2c5d3600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000aeee8b7ff0000000000000000000000000000000000000000000000000000000072e1132700000000000000000000000000000000000000000000000000000000f4f015700000000000000000000000000000000000000000000000000000000046a384be00000000000000000000000000000000000000000000000000000000e949756100000000000000000000000000000000000000000000000000000000504006ca00000000000000000000000000000000000000000000000000000000c4c1662b00000000000000000000000000000000000000000000000000000000bddffdc4000000000000000000000000000000000000000000000000000000000634612f000000000000000000000000000000000000000000000000000000003b929300000000000000000000000000000000000000000000000000000000000000000000000000000000004d046a028556d0404de776b78eac6e9e89ac339500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000546e04a2f00000000000000000000000000000000000000000000000000000000e89ad656000000000000000000000000000000000000000000000000000000005ebc633400000000000000000000000000000000000000000000000000000000ccdd9f5d000000000000000000000000000000000000000000000000000000008a700b5300000000000000000000000000000000000000000000000000000000000000000000000000000000f1743209a10923d484b5e9b65e1caf4ef7f6c3720000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000032239f5560000000000000000000000000000000000000000000000000000000046efd16c0000000000000000000000000000000000000000000000000000000078b248e400000000000000000000000000000000000000000000000000000000000000000000000000000000f98880d3d29c0337fb457d2adc1443849e4c0d59000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000003a7baf6fc000000000000000000000000000000000000000000000000000000006f70d212000000000000000000000000000000000000000000000000000000000f48a4820000000000000000000000000000000000000000000000000000000000000000000000000000000061504a238e2dd5f6a6d027384816d8c944fe78b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000371d78fbc00000000000000000000000000000000000000000000000000000000f63761240000000000000000000000000000000000000000000000000000000033c72dfe0000000000000000000000000000000000000000000000000000000000000000000000000000000076f35684665469fb1bce0f2abe0f34e3791ee3c90000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000038d3900ba00000000000000000000000000000000000000000000000000000000c9fe48fc000000000000000000000000000000000000000000000000000000001bb0a63e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000844d8a2d36d0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5000000000000000000000000000000000000000000000000000000000000014000000000000000000000000000000000000000000000000000000000000007a0000000000000000000000000fd7f9d58340dc9849e46752314a6a85d24446bbf000000000000000000000000a49e48c4486275ca15eddb86f5f30e02d04ef68a0000000000000000000000003748f2e8a0e4609684805698eea7855871d1046700000000000000000000000029385cd1cc03df08f8e7bfea0ef3e073598a190c00000000000000000000000095143890162bd671d77ae9b771881a1cb76c29a40000000000000000000000009c3c9283d3e44854697cd22d3faa240cfb03288900000000000000000000000060fd8b742dfc3f9c51c436ee15a1341886199791000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000014000000000000000000000000000000000000000000000000000000000000001c0000000000000000000000000000000000000000000000000000000000000024000000000000000000000000000000000000000000000000000000000000002c0000000000000000000000000000000000000000000000000000000000000034000000000000000000000000000000000000000000000000000000000000003c0000000000000000000000000000000000000000000000000000000000000044000000000000000000000000000000000000000000000000000000000000004c0000000000000000000000000000000000000000000000000000000000000054000000000000000000000000000000000000000000000000000000000000005c00000000000000000000000000000000000000000000000000000000000000040000000000000000000000000c2132d05d31c914a87c6611c10748aeb04b58e8f000000000000000000000000000000000000000000000000000000000000000441415645000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000639cb7b21ee2161df9c882483c9d55c90c20ca3e000000000000000000000000000000000000000000000000000000000000000441444149000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000fecfa775643eb8c0f755491ba4569e501764da510000000000000000000000000000000000000000000000000000000000000005504344414900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000003c68ce8504087f89c640d02d133646d98e64ddd90000000000000000000000000000000000000000000000000000000000000004574554480000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000009c3c9283d3e44854697cd22d3faa240cfb0328890000000000000000000000000000000000000000000000000000000000000006574d4154494300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000001b3b4d0f3714ca98ba10f6042daebf0b1b7b6f0000000000000000000000000000000000000000000000000000000000000003444149000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000002058a9d7613eee744279e3856ef0eada5fcbaa7e000000000000000000000000000000000000000000000000000000000000000455534443000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000bd21a10f619be90d6066c941b04e340841f1f989000000000000000000000000000000000000000000000000000000000000000455534454000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000326c977e6efc84e512bb9c30f76e30c160ed06fb00000000000000000000000000000000000000000000000000000000000000044c494e4b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000d787a4a1548f673ed375445535a6c7a1ee56180000000000000000000000000000000000000000000000000000000000000000457425443000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003000000000000000000000000639cb7b21ee2161df9c882483c9d55c90c20ca3e0000000000000000000000002271e3fef9e15046d09e1d78a8ff038c691e9cf90000000000000000000000007ae20397ca327721f013bb9e140c707f82871b5600000000000000000000000000000000000000000000000000000000", + "logIndex": 3, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000c275dc8be39f50d12f66b6a63629c39da5bae5bd" + ], + "data": "0x000000000000000000000000000000000000000000000000025bff31ba43a00000000000000000000000000000000000000000000000000039eb94ebc31428000000000000000000000000000000000000000000000000b41811ed8f531c41d5000000000000000000000000000000000000000000000000378f95ba08d088000000000000000000000000000000000000000000000000b41a6decc10d5fe1d5", + "logIndex": 7, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000ab3ea92a73b116eb4fd092106de715b2aca65a54", + "logIndex": 2, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694", + "args": ["0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54"], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0x539440820030c4994db4e31b6b800deafd503688728f932addfe7a410515c14c", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0xAb3eA92a73B116Eb4Fd092106de715b2aCA65A54", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 6, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + }, + { + "transactionIndex": 0, + "blockNumber": 15692496, + "transactionHash": "0xc1731f32174b1d116482eaad8af43ac306fa6925cdbace160e41f193a1b6947a", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000c275dc8be39f50d12f66b6a63629c39da5bae5bd" + ], + "data": "0x000000000000000000000000000000000000000000000000025bff31ba43a00000000000000000000000000000000000000000000000000039eb94ebc31428000000000000000000000000000000000000000000000000b41811ed8f531c41d5000000000000000000000000000000000000000000000000378f95ba08d088000000000000000000000000000000000000000000000000b41a6decc10d5fe1d5", + "logIndex": 7, + "blockHash": "0x319c79ed9ad8e2ad1bc6a1ebd858215989b0e61e7ac3a4b8fac642f86c6ce694" + } + ], + "blockNumber": 15692496, + "cumulativeGasUsed": "5667000", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0x00C864C47Ed6B60f8C0588Da0d1065fB87d69B80", + "functionSelectors": [ + "0x42f1181e", + "0x6eade577", + "0x4dc2304d", + "0xad21879e", + "0xd8a2d36d", + "0x70712939", + "0x6e4d22c2" + ], + "action": 0 + }, + { + "facetAddress": "0x23Ba2174906E6668FF841829F923cFAEf2Ee228e", + "functionSelectors": [ + "0x9dec88b9", + "0xce199129", + "0xd10a0aec", + "0x74b1d75d" + ], + "action": 0 + }, + { + "facetAddress": "0x092B2Ee3864fd374EE1786Ed31d7824Af63e3BED", + "functionSelectors": [ + "0x82f205cc", + "0xc76d202d", + "0x839bb9a6", + "0x8e756bb3", + "0x46e482fd", + "0xc676d298" + ], + "action": 0 + }, + { + "facetAddress": "0xF8441De2A5Ec87402989bB3691aa0d9926607302", + "functionSelectors": [ + "0xfee2792b", + "0xbf6d79ab", + "0xc1c52f88", + "0xec1c2bb5" + ], + "action": 0 + }, + { + "facetAddress": "0xAb5ABA751Fb9ff85b66B107BDC745882aA49B930", + "functionSelectors": ["0x241b71bb", "0xbb14516c"], + "action": 0 + }, + { + "facetAddress": "0x7339d372116d8A56A9984814Ce1175377C58Fd7E", + "functionSelectors": ["0x35a7206d", "0xc05b1ec3"], + "action": 0 + }, + { + "facetAddress": "0xB8030DBf749Ab84a59FE06D2346Ad2Cb856a9C49", + "functionSelectors": [ + "0x961113df", + "0x10d94006", + "0x8fe2b414", + "0x020ce3a6" + ], + "action": 0 + }, + { + "facetAddress": "0x50a0DE2C69Ca270F8FBB4732EEA85552B89D7A5b", + "functionSelectors": ["0x9912dde8", "0x5a601668", "0x8a4f4f92"], + "action": 0 + }, + { + "facetAddress": "0xe42b077B892a0B282F2B636C017199d5a55B192b", + "functionSelectors": [ + "0x13abaf07", + "0xece13732", + "0xed903f7a", + "0x010d5730", + "0x767a7b05" + ], + "action": 0 + }, + { + "facetAddress": "0xB53dD2fE8B837E7877dfb43c046D75D5648A9005", + "functionSelectors": ["0xea40e51a", "0xfe5d095b"], + "action": 0 + }, + { + "facetAddress": "0x802ff89ABeEe5F98eDDF38E20eF17F246F2c5d36", + "functionSelectors": [ + "0xeee8b7ff", + "0x72e11327", + "0xf4f01570", + "0x46a384be", + "0xe9497561", + "0x504006ca", + "0xc4c1662b", + "0xbddffdc4", + "0x0634612f", + "0x3b929300" + ], + "action": 0 + }, + { + "facetAddress": "0x4d046a028556D0404dE776B78EAC6e9E89ac3395", + "functionSelectors": [ + "0x46e04a2f", + "0xe89ad656", + "0x5ebc6334", + "0xccdd9f5d", + "0x8a700b53" + ], + "action": 0 + }, + { + "facetAddress": "0xF1743209a10923d484b5e9B65e1Caf4eF7f6C372", + "functionSelectors": ["0x2239f556", "0x46efd16c", "0x78b248e4"], + "action": 0 + }, + { + "facetAddress": "0xf98880D3d29c0337fb457d2adc1443849e4C0d59", + "functionSelectors": ["0xa7baf6fc", "0x6f70d212", "0x0f48a482"], + "action": 0 + }, + { + "facetAddress": "0x61504A238e2DD5f6a6D027384816d8C944fe78b0", + "functionSelectors": ["0x71d78fbc", "0xf6376124", "0x33c72dfe"], + "action": 0 + }, + { + "facetAddress": "0x76F35684665469FB1Bce0F2Abe0F34e3791ee3c9", + "functionSelectors": ["0x8d3900ba", "0xc9fe48fc", "0x1bb0a63e"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/TellerNFT.json b/deployments/polygon_mumbai/TellerNFT.json new file mode 100644 index 000000000..8bdded0ce --- /dev/null +++ b/deployments/polygon_mumbai/TellerNFT.json @@ -0,0 +1,1439 @@ +{ + "address": "0xfd7f9D58340DC9849e46752314a6A85d24446bbF", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "owner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "approved", + "type": "address" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "Approval", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "owner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "operator", + "type": "address" + }, + { + "indexed": false, + "internalType": "bool", + "name": "approved", + "type": "bool" + } + ], + "name": "ApprovalForAll", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "previousAdminRole", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "newAdminRole", + "type": "bytes32" + } + ], + "name": "RoleAdminChanged", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "account", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "RoleGranted", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "account", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "RoleRevoked", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "from", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "Transfer", + "type": "event" + }, + { + "inputs": [], + "name": "ADMIN", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "DEFAULT_ADMIN_ROLE", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "MINTER", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "minter", + "type": "address" + } + ], + "name": "addMinter", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "string[]", + "name": "hashes", + "type": "string[]" + }, + { + "internalType": "address", + "name": "contributionAsset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "contributionSize", + "type": "uint256" + }, + { + "internalType": "uint8", + "name": "contributionMultiplier", + "type": "uint8" + } + ], + "internalType": "struct ITellerNFT.Tier", + "name": "newTier", + "type": "tuple" + } + ], + "name": "addTier", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "approve", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "name": "balanceOf", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "contractURI", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "getApproved", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "name": "getOwnedTokens", + "outputs": [ + { + "internalType": "uint256[]", + "name": "owned_", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + } + ], + "name": "getRoleAdmin", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "index", + "type": "uint256" + } + ], + "name": "getTier", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "string[]", + "name": "hashes", + "type": "string[]" + }, + { + "internalType": "address", + "name": "contributionAsset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "contributionSize", + "type": "uint256" + }, + { + "internalType": "uint8", + "name": "contributionMultiplier", + "type": "uint8" + } + ], + "internalType": "struct ITellerNFT.Tier", + "name": "tier_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tierIndex", + "type": "uint256" + } + ], + "name": "getTierHashes", + "outputs": [ + { + "internalType": "string[]", + "name": "hashes_", + "type": "string[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "getTokenTier", + "outputs": [ + { + "internalType": "uint256", + "name": "index_", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "string[]", + "name": "hashes", + "type": "string[]" + }, + { + "internalType": "address", + "name": "contributionAsset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "contributionSize", + "type": "uint256" + }, + { + "internalType": "uint8", + "name": "contributionMultiplier", + "type": "uint8" + } + ], + "internalType": "struct ITellerNFT.Tier", + "name": "tier_", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "grantRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasRole", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "minters", + "type": "address[]" + } + ], + "name": "initialize", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + }, + { + "internalType": "address", + "name": "operator", + "type": "address" + } + ], + "name": "isApprovedForAll", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tierIndex", + "type": "uint256" + }, + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "name": "mint", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "name", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "ownerOf", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "minter", + "type": "address" + } + ], + "name": "removeMinter", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "renounceRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "revokeRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "from", + "type": "address" + }, + { + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "safeTransferFrom", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "from", + "type": "address" + }, + { + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + }, + { + "internalType": "bytes", + "name": "_data", + "type": "bytes" + } + ], + "name": "safeTransferFrom", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "operator", + "type": "address" + }, + { + "internalType": "bool", + "name": "approved", + "type": "bool" + } + ], + "name": "setApprovalForAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "string", + "name": "contractURIHash", + "type": "string" + } + ], + "name": "setContractURIHash", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "symbol", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "tokenURI", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "from", + "type": "address" + }, + { + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "transferFrom", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "TellerNFT", + "transactionHash": "0x1faf5a6ca1982d00ffb048d338a9b03462862979a6682cefe32884bd603f8298", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0xfd7f9D58340DC9849e46752314a6A85d24446bbF", + "transactionIndex": 0, + "gasUsed": "2619805", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000800100000000000000000100000000000000000000000000000000000000000000000000000000080080000000000000000000000000040000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000004000000000000100200001000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0xbd40172910fc96fc97012058b5db210a7e6ce9bdb2d8d1ac3e451a0b822e3cec", + "transactionHash": "0x1faf5a6ca1982d00ffb048d338a9b03462862979a6682cefe32884bd603f8298", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692280, + "transactionHash": "0x1faf5a6ca1982d00ffb048d338a9b03462862979a6682cefe32884bd603f8298", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b26c22237816d898cb9992d767444105bfdc03b6" + ], + "data": "0x000000000000000000000000000000000000000000000000011738f6882c7c0000000000000000000000000000000000000000000000000052bd1d1586b60800000000000000000000000000000000000000000000000005a30452a14f701b3000000000000000000000000000000000000000000000000051a5e41efe898c00000000000000000000000000000000000000000000000005a41b8b97d79c9730", + "logIndex": 0, + "blockHash": "0xbd40172910fc96fc97012058b5db210a7e6ce9bdb2d8d1ac3e451a0b822e3cec" + } + ], + "blockNumber": 15692280, + "cumulativeGasUsed": "2619805", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"approved\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"previousAdminRole\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"newAdminRole\",\"type\":\"bytes32\"}],\"name\":\"RoleAdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"RoleGranted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"RoleRevoked\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"ADMIN\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DEFAULT_ADMIN_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"MINTER\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"minter\",\"type\":\"address\"}],\"name\":\"addMinter\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"baseLoanSize\",\"type\":\"uint256\"},{\"internalType\":\"string[]\",\"name\":\"hashes\",\"type\":\"string[]\"},{\"internalType\":\"address\",\"name\":\"contributionAsset\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"contributionSize\",\"type\":\"uint256\"},{\"internalType\":\"uint8\",\"name\":\"contributionMultiplier\",\"type\":\"uint8\"}],\"internalType\":\"struct ITellerNFT.Tier\",\"name\":\"newTier\",\"type\":\"tuple\"}],\"name\":\"addTier\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"contractURI\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"getApproved\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"getOwnedTokens\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"owned_\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"}],\"name\":\"getRoleAdmin\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"getTier\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"baseLoanSize\",\"type\":\"uint256\"},{\"internalType\":\"string[]\",\"name\":\"hashes\",\"type\":\"string[]\"},{\"internalType\":\"address\",\"name\":\"contributionAsset\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"contributionSize\",\"type\":\"uint256\"},{\"internalType\":\"uint8\",\"name\":\"contributionMultiplier\",\"type\":\"uint8\"}],\"internalType\":\"struct ITellerNFT.Tier\",\"name\":\"tier_\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tierIndex\",\"type\":\"uint256\"}],\"name\":\"getTierHashes\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"hashes_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"getTokenTier\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"index_\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"baseLoanSize\",\"type\":\"uint256\"},{\"internalType\":\"string[]\",\"name\":\"hashes\",\"type\":\"string[]\"},{\"internalType\":\"address\",\"name\":\"contributionAsset\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"contributionSize\",\"type\":\"uint256\"},{\"internalType\":\"uint8\",\"name\":\"contributionMultiplier\",\"type\":\"uint8\"}],\"internalType\":\"struct ITellerNFT.Tier\",\"name\":\"tier_\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"grantRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"hasRole\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"minters\",\"type\":\"address[]\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tierIndex\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"mint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"ownerOf\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"minter\",\"type\":\"address\"}],\"name\":\"removeMinter\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"renounceRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"revokeRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"contractURIHash\",\"type\":\"string\"}],\"name\":\"setContractURIHash\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"tokenURI\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"develop@teller.finance\",\"kind\":\"dev\",\"methods\":{\"addMinter(address)\":{\"params\":{\"minter\":\"the address of the minter to add to the role of MINTER\"}},\"addTier((uint256,string[],address,uint256,uint8))\":{\"details\":\"It auto increments the index of the next tier to add.\",\"params\":{\"newTier\":\"Information about the new tier to add. Requirements: - Caller must have the {MINTER} role\"}},\"approve(address,uint256)\":{\"details\":\"See {IERC721-approve}.\"},\"balanceOf(address)\":{\"details\":\"See {IERC721-balanceOf}.\"},\"contractURI()\":{\"returns\":{\"_0\":\"the contract URI hash\"}},\"getApproved(uint256)\":{\"details\":\"See {IERC721-getApproved}.\"},\"getOwnedTokens(address)\":{\"details\":\"It uses a EnumerableSet to store values and loops over each element to add to the array.Can be costly if calling within a contract for address with many tokens.\",\"returns\":{\"owned_\":\"the array of tokenIDs owned by the address\"}},\"getRoleAdmin(bytes32)\":{\"details\":\"Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}.\"},\"getTier(uint256)\":{\"params\":{\"index\":\"Tier index to get info.\"},\"returns\":{\"tier_\":\"the tier which belongs to the respective index\"}},\"getTierHashes(uint256)\":{\"params\":{\"tierIndex\":\"the tier index to get the tier hashes\"},\"returns\":{\"hashes_\":\"all the tokenID hashes\"}},\"getTokenTier(uint256)\":{\"params\":{\"tokenId\":\"ID of the token to get Tier info.\"},\"returns\":{\"index_\":\"the index of the tier the tokenID belongs in\",\"tier_\":\"the tier where the tokenID belongs in\"}},\"grantRole(bytes32,address)\":{\"details\":\"Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role.\"},\"hasRole(bytes32,address)\":{\"details\":\"Returns `true` if `account` has been granted `role`.\"},\"initialize(address[])\":{\"params\":{\"minters\":\"The addresses that should allowed to mint tokens.\"}},\"isApprovedForAll(address,address)\":{\"details\":\"See {IERC721-isApprovedForAll}.\"},\"mint(uint256,address)\":{\"params\":{\"owner\":\"The owner of the new token. Requirements: - Caller must be an authorized minter\",\"tierIndex\":\"Tier to mint token on.\"}},\"name()\":{\"details\":\"See {IERC721Metadata-name}.\"},\"ownerOf(uint256)\":{\"details\":\"See {IERC721-ownerOf}.\"},\"removeMinter(address)\":{\"params\":{\"minter\":\"the address of the minter\"}},\"renounceRole(bytes32,address)\":{\"details\":\"Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `account`.\"},\"revokeRole(bytes32,address)\":{\"details\":\"Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role.\"},\"safeTransferFrom(address,address,uint256)\":{\"details\":\"See {IERC721-safeTransferFrom}.\"},\"safeTransferFrom(address,address,uint256,bytes)\":{\"details\":\"See {IERC721-safeTransferFrom}.\"},\"setApprovalForAll(address,bool)\":{\"details\":\"See {IERC721-setApprovalForAll}.\"},\"setContractURIHash(string)\":{\"params\":{\"contractURIHash\":\"The hash to the initial contract level metadata.\"}},\"supportsInterface(bytes4)\":{\"params\":{\"interfaceId\":\"the identifier of the interface\"},\"returns\":{\"_0\":\"bool stating whether or not our interface is supported\"}},\"symbol()\":{\"details\":\"See {IERC721Metadata-symbol}.\"},\"tokenURI(uint256)\":{\"params\":{\"tokenId\":\"the token identifier that returns the hash of the baseURI and the tokenURI hash\"},\"returns\":{\"_0\":\"the tokenURI\"}},\"transferFrom(address,address,uint256)\":{\"details\":\"See {IERC721-transferFrom}.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"addMinter(address)\":{\"notice\":\"it adds the minter to the rule\"},\"addTier((uint256,string[],address,uint256,uint8))\":{\"notice\":\"Adds a new Tier to be minted with the given information.\"},\"contractURI()\":{\"notice\":\"The contract metadata URI.\"},\"getOwnedTokens(address)\":{\"notice\":\"It returns an array of token IDs owned by an address.\"},\"getTier(uint256)\":{\"notice\":\"It returns information about a Tier for a token ID.\"},\"getTierHashes(uint256)\":{\"notice\":\"It returns an array of hashes in a tier\"},\"getTokenTier(uint256)\":{\"notice\":\"It returns information about a Tier for a token ID.\"},\"initialize(address[])\":{\"notice\":\"Initializes the TellerNFT.\"},\"mint(uint256,address)\":{\"notice\":\"It mints a new token for a Tier index.\"},\"removeMinter(address)\":{\"notice\":\"it removes the minter by revoking the role of the address assigned to MINTER\"},\"setContractURIHash(string)\":{\"notice\":\"Sets the contract level metadata URI hash.\"},\"supportsInterface(bytes4)\":{\"notice\":\"checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\"},\"tokenURI(uint256)\":{\"notice\":\"The token URI is based on the token ID.\"}},\"notice\":\"This contract is used by borrowers to call Dapp functions (using delegate calls).This contract should only be constructed using it's upgradeable Proxy contract.In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/nft/TellerNFT.sol\":\"TellerNFT\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721Upgradeable.sol\\\";\\nimport \\\"./IERC721ReceiverUpgradeable.sol\\\";\\nimport \\\"./extensions/IERC721MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\\n using AddressUpgradeable for address;\\n using StringsUpgradeable for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping (uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping (address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping (uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping (address => mapping (address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __ERC721_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\\n return interfaceId == type(IERC721Upgradeable).interfaceId\\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\\n : '';\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\\n * in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n require(operator != _msgSender(), \\\"ERC721: approve to caller\\\");\\n\\n _operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\\n _mint(to, tokenId);\\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721Upgradeable.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \\\"ERC721: transfer of token that is not own\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\\n private returns (bool)\\n {\\n if (to.isContract()) {\\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\\n uint256[44] private __gap;\\n}\\n\",\"keccak256\":\"0x2ab92ebd3f4d4d85f30b39bd678ec3489e00aadd0a432c7a0ffa98adc2799004\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721ReceiverUpgradeable {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x33620beff0655c5e728a72fff76fb6ce2dc32fc6b61eb8e435b12ed1adf31525\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165Upgradeable.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721Upgradeable is IERC165Upgradeable {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0x9ef7f2874f4a491f253a81eb4c5b9a7b6467a287aa0c32ac3dd684260a3cd7ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721Upgradeable.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x64581a092c059ab0cb74f473545e379b8a88f36a6a57f805515ef8c6ae061847\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5642ae1d6b33c5c0b71a8412c6c64cbcf2468b84a002bee3e33cdb5644d25cdb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Counters.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x62d306ff0499a11913bc60b5939eec619509b5c67b30e86ebf8b8bda0b7a7fee\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2526b7c6a366fc211bbc176078ab02b83833e7682abcc5b3bed9d700b34e2a3e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping (bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) { // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\\n\\n bytes32 lastvalue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastvalue;\\n // Update the index for the moved value\\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n require(set._values.length > index, \\\"EnumerableSet: index out of bounds\\\");\\n return set._values[index];\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n}\\n\",\"keccak256\":\"0x4878ef6c288f4cef3c2a288d32cc548c648831cc55503ad3d9a581ed3b93aad9\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/Counters.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeMath.sol\\\";\\n\\n// Interfaces\\nimport \\\"./ITellerNFT.sol\\\";\\n\\n/*****************************************************************************************************/\\n/** WARNING **/\\n/** THIS CONTRACT IS UPGRADEABLE! **/\\n/** --------------------------------------------------------------------------------------------- **/\\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\\n/** **/\\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\\n/** more information. **/\\n/*****************************************************************************************************/\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\\n using Counters for Counters.Counter;\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeMath for uint256;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n bytes32 public constant MINTER = keccak256(\\\"MINTER\\\");\\n\\n /* State Variables */\\n\\n // It holds the total number of tiers.\\n Counters.Counter internal _tierCounter;\\n\\n // It holds the total number of tokens minted.\\n Counters.Counter internal _tokenCounter;\\n\\n // It holds the information about a tier.\\n mapping(uint256 => Tier) internal _tiers;\\n\\n // It holds which tier a token ID is in.\\n mapping(uint256 => uint256) internal _tokenTier;\\n\\n // It holds a set of token IDs for an owner address.\\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\\n\\n // Link to the contract metadata\\n string private _metadataBaseURI;\\n\\n // Hash to the contract metadata located on the {_metadataBaseURI}\\n string private _contractURIHash;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFT: not admin\\\");\\n _;\\n }\\n\\n modifier onlyMinter() {\\n require(hasRole(MINTER, _msgSender()), \\\"TellerNFT: not minter\\\");\\n _;\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index)\\n external\\n view\\n override\\n returns (Tier memory tier_)\\n {\\n tier_ = _tiers[index];\\n }\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n override\\n returns (uint256 index_, Tier memory tier_)\\n {\\n index_ = _tokenTier[tokenId];\\n tier_ = _tiers[index_];\\n }\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n override\\n returns (string[] memory hashes_)\\n {\\n hashes_ = _tiers[tierIndex].hashes;\\n }\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned_ the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n override\\n returns (uint256[] memory owned_)\\n {\\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\\n owned_ = new uint256[](set.length());\\n for (uint256 i; i < owned_.length; i++) {\\n owned_[i] = set.at(i);\\n }\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contract URI hash\\n */\\n function contractURI() external view override returns (string memory) {\\n return _contractURIHash;\\n }\\n\\n /**\\n * @notice The token URI is based on the token ID.\\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\\n * @return the tokenURI\\n */\\n function tokenURI(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n require(_exists(tokenId), \\\"TellerNFT: URI query for nonexistent token\\\");\\n\\n string memory baseURI = _baseURI();\\n return\\n bytes(baseURI).length > 0\\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\\n : \\\"\\\";\\n }\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex Tier to mint token on.\\n * @param owner The owner of the new token.\\n *\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner)\\n external\\n override\\n onlyMinter\\n {\\n // Get the new token ID\\n uint256 tokenId = _tokenCounter.current();\\n _tokenCounter.increment();\\n\\n // Mint and set the token to the tier index\\n _safeMint(owner, tokenId);\\n _tokenTier[tokenId] = tierIndex;\\n\\n // Set owner\\n _setOwner(owner, tokenId);\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external override onlyMinter {\\n Tier storage tier = _tiers[_tierCounter.current()];\\n\\n tier.baseLoanSize = newTier.baseLoanSize;\\n tier.hashes = newTier.hashes;\\n tier.contributionAsset = newTier.contributionAsset;\\n tier.contributionSize = newTier.contributionSize;\\n tier.contributionMultiplier = newTier.contributionMultiplier;\\n\\n _tierCounter.increment();\\n }\\n\\n /**\\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\\n * @param minter the address of the minter\\n */\\n function removeMinter(address minter) external onlyMinter {\\n revokeRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice it adds the minter to the rule\\n * @param minter the address of the minter to add to the role of MINTER\\n */\\n function addMinter(address minter) public onlyMinter {\\n _setupRole(MINTER, minter);\\n }\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash)\\n external\\n override\\n onlyAdmin\\n {\\n _contractURIHash = contractURIHash;\\n }\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters)\\n external\\n override\\n initializer\\n {\\n __ERC721_init(\\\"Teller NFT\\\", \\\"TNFT\\\");\\n __AccessControl_init();\\n\\n for (uint256 i; i < minters.length; i++) {\\n _setupRole(MINTER, minters[i]);\\n }\\n\\n _metadataBaseURI = \\\"https://gateway.pinata.cloud/ipfs/\\\";\\n _contractURIHash = \\\"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\\\";\\n }\\n\\n /**\\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\\n * @param interfaceId the identifier of the interface\\n * @return bool stating whether or not our interface is supported\\n */\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable, ERC721Upgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(ITellerNFT).interfaceId ||\\n ERC721Upgradeable.supportsInterface(interfaceId) ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @notice It returns the hash to use for the token URI.\\n * @param tokenId the tokenId to get the tokenURI hash\\n * @return the tokenURIHash of our NFT\\n */\\n function _tokenURIHash(uint256 tokenId)\\n internal\\n view\\n returns (string memory)\\n {\\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice The base URI path where the token media is hosted.\\n * @dev Base URI for computing {tokenURI}\\n * @return our metadata URI\\n */\\n function _baseURI() internal view override returns (string memory) {\\n return _metadataBaseURI;\\n }\\n\\n /**\\n * @notice Moves token to new owner set and then transfers.\\n * @param from address to transfer from\\n * @param to address to transfer to\\n * @param tokenId tokenID to transfer\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal override {\\n _setOwner(to, tokenId);\\n super._transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @notice It removes the token from the current owner set and adds to new owner.\\n * @param newOwner the new owner of the tokenID\\n * @param tokenId the ID of the NFT\\n */\\n function _setOwner(address newOwner, uint256 tokenId) internal {\\n address currentOwner = ownerOf(tokenId);\\n if (currentOwner != address(0)) {\\n _ownerTokenIDs[currentOwner].remove(tokenId);\\n }\\n _ownerTokenIDs[newOwner].add(tokenId);\\n }\\n\\n function _msgData() internal pure override returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x417b75f5d92be67993efc54db7d453be5b5058a9a54d8916380e0281d3299526\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "author": "develop@teller.finance", + "kind": "dev", + "methods": { + "addMinter(address)": { + "params": { + "minter": "the address of the minter to add to the role of MINTER" + } + }, + "addTier((uint256,string[],address,uint256,uint8))": { + "details": "It auto increments the index of the next tier to add.", + "params": { + "newTier": "Information about the new tier to add. Requirements: - Caller must have the {MINTER} role" + } + }, + "approve(address,uint256)": { + "details": "See {IERC721-approve}." + }, + "balanceOf(address)": { + "details": "See {IERC721-balanceOf}." + }, + "contractURI()": { + "returns": { + "_0": "the contract URI hash" + } + }, + "getApproved(uint256)": { + "details": "See {IERC721-getApproved}." + }, + "getOwnedTokens(address)": { + "details": "It uses a EnumerableSet to store values and loops over each element to add to the array.Can be costly if calling within a contract for address with many tokens.", + "returns": { + "owned_": "the array of tokenIDs owned by the address" + } + }, + "getRoleAdmin(bytes32)": { + "details": "Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}." + }, + "getTier(uint256)": { + "params": { + "index": "Tier index to get info." + }, + "returns": { + "tier_": "the tier which belongs to the respective index" + } + }, + "getTierHashes(uint256)": { + "params": { + "tierIndex": "the tier index to get the tier hashes" + }, + "returns": { + "hashes_": "all the tokenID hashes" + } + }, + "getTokenTier(uint256)": { + "params": { + "tokenId": "ID of the token to get Tier info." + }, + "returns": { + "index_": "the index of the tier the tokenID belongs in", + "tier_": "the tier where the tokenID belongs in" + } + }, + "grantRole(bytes32,address)": { + "details": "Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role." + }, + "hasRole(bytes32,address)": { + "details": "Returns `true` if `account` has been granted `role`." + }, + "initialize(address[])": { + "params": { + "minters": "The addresses that should allowed to mint tokens." + } + }, + "isApprovedForAll(address,address)": { + "details": "See {IERC721-isApprovedForAll}." + }, + "mint(uint256,address)": { + "params": { + "owner": "The owner of the new token. Requirements: - Caller must be an authorized minter", + "tierIndex": "Tier to mint token on." + } + }, + "name()": { + "details": "See {IERC721Metadata-name}." + }, + "ownerOf(uint256)": { + "details": "See {IERC721-ownerOf}." + }, + "removeMinter(address)": { + "params": { + "minter": "the address of the minter" + } + }, + "renounceRole(bytes32,address)": { + "details": "Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `account`." + }, + "revokeRole(bytes32,address)": { + "details": "Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role." + }, + "safeTransferFrom(address,address,uint256)": { + "details": "See {IERC721-safeTransferFrom}." + }, + "safeTransferFrom(address,address,uint256,bytes)": { + "details": "See {IERC721-safeTransferFrom}." + }, + "setApprovalForAll(address,bool)": { + "details": "See {IERC721-setApprovalForAll}." + }, + "setContractURIHash(string)": { + "params": { + "contractURIHash": "The hash to the initial contract level metadata." + } + }, + "supportsInterface(bytes4)": { + "params": { + "interfaceId": "the identifier of the interface" + }, + "returns": { + "_0": "bool stating whether or not our interface is supported" + } + }, + "symbol()": { + "details": "See {IERC721Metadata-symbol}." + }, + "tokenURI(uint256)": { + "params": { + "tokenId": "the token identifier that returns the hash of the baseURI and the tokenURI hash" + }, + "returns": { + "_0": "the tokenURI" + } + }, + "transferFrom(address,address,uint256)": { + "details": "See {IERC721-transferFrom}." + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "addMinter(address)": { + "notice": "it adds the minter to the rule" + }, + "addTier((uint256,string[],address,uint256,uint8))": { + "notice": "Adds a new Tier to be minted with the given information." + }, + "contractURI()": { + "notice": "The contract metadata URI." + }, + "getOwnedTokens(address)": { + "notice": "It returns an array of token IDs owned by an address." + }, + "getTier(uint256)": { + "notice": "It returns information about a Tier for a token ID." + }, + "getTierHashes(uint256)": { + "notice": "It returns an array of hashes in a tier" + }, + "getTokenTier(uint256)": { + "notice": "It returns information about a Tier for a token ID." + }, + "initialize(address[])": { + "notice": "Initializes the TellerNFT." + }, + "mint(uint256,address)": { + "notice": "It mints a new token for a Tier index." + }, + "removeMinter(address)": { + "notice": "it removes the minter by revoking the role of the address assigned to MINTER" + }, + "setContractURIHash(string)": { + "notice": "Sets the contract level metadata URI hash." + }, + "supportsInterface(bytes4)": { + "notice": "checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable" + }, + "tokenURI(uint256)": { + "notice": "The token URI is based on the token ID." + } + }, + "notice": "This contract is used by borrowers to call Dapp functions (using delegate calls).This contract should only be constructed using it's upgradeable Proxy contract.In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.", + "version": 1 + }, + "storageLayout": { + "storage": [ + { + "astId": 635, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "_initialized", + "offset": 0, + "slot": "0", + "type": "t_bool" + }, + { + "astId": 638, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "_initializing", + "offset": 1, + "slot": "0", + "type": "t_bool" + }, + { + "astId": 2833, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "__gap", + "offset": 0, + "slot": "1", + "type": "t_array(t_uint256)50_storage" + }, + { + "astId": 3082, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "__gap", + "offset": 0, + "slot": "51", + "type": "t_array(t_uint256)50_storage" + }, + { + "astId": 1565, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "_name", + "offset": 0, + "slot": "101", + "type": "t_string_storage" + }, + { + "astId": 1567, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "_symbol", + "offset": 0, + "slot": "102", + "type": "t_string_storage" + }, + { + "astId": 1571, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "_owners", + "offset": 0, + "slot": "103", + "type": "t_mapping(t_uint256,t_address)" + }, + { + "astId": 1575, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "_balances", + "offset": 0, + "slot": "104", + "type": "t_mapping(t_address,t_uint256)" + }, + { + "astId": 1579, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "_tokenApprovals", + "offset": 0, + "slot": "105", + "type": "t_mapping(t_uint256,t_address)" + }, + { + "astId": 1585, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "_operatorApprovals", + "offset": 0, + "slot": "106", + "type": "t_mapping(t_address,t_mapping(t_address,t_bool))" + }, + { + "astId": 2383, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "__gap", + "offset": 0, + "slot": "107", + "type": "t_array(t_uint256)44_storage" + }, + { + "astId": 189, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "_roles", + "offset": 0, + "slot": "151", + "type": "t_mapping(t_bytes32,t_struct(RoleData)184_storage)" + }, + { + "astId": 497, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "__gap", + "offset": 0, + "slot": "152", + "type": "t_array(t_uint256)49_storage" + }, + { + "astId": 17125, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "_tierCounter", + "offset": 0, + "slot": "201", + "type": "t_struct(Counter)5088_storage" + }, + { + "astId": 17128, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "_tokenCounter", + "offset": 0, + "slot": "202", + "type": "t_struct(Counter)5088_storage" + }, + { + "astId": 17133, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "_tiers", + "offset": 0, + "slot": "203", + "type": "t_mapping(t_uint256,t_struct(Tier)16881_storage)" + }, + { + "astId": 17137, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "_tokenTier", + "offset": 0, + "slot": "204", + "type": "t_mapping(t_uint256,t_uint256)" + }, + { + "astId": 17142, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "_ownerTokenIDs", + "offset": 0, + "slot": "205", + "type": "t_mapping(t_address,t_struct(UintSet)6696_storage)" + }, + { + "astId": 17144, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "_metadataBaseURI", + "offset": 0, + "slot": "206", + "type": "t_string_storage" + }, + { + "astId": 17146, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "_contractURIHash", + "offset": 0, + "slot": "207", + "type": "t_string_storage" + } + ], + "types": { + "t_address": { + "encoding": "inplace", + "label": "address", + "numberOfBytes": "20" + }, + "t_array(t_bytes32)dyn_storage": { + "base": "t_bytes32", + "encoding": "dynamic_array", + "label": "bytes32[]", + "numberOfBytes": "32" + }, + "t_array(t_string_storage)dyn_storage": { + "base": "t_string_storage", + "encoding": "dynamic_array", + "label": "string[]", + "numberOfBytes": "32" + }, + "t_array(t_uint256)44_storage": { + "base": "t_uint256", + "encoding": "inplace", + "label": "uint256[44]", + "numberOfBytes": "1408" + }, + "t_array(t_uint256)49_storage": { + "base": "t_uint256", + "encoding": "inplace", + "label": "uint256[49]", + "numberOfBytes": "1568" + }, + "t_array(t_uint256)50_storage": { + "base": "t_uint256", + "encoding": "inplace", + "label": "uint256[50]", + "numberOfBytes": "1600" + }, + "t_bool": { + "encoding": "inplace", + "label": "bool", + "numberOfBytes": "1" + }, + "t_bytes32": { + "encoding": "inplace", + "label": "bytes32", + "numberOfBytes": "32" + }, + "t_mapping(t_address,t_bool)": { + "encoding": "mapping", + "key": "t_address", + "label": "mapping(address => bool)", + "numberOfBytes": "32", + "value": "t_bool" + }, + "t_mapping(t_address,t_mapping(t_address,t_bool))": { + "encoding": "mapping", + "key": "t_address", + "label": "mapping(address => mapping(address => bool))", + "numberOfBytes": "32", + "value": "t_mapping(t_address,t_bool)" + }, + "t_mapping(t_address,t_struct(UintSet)6696_storage)": { + "encoding": "mapping", + "key": "t_address", + "label": "mapping(address => struct EnumerableSet.UintSet)", + "numberOfBytes": "32", + "value": "t_struct(UintSet)6696_storage" + }, + "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(RoleData)184_storage)": { + "encoding": "mapping", + "key": "t_bytes32", + "label": "mapping(bytes32 => struct AccessControlUpgradeable.RoleData)", + "numberOfBytes": "32", + "value": "t_struct(RoleData)184_storage" + }, + "t_mapping(t_bytes32,t_uint256)": { + "encoding": "mapping", + "key": "t_bytes32", + "label": "mapping(bytes32 => uint256)", + "numberOfBytes": "32", + "value": "t_uint256" + }, + "t_mapping(t_uint256,t_address)": { + "encoding": "mapping", + "key": "t_uint256", + "label": "mapping(uint256 => address)", + "numberOfBytes": "32", + "value": "t_address" + }, + "t_mapping(t_uint256,t_struct(Tier)16881_storage)": { + "encoding": "mapping", + "key": "t_uint256", + "label": "mapping(uint256 => struct ITellerNFT.Tier)", + "numberOfBytes": "32", + "value": "t_struct(Tier)16881_storage" + }, + "t_mapping(t_uint256,t_uint256)": { + "encoding": "mapping", + "key": "t_uint256", + "label": "mapping(uint256 => uint256)", + "numberOfBytes": "32", + "value": "t_uint256" + }, + "t_string_storage": { + "encoding": "bytes", + "label": "string", + "numberOfBytes": "32" + }, + "t_struct(Counter)5088_storage": { + "encoding": "inplace", + "label": "struct Counters.Counter", + "members": [ + { + "astId": 5087, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "_value", + "offset": 0, + "slot": "0", + "type": "t_uint256" + } + ], + "numberOfBytes": "32" + }, + "t_struct(RoleData)184_storage": { + "encoding": "inplace", + "label": "struct AccessControlUpgradeable.RoleData", + "members": [ + { + "astId": 181, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "members", + "offset": 0, + "slot": "0", + "type": "t_mapping(t_address,t_bool)" + }, + { + "astId": 183, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "adminRole", + "offset": 0, + "slot": "1", + "type": "t_bytes32" + } + ], + "numberOfBytes": "64" + }, + "t_struct(Set)6294_storage": { + "encoding": "inplace", + "label": "struct EnumerableSet.Set", + "members": [ + { + "astId": 6289, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "_values", + "offset": 0, + "slot": "0", + "type": "t_array(t_bytes32)dyn_storage" + }, + { + "astId": 6293, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "_indexes", + "offset": 0, + "slot": "1", + "type": "t_mapping(t_bytes32,t_uint256)" + } + ], + "numberOfBytes": "64" + }, + "t_struct(Tier)16881_storage": { + "encoding": "inplace", + "label": "struct ITellerNFT.Tier", + "members": [ + { + "astId": 16871, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "baseLoanSize", + "offset": 0, + "slot": "0", + "type": "t_uint256" + }, + { + "astId": 16874, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "hashes", + "offset": 0, + "slot": "1", + "type": "t_array(t_string_storage)dyn_storage" + }, + { + "astId": 16876, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "contributionAsset", + "offset": 0, + "slot": "2", + "type": "t_address" + }, + { + "astId": 16878, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "contributionSize", + "offset": 0, + "slot": "3", + "type": "t_uint256" + }, + { + "astId": 16880, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "contributionMultiplier", + "offset": 0, + "slot": "4", + "type": "t_uint8" + } + ], + "numberOfBytes": "160" + }, + "t_struct(UintSet)6696_storage": { + "encoding": "inplace", + "label": "struct EnumerableSet.UintSet", + "members": [ + { + "astId": 6695, + "contract": "contracts/nft/TellerNFT.sol:TellerNFT", + "label": "_inner", + "offset": 0, + "slot": "0", + "type": "t_struct(Set)6294_storage" + } + ], + "numberOfBytes": "64" + }, + "t_uint256": { + "encoding": "inplace", + "label": "uint256", + "numberOfBytes": "32" + }, + "t_uint8": { + "encoding": "inplace", + "label": "uint8", + "numberOfBytes": "1" + } + } + } +} diff --git a/deployments/polygon_mumbai/TellerNFTDictionary.json b/deployments/polygon_mumbai/TellerNFTDictionary.json new file mode 100644 index 000000000..86b92bff1 --- /dev/null +++ b/deployments/polygon_mumbai/TellerNFTDictionary.json @@ -0,0 +1,894 @@ +{ + "address": "0x60FD8B742dFc3f9c51C436EE15a1341886199791", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "previousAdmin", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "newAdmin", + "type": "address" + } + ], + "name": "AdminChanged", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "implementation", + "type": "address" + } + ], + "name": "Upgraded", + "type": "event" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "inputs": [], + "name": "admin", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newAdmin", + "type": "address" + } + ], + "name": "changeAdmin", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "implementation", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newImplementation", + "type": "address" + } + ], + "name": "upgradeTo", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newImplementation", + "type": "address" + }, + { + "internalType": "bytes", + "name": "data", + "type": "bytes" + } + ], + "name": "upgradeToAndCall", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "previousAdminRole", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "newAdminRole", + "type": "bytes32" + } + ], + "name": "RoleAdminChanged", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "account", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "RoleGranted", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "account", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "RoleRevoked", + "type": "event" + }, + { + "inputs": [], + "name": "ADMIN", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "DEFAULT_ADMIN_ROLE", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "_tokenTierMappingCompressed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "_tokenTierMappingCompressedSet", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "baseLoanSizes", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "contributionAssets", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "contributionMultipliers", + "outputs": [ + { + "internalType": "uint8", + "name": "", + "type": "uint8" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "contributionSizes", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + } + ], + "name": "getRoleAdmin", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tierIndex", + "type": "uint256" + } + ], + "name": "getTierHashes", + "outputs": [ + { + "internalType": "string[]", + "name": "", + "type": "string[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "getTokenTierIndex", + "outputs": [ + { + "internalType": "uint8", + "name": "index_", + "type": "uint8" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "grantRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasRole", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "hashes", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "initialAdmin", + "type": "address" + } + ], + "name": "initialize", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "renounceRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "revokeRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "tiersMapping", + "type": "uint256[]" + } + ], + "name": "setAllTokenTierMappings", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "index", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "string[]", + "name": "hashes", + "type": "string[]" + }, + { + "internalType": "address", + "name": "contributionAsset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "contributionSize", + "type": "uint256" + }, + { + "internalType": "uint8", + "name": "contributionMultiplier", + "type": "uint8" + } + ], + "internalType": "struct TellerNFTDictionary.Tier", + "name": "newTier", + "type": "tuple" + } + ], + "name": "setTier", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "tokenTier", + "type": "uint256" + } + ], + "name": "setTokenTierForTokenId", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "tokenIds", + "type": "uint256[]" + }, + { + "internalType": "uint256", + "name": "tokenTier", + "type": "uint256" + } + ], + "name": "setTokenTierForTokenIds", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "index", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "tierMapping", + "type": "uint256" + } + ], + "name": "setTokenTierMapping", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "tokenBaseLoanSize", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "tokenContributionAsset", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "tokenContributionMultiplier", + "outputs": [ + { + "internalType": "uint8", + "name": "", + "type": "uint8" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "tokenContributionSize", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "tokenURIHash", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "initialLogic", + "type": "address" + }, + { + "internalType": "address", + "name": "initialAdmin", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_data", + "type": "bytes" + } + ], + "stateMutability": "payable", + "type": "constructor" + } + ], + "artifactName": "EIP173Proxy", + "transactionHash": "0x2f22784480ac0812613e8db32dd3a9c7dc8b8c2bbbfe9cb7078621630f679f57", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x60FD8B742dFc3f9c51C436EE15a1341886199791", + "transactionIndex": 0, + "gasUsed": "618768", + "logsBloom": "0x00000004000000000800000000008000080000000000000000000000000000200000000000000000000000000000000000008000002000000000000000000000000000000000000000000000000000800100000000000000040100000000000000000000020000400000008000000800000000000000000080000000000000000000000000000000000000000000000000000000000000000001000000000000200000000000000000000000100000000000000000000000001040000000004000000000000100000001000000000000000000000000000100100000000020000000004000000000200000000000000000000000000000000000000000100000", + "blockHash": "0xab87008fd5d48c159b57510d4df816e78a94ca40cd83affdadedb7f29dbe68b1", + "transactionHash": "0x2f22784480ac0812613e8db32dd3a9c7dc8b8c2bbbfe9cb7078621630f679f57", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692289, + "transactionHash": "0x2f22784480ac0812613e8db32dd3a9c7dc8b8c2bbbfe9cb7078621630f679f57", + "address": "0x60FD8B742dFc3f9c51C436EE15a1341886199791", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 0, + "blockHash": "0xab87008fd5d48c159b57510d4df816e78a94ca40cd83affdadedb7f29dbe68b1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692289, + "transactionHash": "0x2f22784480ac0812613e8db32dd3a9c7dc8b8c2bbbfe9cb7078621630f679f57", + "address": "0x60FD8B742dFc3f9c51C436EE15a1341886199791", + "topics": [ + "0xbd79b86ffe0ab8e8776151514217cd7cacd52c909f66475c3af44e129f0b00ff", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0xab87008fd5d48c159b57510d4df816e78a94ca40cd83affdadedb7f29dbe68b1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692289, + "transactionHash": "0x2f22784480ac0812613e8db32dd3a9c7dc8b8c2bbbfe9cb7078621630f679f57", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000c275dc8be39f50d12f66b6a63629c39da5bae5bd" + ], + "data": "0x0000000000000000000000000000000000000000000000000041f2fc8d26c00000000000000000000000000000000000000000000000000050bfdacfe3befc000000000000000000000000000000000000000000000000b4070a69863f8505d5000000000000000000000000000000000000000000000000507de7d356983c000000000000000000000000000000000000000000000000b4074c5c82ccabc5d5", + "logIndex": 2, + "blockHash": "0xab87008fd5d48c159b57510d4df816e78a94ca40cd83affdadedb7f29dbe68b1" + } + ], + "blockNumber": 15692289, + "cumulativeGasUsed": "618768", + "status": 1, + "byzantium": true + }, + "args": [ + "0x629812CEfd43A00D34101F9A218d518b11B0bd1F", + "0x40d6Cab1722fF9A0C5bBf5Fb00141C427039fE4a", + "0xc4d66de8000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "solcInputHash": "1635d55d57a0a2552952c0d22586ed23", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initialLogic\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"initialAdmin\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"inputs\":[],\"name\":\"admin\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"changeAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"implementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"details\":\"This contract implements a proxy that is upgradeable by an admin. To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector clashing], which can potentially be used in an attack, this contract uses the https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two things that go hand in hand: 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if that call matches one of the admin functions exposed by the proxy itself. 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the implementation. If the admin tries to call a function on the implementation it will fail with an error that says \\\"admin cannot fallback to proxy target\\\". These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due to sudden errors when trying to call a function from the proxy implementation. Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way, you should think of the `ProxyAdmin` instance as the real administrative inerface of your proxy.\",\"events\":{\"AdminChanged(address,address)\":{\"details\":\"Emitted when the admin account has changed.\"}},\"kind\":\"dev\",\"methods\":{\"admin()\":{\"details\":\"Returns the current admin. NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}. TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call. `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`\"},\"changeAdmin(address)\":{\"details\":\"Changes the admin of the proxy. Emits an {AdminChanged} event. NOTE: Only the admin can call this function. See {ProxyAdmin-changeProxyAdmin}.\"},\"constructor\":{\"details\":\"Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and optionally initialized with `_data` as explained in {UpgradeableProxy-constructor}.\"},\"implementation()\":{\"details\":\"Returns the current implementation. NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}. TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call. `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`\"},\"upgradeTo(address)\":{\"details\":\"Upgrade the implementation of the proxy. NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}.\"},\"upgradeToAndCall(address,bytes)\":{\"details\":\"Upgrade the implementation of the proxy, and then call a function from the new implementation as specified by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the proxied contract. NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}.\"}},\"stateVariables\":{\"_ADMIN_SLOT\":{\"details\":\"Storage slot with the admin of the contract. This is the keccak-256 hash of \\\"eip1967.proxy.admin\\\" subtracted by 1, and is validated in the constructor.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/openzeppelin/proxy/TransparentUpgradeableProxy.sol\":\"TransparentUpgradeableProxy\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/openzeppelin/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.7.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n * \\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n * \\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n * \\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal virtual view returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n * \\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () payable external {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () payable external {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n * \\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc33f9858a67e34c77831163d5611d21fc627dfd2c303806a98a6c9db5a01b034\",\"license\":\"MIT\"},\"solc_0.7/openzeppelin/proxy/TransparentUpgradeableProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.7.0;\\n\\nimport \\\"./UpgradeableProxy.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that is upgradeable by an admin.\\n * \\n * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector\\n * clashing], which can potentially be used in an attack, this contract uses the\\n * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two\\n * things that go hand in hand:\\n * \\n * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if\\n * that call matches one of the admin functions exposed by the proxy itself.\\n * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the\\n * implementation. If the admin tries to call a function on the implementation it will fail with an error that says\\n * \\\"admin cannot fallback to proxy target\\\".\\n * \\n * These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing\\n * the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due\\n * to sudden errors when trying to call a function from the proxy implementation.\\n * \\n * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way,\\n * you should think of the `ProxyAdmin` instance as the real administrative inerface of your proxy.\\n */\\ncontract TransparentUpgradeableProxy is UpgradeableProxy {\\n /**\\n * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and\\n * optionally initialized with `_data` as explained in {UpgradeableProxy-constructor}.\\n */\\n constructor(address initialLogic, address initialAdmin, bytes memory _data) payable UpgradeableProxy(initialLogic, _data) {\\n assert(_ADMIN_SLOT == bytes32(uint256(keccak256(\\\"eip1967.proxy.admin\\\")) - 1));\\n _setAdmin(initialAdmin);\\n }\\n\\n /**\\n * @dev Emitted when the admin account has changed.\\n */\\n event AdminChanged(address previousAdmin, address newAdmin);\\n\\n /**\\n * @dev Storage slot with the admin of the contract.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.admin\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 private constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\\n\\n /**\\n * @dev Modifier used internally that will delegate the call to the implementation unless the sender is the admin.\\n */\\n modifier ifAdmin() {\\n if (msg.sender == _admin()) {\\n _;\\n } else {\\n _fallback();\\n }\\n }\\n\\n /**\\n * @dev Returns the current admin.\\n * \\n * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}.\\n * \\n * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the\\n * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\\n * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`\\n */\\n function admin() external ifAdmin returns (address) {\\n return _admin();\\n }\\n\\n /**\\n * @dev Returns the current implementation.\\n * \\n * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}.\\n * \\n * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the\\n * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\\n * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`\\n */\\n function implementation() external ifAdmin returns (address) {\\n return _implementation();\\n }\\n\\n /**\\n * @dev Changes the admin of the proxy.\\n * \\n * Emits an {AdminChanged} event.\\n * \\n * NOTE: Only the admin can call this function. See {ProxyAdmin-changeProxyAdmin}.\\n */\\n function changeAdmin(address newAdmin) external ifAdmin {\\n require(newAdmin != address(0), \\\"TransparentUpgradeableProxy: new admin is the zero address\\\");\\n emit AdminChanged(_admin(), newAdmin);\\n _setAdmin(newAdmin);\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy.\\n * \\n * NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}.\\n */\\n function upgradeTo(address newImplementation) external ifAdmin {\\n _upgradeTo(newImplementation);\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified\\n * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the\\n * proxied contract.\\n * \\n * NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}.\\n */\\n function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {\\n _upgradeTo(newImplementation);\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success,) = newImplementation.delegatecall(data);\\n require(success);\\n }\\n\\n /**\\n * @dev Returns the current admin.\\n */\\n function _admin() internal view returns (address adm) {\\n bytes32 slot = _ADMIN_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n adm := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 admin slot.\\n */\\n function _setAdmin(address newAdmin) private {\\n bytes32 slot = _ADMIN_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, newAdmin)\\n }\\n }\\n\\n /**\\n * @dev Makes sure the admin cannot access the fallback function. See {Proxy-_beforeFallback}.\\n */\\n function _beforeFallback() internal override virtual {\\n require(msg.sender != _admin(), \\\"TransparentUpgradeableProxy: admin cannot fallback to proxy target\\\");\\n super._beforeFallback();\\n }\\n}\\n\",\"keccak256\":\"0xd6cecbe00dc78355aff1a16d83487bb73c54701004d61a2e48cdb81e2bcacc26\",\"license\":\"MIT\"},\"solc_0.7/openzeppelin/proxy/UpgradeableProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.7.0;\\n\\nimport \\\"./Proxy.sol\\\";\\nimport \\\"../utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an\\n * implementation address that can be changed. This address is stored in storage in the location specified by\\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the\\n * implementation behind the proxy.\\n * \\n * Upgradeability is only provided internally through {_upgradeTo}. For an externally upgradeable proxy see\\n * {TransparentUpgradeableProxy}.\\n */\\ncontract UpgradeableProxy is Proxy {\\n /**\\n * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.\\n * \\n * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded\\n * function call, and allows initializating the storage of the proxy like a Solidity constructor.\\n */\\n constructor(address _logic, bytes memory _data) payable {\\n assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256(\\\"eip1967.proxy.implementation\\\")) - 1));\\n _setImplementation(_logic);\\n if(_data.length > 0) {\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success,) = _logic.delegatecall(_data);\\n require(success);\\n }\\n }\\n\\n /**\\n * @dev Emitted when the implementation is upgraded.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Storage slot with the address of the current implementation.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.implementation\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 private constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function _implementation() internal override view returns (address impl) {\\n bytes32 slot = _IMPLEMENTATION_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n impl := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Upgrades the proxy to a new implementation.\\n * \\n * Emits an {Upgraded} event.\\n */\\n function _upgradeTo(address newImplementation) internal {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 implementation slot.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(Address.isContract(newImplementation), \\\"UpgradeableProxy: new implementation is not a contract\\\");\\n\\n bytes32 slot = _IMPLEMENTATION_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, newImplementation)\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd68f4c11941712db79a61b9dca81a5db663cfacec3d7bb19f8d2c23bb1ab8afe\",\"license\":\"MIT\"},\"solc_0.7/openzeppelin/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.7.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // According to EIP-1052, 0x0 is the value returned for not-yet created accounts\\n // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned\\n // for accounts without code, i.e. `keccak256('')`\\n bytes32 codehash;\\n bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { codehash := extcodehash(account) }\\n return (codehash != accountHash && codehash != 0x0);\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return _functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n return _functionCallWithValue(target, data, value, errorMessage);\\n }\\n\\n function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x698f929f1097637d051976b322a2d532c27df022b09010e8d091e2888a5ebdf8\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "execute": { + "methodName": "initialize", + "args": ["0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5"] + }, + "implementation": "0x629812CEfd43A00D34101F9A218d518b11B0bd1F", + "devdoc": { + "details": "This contract implements a proxy that is upgradeable by an admin. To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector clashing], which can potentially be used in an attack, this contract uses the https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two things that go hand in hand: 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if that call matches one of the admin functions exposed by the proxy itself. 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the implementation. If the admin tries to call a function on the implementation it will fail with an error that says \"admin cannot fallback to proxy target\". These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due to sudden errors when trying to call a function from the proxy implementation. Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way, you should think of the `ProxyAdmin` instance as the real administrative inerface of your proxy.", + "events": { + "AdminChanged(address,address)": { + "details": "Emitted when the admin account has changed." + } + }, + "kind": "dev", + "methods": { + "admin()": { + "details": "Returns the current admin. NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}. TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call. `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`" + }, + "changeAdmin(address)": { + "details": "Changes the admin of the proxy. Emits an {AdminChanged} event. NOTE: Only the admin can call this function. See {ProxyAdmin-changeProxyAdmin}." + }, + "constructor": { + "details": "Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and optionally initialized with `_data` as explained in {UpgradeableProxy-constructor}." + }, + "implementation()": { + "details": "Returns the current implementation. NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}. TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call. `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`" + }, + "upgradeTo(address)": { + "details": "Upgrade the implementation of the proxy. NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}." + }, + "upgradeToAndCall(address,bytes)": { + "details": "Upgrade the implementation of the proxy, and then call a function from the new implementation as specified by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the proxied contract. NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}." + } + }, + "stateVariables": { + "_ADMIN_SLOT": { + "details": "Storage slot with the admin of the contract. This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1, and is validated in the constructor." + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/TellerNFTDictionary_Implementation.json b/deployments/polygon_mumbai/TellerNFTDictionary_Implementation.json new file mode 100644 index 000000000..7cbf17f56 --- /dev/null +++ b/deployments/polygon_mumbai/TellerNFTDictionary_Implementation.json @@ -0,0 +1,1027 @@ +{ + "address": "0x629812CEfd43A00D34101F9A218d518b11B0bd1F", + "abi": [ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "previousAdminRole", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "newAdminRole", + "type": "bytes32" + } + ], + "name": "RoleAdminChanged", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "account", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "RoleGranted", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "account", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "RoleRevoked", + "type": "event" + }, + { + "inputs": [], + "name": "ADMIN", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "DEFAULT_ADMIN_ROLE", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "_tokenTierMappingCompressed", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "_tokenTierMappingCompressedSet", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "baseLoanSizes", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "contributionAssets", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "contributionMultipliers", + "outputs": [ + { + "internalType": "uint8", + "name": "", + "type": "uint8" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "contributionSizes", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + } + ], + "name": "getRoleAdmin", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tierIndex", + "type": "uint256" + } + ], + "name": "getTierHashes", + "outputs": [ + { + "internalType": "string[]", + "name": "", + "type": "string[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "getTokenTierIndex", + "outputs": [ + { + "internalType": "uint8", + "name": "index_", + "type": "uint8" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "grantRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasRole", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "hashes", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "initialAdmin", + "type": "address" + } + ], + "name": "initialize", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "renounceRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "revokeRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "tiersMapping", + "type": "uint256[]" + } + ], + "name": "setAllTokenTierMappings", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "index", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "baseLoanSize", + "type": "uint256" + }, + { + "internalType": "string[]", + "name": "hashes", + "type": "string[]" + }, + { + "internalType": "address", + "name": "contributionAsset", + "type": "address" + }, + { + "internalType": "uint256", + "name": "contributionSize", + "type": "uint256" + }, + { + "internalType": "uint8", + "name": "contributionMultiplier", + "type": "uint8" + } + ], + "internalType": "struct TellerNFTDictionary.Tier", + "name": "newTier", + "type": "tuple" + } + ], + "name": "setTier", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "tokenTier", + "type": "uint256" + } + ], + "name": "setTokenTierForTokenId", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "tokenIds", + "type": "uint256[]" + }, + { + "internalType": "uint256", + "name": "tokenTier", + "type": "uint256" + } + ], + "name": "setTokenTierForTokenIds", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "index", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "tierMapping", + "type": "uint256" + } + ], + "name": "setTokenTierMapping", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "tokenBaseLoanSize", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "tokenContributionAsset", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "tokenContributionMultiplier", + "outputs": [ + { + "internalType": "uint8", + "name": "", + "type": "uint8" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "tokenContributionSize", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "tokenURIHash", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + } + ], + "artifactName": "TellerNFTDictionary", + "transactionHash": "0xbbcac10e314478a22995c9c17a1e56cdbab73f1cf0af5cf6a7c37868b354374b", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x629812CEfd43A00D34101F9A218d518b11B0bd1F", + "transactionIndex": 0, + "gasUsed": "1486855", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000800100000000000000000100000000000000000000000000000000000000000000000000000000080080000000000000000000000000040000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000004000000000000100200001000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0x0b68f543a46bcfb697a8a720953cd23ce66ac8241740ffe827bcef232c0f6fd8", + "transactionHash": "0xbbcac10e314478a22995c9c17a1e56cdbab73f1cf0af5cf6a7c37868b354374b", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692287, + "transactionHash": "0xbbcac10e314478a22995c9c17a1e56cdbab73f1cf0af5cf6a7c37868b354374b", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b26c22237816d898cb9992d767444105bfdc03b6" + ], + "data": "0x000000000000000000000000000000000000000000000000009e789a3339b400000000000000000000000000000000000000000000000000515e536a16f8b000000000000000000000000000000000000000000000000005a46593419bdcd33000000000000000000000000000000000000000000000000050bfdacfe3befc00000000000000000000000000000000000000000000000005a5040bdbcf168730", + "logIndex": 0, + "blockHash": "0x0b68f543a46bcfb697a8a720953cd23ce66ac8241740ffe827bcef232c0f6fd8" + } + ], + "blockNumber": 15692287, + "cumulativeGasUsed": "1486855", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"previousAdminRole\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"newAdminRole\",\"type\":\"bytes32\"}],\"name\":\"RoleAdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"RoleGranted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"RoleRevoked\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"ADMIN\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DEFAULT_ADMIN_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"_tokenTierMappingCompressed\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"_tokenTierMappingCompressedSet\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"baseLoanSizes\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"contributionAssets\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"contributionMultipliers\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"contributionSizes\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"}],\"name\":\"getRoleAdmin\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tierIndex\",\"type\":\"uint256\"}],\"name\":\"getTierHashes\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"getTokenTierIndex\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"index_\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"grantRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"hasRole\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"hashes\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initialAdmin\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"renounceRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"revokeRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256[]\",\"name\":\"tiersMapping\",\"type\":\"uint256[]\"}],\"name\":\"setAllTokenTierMappings\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"baseLoanSize\",\"type\":\"uint256\"},{\"internalType\":\"string[]\",\"name\":\"hashes\",\"type\":\"string[]\"},{\"internalType\":\"address\",\"name\":\"contributionAsset\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"contributionSize\",\"type\":\"uint256\"},{\"internalType\":\"uint8\",\"name\":\"contributionMultiplier\",\"type\":\"uint8\"}],\"internalType\":\"struct TellerNFTDictionary.Tier\",\"name\":\"newTier\",\"type\":\"tuple\"}],\"name\":\"setTier\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"tokenTier\",\"type\":\"uint256\"}],\"name\":\"setTokenTierForTokenId\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256[]\",\"name\":\"tokenIds\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256\",\"name\":\"tokenTier\",\"type\":\"uint256\"}],\"name\":\"setTokenTierForTokenIds\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"tierMapping\",\"type\":\"uint256\"}],\"name\":\"setTokenTierMapping\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"tokenBaseLoanSize\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"tokenContributionAsset\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"tokenContributionMultiplier\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"tokenContributionSize\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"tokenURIHash\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"develop@teller.finance\",\"kind\":\"dev\",\"methods\":{\"getRoleAdmin(bytes32)\":{\"details\":\"Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}.\"},\"getTokenTierIndex(uint256)\":{\"params\":{\"tokenId\":\"ID of the token to get Tier info.\"}},\"grantRole(bytes32,address)\":{\"details\":\"Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role.\"},\"hasRole(bytes32,address)\":{\"details\":\"Returns `true` if `account` has been granted `role`.\"},\"renounceRole(bytes32,address)\":{\"details\":\"Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `account`.\"},\"revokeRole(bytes32,address)\":{\"details\":\"Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role.\"},\"setAllTokenTierMappings(uint256[])\":{\"params\":{\"tiersMapping\":\"Information about the new tiers to add. Requirements: - Caller must have the {Admin} role\"}},\"setTier(uint256,(uint256,string[],address,uint256,uint8))\":{\"details\":\"It auto increments the index of the next tier to add.\",\"params\":{\"newTier\":\"Information about the new tier to add. Requirements: - Caller must have the {Admin} role\"}},\"setTokenTierForTokenId(uint256,uint256)\":{\"params\":{\"tokenId\":\"the NFT token Id for which to add data\",\"tokenTier\":\"the index of the tier that these tokenIds should have Requirements: - Caller must have the {Admin} role\"}},\"setTokenTierForTokenIds(uint256[],uint256)\":{\"params\":{\"tokenIds\":\"the NFT token Ids for which to add data\",\"tokenTier\":\"the index of the tier that these tokenIds should have Requirements: - Caller must have the {Admin} role\"}},\"setTokenTierMapping(uint256,uint256)\":{\"params\":{\"index\":\"the mapping row, each holds data for 32 tokens\",\"tierMapping\":\"Information about the new tier to add. Requirements: - Caller must have the {Admin} role\"}},\"supportsInterface(bytes4)\":{\"details\":\"See {IERC165-supportsInterface}.\"},\"tokenBaseLoanSize(uint256)\":{\"params\":{\"tokenId\":\"ID of the token to get info.\"}},\"tokenContributionAsset(uint256)\":{\"params\":{\"tokenId\":\"ID of the token to get info.\"}},\"tokenContributionMultiplier(uint256)\":{\"params\":{\"tokenId\":\"ID of the token to get info.\"}},\"tokenContributionSize(uint256)\":{\"params\":{\"tokenId\":\"ID of the token to get info.\"}},\"tokenURIHash(uint256)\":{\"params\":{\"tokenId\":\"ID of the token to get info.\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"getTokenTierIndex(uint256)\":{\"notice\":\"It returns information about a Tier for a token ID.\"},\"setAllTokenTierMappings(uint256[])\":{\"notice\":\"Sets the tiers for each tokenId using compressed data.\"},\"setTier(uint256,(uint256,string[],address,uint256,uint8))\":{\"notice\":\"Adds a new Tier to be minted with the given information.\"},\"setTokenTierForTokenId(uint256,uint256)\":{\"notice\":\"Sets a specific tier for a specific tokenId using compressed data.\"},\"setTokenTierForTokenIds(uint256[],uint256)\":{\"notice\":\"Sets a specific tier for a specific tokenId using compressed data.\"},\"setTokenTierMapping(uint256,uint256)\":{\"notice\":\"Sets the tiers for each tokenId using compressed data.\"},\"tokenBaseLoanSize(uint256)\":{\"notice\":\"It returns Base Loan Size for a token ID.\"},\"tokenContributionAsset(uint256)\":{\"notice\":\"It returns Contribution Asset for a token ID.\"},\"tokenContributionMultiplier(uint256)\":{\"notice\":\"It returns Contribution Multiplier for a token ID.\"},\"tokenContributionSize(uint256)\":{\"notice\":\"It returns Contribution Size for a token ID.\"},\"tokenURIHash(uint256)\":{\"notice\":\"It returns Token URI Hash for a token ID.\"}},\"notice\":\"This contract is used by borrowers to call Dapp functions (using delegate calls).This contract should only be constructed using it's upgradeable Proxy contract.In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/nft/TellerNFTDictionary.sol\":\"TellerNFTDictionary\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"contracts/nft/IStakeableNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IStakeableNFT {\\n function tokenBaseLoanSize(uint256 tokenId) external view returns (uint256);\\n\\n function tokenURIHash(uint256 tokenId)\\n external\\n view\\n returns (string memory);\\n\\n function tokenContributionAsset(uint256 tokenId)\\n external\\n view\\n returns (address);\\n\\n function tokenContributionSize(uint256 tokenId)\\n external\\n view\\n returns (uint256);\\n\\n function tokenContributionMultiplier(uint256 tokenId)\\n external\\n view\\n returns (uint8);\\n}\\n\",\"keccak256\":\"0xfbf44350ad91a54de26f39195d714580d7dade556ea4c7991a51eef5aa839105\",\"license\":\"MIT\"},\"contracts/nft/TellerNFTDictionary.sol\":{\"content\":\"/**\\n * @notice TellerNFTDictionary Version 1.02\\n *\\n * @notice This contract is used to gather data for TellerV1 NFTs more efficiently.\\n * @notice This contract has data which must be continuously synchronized with the TellerV1 NFT data\\n *\\n * @author develop@teller.finance\\n */\\n\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Interfaces\\nimport \\\"./IStakeableNFT.sol\\\";\\n\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFTDictionary is IStakeableNFT, AccessControlUpgradeable {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n mapping(uint256 => uint256) public baseLoanSizes;\\n mapping(uint256 => string[]) public hashes;\\n mapping(uint256 => address) public contributionAssets;\\n mapping(uint256 => uint256) public contributionSizes;\\n mapping(uint256 => uint8) public contributionMultipliers;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n\\n /* State Variables */\\n\\n mapping(uint256 => uint256) public _tokenTierMappingCompressed;\\n bool public _tokenTierMappingCompressedSet;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFTDictionary: not admin\\\");\\n _;\\n }\\n\\n function initialize(address initialAdmin) public {\\n _setupRole(ADMIN, initialAdmin);\\n _setRoleAdmin(ADMIN, ADMIN);\\n\\n __AccessControl_init();\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTierIndex(uint256 tokenId)\\n public\\n view\\n returns (uint8 index_)\\n {\\n //32 * 8 = 256 - each uint256 holds the data of 32 tokens . 8 bits each.\\n\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 compressedRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n //use 31 instead of 32 to account for the '0x' in the start.\\n //the '31 -' reverses our bytes order which is necessary\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint8 tierIndex = uint8((compressedRegister >> offset));\\n\\n return tierIndex;\\n }\\n\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory)\\n {\\n return hashes[tierIndex];\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTier(uint256 index, Tier memory newTier)\\n external\\n onlyAdmin\\n returns (bool)\\n {\\n baseLoanSizes[index] = newTier.baseLoanSize;\\n hashes[index] = newTier.hashes;\\n contributionAssets[index] = newTier.contributionAsset;\\n contributionSizes[index] = newTier.contributionSize;\\n contributionMultipliers[index] = newTier.contributionMultiplier;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param tiersMapping Information about the new tiers to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setAllTokenTierMappings(uint256[] memory tiersMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n require(\\n !_tokenTierMappingCompressedSet,\\n \\\"TellerNFTDictionary: token tier mapping already set\\\"\\n );\\n for (uint256 i = 0; i < tiersMapping.length; i++) {\\n _tokenTierMappingCompressed[i] = tiersMapping[i];\\n }\\n\\n _tokenTierMappingCompressedSet = true;\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param index the mapping row, each holds data for 32 tokens\\n * @param tierMapping Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierMapping(uint256 index, uint256 tierMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n _tokenTierMappingCompressed[index] = tierMapping;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenIds the NFT token Ids for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenIds(\\n uint256[] calldata tokenIds,\\n uint256 tokenTier\\n ) public onlyAdmin returns (bool) {\\n for (uint256 i; i < tokenIds.length; i++) {\\n setTokenTierForTokenId(tokenIds[i], tokenTier);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenId the NFT token Id for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenId(uint256 tokenId, uint256 tokenTier)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 existingRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint256 updateMaskShifted =\\n 0x00000000000000000000000000000000000000000000000000000000000000FF <<\\n offset;\\n\\n uint256 updateMaskShiftedNegated = ~updateMaskShifted;\\n\\n uint256 tokenTierShifted =\\n ((0x0000000000000000000000000000000000000000000000000000000000000000 |\\n tokenTier) << offset);\\n\\n uint256 existingRegisterClearedWithMask =\\n existingRegister & updateMaskShiftedNegated;\\n\\n uint256 updatedRegister =\\n existingRegisterClearedWithMask | tokenTierShifted;\\n\\n _tokenTierMappingCompressed[mappingIndex] = updatedRegister;\\n\\n return true;\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(IStakeableNFT).interfaceId ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n New methods for the dictionary\\n */\\n\\n /**\\n * @notice It returns Base Loan Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenBaseLoanSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return baseLoanSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Token URI Hash for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenURIHash(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n string[] memory tierImageHashes = hashes[tokenTier];\\n return tierImageHashes[tokenId % (tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice It returns Contribution Asset for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionAsset(uint256 tokenId)\\n public\\n view\\n override\\n returns (address)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionAssets[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Multiplier for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionMultiplier(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint8)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionMultipliers[tokenTier];\\n }\\n}\\n\",\"keccak256\":\"0xf33e3fa1f609fdd2abb3b5fb9c232269d13363a3e4fa5697ea96269e361e74fa\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "author": "develop@teller.finance", + "kind": "dev", + "methods": { + "getRoleAdmin(bytes32)": { + "details": "Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}." + }, + "getTokenTierIndex(uint256)": { + "params": { + "tokenId": "ID of the token to get Tier info." + } + }, + "grantRole(bytes32,address)": { + "details": "Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role." + }, + "hasRole(bytes32,address)": { + "details": "Returns `true` if `account` has been granted `role`." + }, + "renounceRole(bytes32,address)": { + "details": "Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `account`." + }, + "revokeRole(bytes32,address)": { + "details": "Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role." + }, + "setAllTokenTierMappings(uint256[])": { + "params": { + "tiersMapping": "Information about the new tiers to add. Requirements: - Caller must have the {Admin} role" + } + }, + "setTier(uint256,(uint256,string[],address,uint256,uint8))": { + "details": "It auto increments the index of the next tier to add.", + "params": { + "newTier": "Information about the new tier to add. Requirements: - Caller must have the {Admin} role" + } + }, + "setTokenTierForTokenId(uint256,uint256)": { + "params": { + "tokenId": "the NFT token Id for which to add data", + "tokenTier": "the index of the tier that these tokenIds should have Requirements: - Caller must have the {Admin} role" + } + }, + "setTokenTierForTokenIds(uint256[],uint256)": { + "params": { + "tokenIds": "the NFT token Ids for which to add data", + "tokenTier": "the index of the tier that these tokenIds should have Requirements: - Caller must have the {Admin} role" + } + }, + "setTokenTierMapping(uint256,uint256)": { + "params": { + "index": "the mapping row, each holds data for 32 tokens", + "tierMapping": "Information about the new tier to add. Requirements: - Caller must have the {Admin} role" + } + }, + "supportsInterface(bytes4)": { + "details": "See {IERC165-supportsInterface}." + }, + "tokenBaseLoanSize(uint256)": { + "params": { + "tokenId": "ID of the token to get info." + } + }, + "tokenContributionAsset(uint256)": { + "params": { + "tokenId": "ID of the token to get info." + } + }, + "tokenContributionMultiplier(uint256)": { + "params": { + "tokenId": "ID of the token to get info." + } + }, + "tokenContributionSize(uint256)": { + "params": { + "tokenId": "ID of the token to get info." + } + }, + "tokenURIHash(uint256)": { + "params": { + "tokenId": "ID of the token to get info." + } + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "getTokenTierIndex(uint256)": { + "notice": "It returns information about a Tier for a token ID." + }, + "setAllTokenTierMappings(uint256[])": { + "notice": "Sets the tiers for each tokenId using compressed data." + }, + "setTier(uint256,(uint256,string[],address,uint256,uint8))": { + "notice": "Adds a new Tier to be minted with the given information." + }, + "setTokenTierForTokenId(uint256,uint256)": { + "notice": "Sets a specific tier for a specific tokenId using compressed data." + }, + "setTokenTierForTokenIds(uint256[],uint256)": { + "notice": "Sets a specific tier for a specific tokenId using compressed data." + }, + "setTokenTierMapping(uint256,uint256)": { + "notice": "Sets the tiers for each tokenId using compressed data." + }, + "tokenBaseLoanSize(uint256)": { + "notice": "It returns Base Loan Size for a token ID." + }, + "tokenContributionAsset(uint256)": { + "notice": "It returns Contribution Asset for a token ID." + }, + "tokenContributionMultiplier(uint256)": { + "notice": "It returns Contribution Multiplier for a token ID." + }, + "tokenContributionSize(uint256)": { + "notice": "It returns Contribution Size for a token ID." + }, + "tokenURIHash(uint256)": { + "notice": "It returns Token URI Hash for a token ID." + } + }, + "notice": "This contract is used by borrowers to call Dapp functions (using delegate calls).This contract should only be constructed using it's upgradeable Proxy contract.In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.", + "version": 1 + }, + "storageLayout": { + "storage": [ + { + "astId": 635, + "contract": "contracts/nft/TellerNFTDictionary.sol:TellerNFTDictionary", + "label": "_initialized", + "offset": 0, + "slot": "0", + "type": "t_bool" + }, + { + "astId": 638, + "contract": "contracts/nft/TellerNFTDictionary.sol:TellerNFTDictionary", + "label": "_initializing", + "offset": 1, + "slot": "0", + "type": "t_bool" + }, + { + "astId": 2833, + "contract": "contracts/nft/TellerNFTDictionary.sol:TellerNFTDictionary", + "label": "__gap", + "offset": 0, + "slot": "1", + "type": "t_array(t_uint256)50_storage" + }, + { + "astId": 3082, + "contract": "contracts/nft/TellerNFTDictionary.sol:TellerNFTDictionary", + "label": "__gap", + "offset": 0, + "slot": "51", + "type": "t_array(t_uint256)50_storage" + }, + { + "astId": 189, + "contract": "contracts/nft/TellerNFTDictionary.sol:TellerNFTDictionary", + "label": "_roles", + "offset": 0, + "slot": "101", + "type": "t_mapping(t_bytes32,t_struct(RoleData)184_storage)" + }, + { + "astId": 497, + "contract": "contracts/nft/TellerNFTDictionary.sol:TellerNFTDictionary", + "label": "__gap", + "offset": 0, + "slot": "102", + "type": "t_array(t_uint256)49_storage" + }, + { + "astId": 17688, + "contract": "contracts/nft/TellerNFTDictionary.sol:TellerNFTDictionary", + "label": "baseLoanSizes", + "offset": 0, + "slot": "151", + "type": "t_mapping(t_uint256,t_uint256)" + }, + { + "astId": 17693, + "contract": "contracts/nft/TellerNFTDictionary.sol:TellerNFTDictionary", + "label": "hashes", + "offset": 0, + "slot": "152", + "type": "t_mapping(t_uint256,t_array(t_string_storage)dyn_storage)" + }, + { + "astId": 17697, + "contract": "contracts/nft/TellerNFTDictionary.sol:TellerNFTDictionary", + "label": "contributionAssets", + "offset": 0, + "slot": "153", + "type": "t_mapping(t_uint256,t_address)" + }, + { + "astId": 17701, + "contract": "contracts/nft/TellerNFTDictionary.sol:TellerNFTDictionary", + "label": "contributionSizes", + "offset": 0, + "slot": "154", + "type": "t_mapping(t_uint256,t_uint256)" + }, + { + "astId": 17705, + "contract": "contracts/nft/TellerNFTDictionary.sol:TellerNFTDictionary", + "label": "contributionMultipliers", + "offset": 0, + "slot": "155", + "type": "t_mapping(t_uint256,t_uint8)" + }, + { + "astId": 17714, + "contract": "contracts/nft/TellerNFTDictionary.sol:TellerNFTDictionary", + "label": "_tokenTierMappingCompressed", + "offset": 0, + "slot": "156", + "type": "t_mapping(t_uint256,t_uint256)" + }, + { + "astId": 17716, + "contract": "contracts/nft/TellerNFTDictionary.sol:TellerNFTDictionary", + "label": "_tokenTierMappingCompressedSet", + "offset": 0, + "slot": "157", + "type": "t_bool" + } + ], + "types": { + "t_address": { + "encoding": "inplace", + "label": "address", + "numberOfBytes": "20" + }, + "t_array(t_string_storage)dyn_storage": { + "base": "t_string_storage", + "encoding": "dynamic_array", + "label": "string[]", + "numberOfBytes": "32" + }, + "t_array(t_uint256)49_storage": { + "base": "t_uint256", + "encoding": "inplace", + "label": "uint256[49]", + "numberOfBytes": "1568" + }, + "t_array(t_uint256)50_storage": { + "base": "t_uint256", + "encoding": "inplace", + "label": "uint256[50]", + "numberOfBytes": "1600" + }, + "t_bool": { + "encoding": "inplace", + "label": "bool", + "numberOfBytes": "1" + }, + "t_bytes32": { + "encoding": "inplace", + "label": "bytes32", + "numberOfBytes": "32" + }, + "t_mapping(t_address,t_bool)": { + "encoding": "mapping", + "key": "t_address", + "label": "mapping(address => bool)", + "numberOfBytes": "32", + "value": "t_bool" + }, + "t_mapping(t_bytes32,t_struct(RoleData)184_storage)": { + "encoding": "mapping", + "key": "t_bytes32", + "label": "mapping(bytes32 => struct AccessControlUpgradeable.RoleData)", + "numberOfBytes": "32", + "value": "t_struct(RoleData)184_storage" + }, + "t_mapping(t_uint256,t_address)": { + "encoding": "mapping", + "key": "t_uint256", + "label": "mapping(uint256 => address)", + "numberOfBytes": "32", + "value": "t_address" + }, + "t_mapping(t_uint256,t_array(t_string_storage)dyn_storage)": { + "encoding": "mapping", + "key": "t_uint256", + "label": "mapping(uint256 => string[])", + "numberOfBytes": "32", + "value": "t_array(t_string_storage)dyn_storage" + }, + "t_mapping(t_uint256,t_uint256)": { + "encoding": "mapping", + "key": "t_uint256", + "label": "mapping(uint256 => uint256)", + "numberOfBytes": "32", + "value": "t_uint256" + }, + "t_mapping(t_uint256,t_uint8)": { + "encoding": "mapping", + "key": "t_uint256", + "label": "mapping(uint256 => uint8)", + "numberOfBytes": "32", + "value": "t_uint8" + }, + "t_string_storage": { + "encoding": "bytes", + "label": "string", + "numberOfBytes": "32" + }, + "t_struct(RoleData)184_storage": { + "encoding": "inplace", + "label": "struct AccessControlUpgradeable.RoleData", + "members": [ + { + "astId": 181, + "contract": "contracts/nft/TellerNFTDictionary.sol:TellerNFTDictionary", + "label": "members", + "offset": 0, + "slot": "0", + "type": "t_mapping(t_address,t_bool)" + }, + { + "astId": 183, + "contract": "contracts/nft/TellerNFTDictionary.sol:TellerNFTDictionary", + "label": "adminRole", + "offset": 0, + "slot": "1", + "type": "t_bytes32" + } + ], + "numberOfBytes": "64" + }, + "t_uint256": { + "encoding": "inplace", + "label": "uint256", + "numberOfBytes": "32" + }, + "t_uint8": { + "encoding": "inplace", + "label": "uint8", + "numberOfBytes": "1" + } + } + } +} diff --git a/deployments/polygon_mumbai/TellerNFTDictionary_Proxy.json b/deployments/polygon_mumbai/TellerNFTDictionary_Proxy.json new file mode 100644 index 000000000..0047f824b --- /dev/null +++ b/deployments/polygon_mumbai/TellerNFTDictionary_Proxy.json @@ -0,0 +1,252 @@ +{ + "address": "0x60FD8B742dFc3f9c51C436EE15a1341886199791", + "abi": [ + { + "inputs": [ + { + "internalType": "address", + "name": "initialLogic", + "type": "address" + }, + { + "internalType": "address", + "name": "initialAdmin", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_data", + "type": "bytes" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "previousAdmin", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "newAdmin", + "type": "address" + } + ], + "name": "AdminChanged", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "implementation", + "type": "address" + } + ], + "name": "Upgraded", + "type": "event" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "inputs": [], + "name": "admin", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newAdmin", + "type": "address" + } + ], + "name": "changeAdmin", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "implementation", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newImplementation", + "type": "address" + } + ], + "name": "upgradeTo", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newImplementation", + "type": "address" + }, + { + "internalType": "bytes", + "name": "data", + "type": "bytes" + } + ], + "name": "upgradeToAndCall", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "stateMutability": "payable", + "type": "receive" + } + ], + "artifactName": "TransparentUpgradeableProxy", + "transactionHash": "0x2f22784480ac0812613e8db32dd3a9c7dc8b8c2bbbfe9cb7078621630f679f57", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x60FD8B742dFc3f9c51C436EE15a1341886199791", + "transactionIndex": 0, + "gasUsed": "618768", + "logsBloom": "0x00000004000000000800000000008000080000000000000000000000000000200000000000000000000000000000000000008000002000000000000000000000000000000000000000000000000000800100000000000000040100000000000000000000020000400000008000000800000000000000000080000000000000000000000000000000000000000000000000000000000000000001000000000000200000000000000000000000100000000000000000000000001040000000004000000000000100000001000000000000000000000000000100100000000020000000004000000000200000000000000000000000000000000000000000100000", + "blockHash": "0xab87008fd5d48c159b57510d4df816e78a94ca40cd83affdadedb7f29dbe68b1", + "transactionHash": "0x2f22784480ac0812613e8db32dd3a9c7dc8b8c2bbbfe9cb7078621630f679f57", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692289, + "transactionHash": "0x2f22784480ac0812613e8db32dd3a9c7dc8b8c2bbbfe9cb7078621630f679f57", + "address": "0x60FD8B742dFc3f9c51C436EE15a1341886199791", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 0, + "blockHash": "0xab87008fd5d48c159b57510d4df816e78a94ca40cd83affdadedb7f29dbe68b1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692289, + "transactionHash": "0x2f22784480ac0812613e8db32dd3a9c7dc8b8c2bbbfe9cb7078621630f679f57", + "address": "0x60FD8B742dFc3f9c51C436EE15a1341886199791", + "topics": [ + "0xbd79b86ffe0ab8e8776151514217cd7cacd52c909f66475c3af44e129f0b00ff", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0xab87008fd5d48c159b57510d4df816e78a94ca40cd83affdadedb7f29dbe68b1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692289, + "transactionHash": "0x2f22784480ac0812613e8db32dd3a9c7dc8b8c2bbbfe9cb7078621630f679f57", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000c275dc8be39f50d12f66b6a63629c39da5bae5bd" + ], + "data": "0x0000000000000000000000000000000000000000000000000041f2fc8d26c00000000000000000000000000000000000000000000000000050bfdacfe3befc000000000000000000000000000000000000000000000000b4070a69863f8505d5000000000000000000000000000000000000000000000000507de7d356983c000000000000000000000000000000000000000000000000b4074c5c82ccabc5d5", + "logIndex": 2, + "blockHash": "0xab87008fd5d48c159b57510d4df816e78a94ca40cd83affdadedb7f29dbe68b1" + } + ], + "blockNumber": 15692289, + "cumulativeGasUsed": "618768", + "status": 1, + "byzantium": true + }, + "args": [ + "0x629812CEfd43A00D34101F9A218d518b11B0bd1F", + "0x40d6Cab1722fF9A0C5bBf5Fb00141C427039fE4a", + "0xc4d66de8000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "solcInputHash": "1635d55d57a0a2552952c0d22586ed23", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initialLogic\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"initialAdmin\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"inputs\":[],\"name\":\"admin\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"changeAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"implementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"details\":\"This contract implements a proxy that is upgradeable by an admin. To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector clashing], which can potentially be used in an attack, this contract uses the https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two things that go hand in hand: 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if that call matches one of the admin functions exposed by the proxy itself. 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the implementation. If the admin tries to call a function on the implementation it will fail with an error that says \\\"admin cannot fallback to proxy target\\\". These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due to sudden errors when trying to call a function from the proxy implementation. Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way, you should think of the `ProxyAdmin` instance as the real administrative inerface of your proxy.\",\"events\":{\"AdminChanged(address,address)\":{\"details\":\"Emitted when the admin account has changed.\"}},\"kind\":\"dev\",\"methods\":{\"admin()\":{\"details\":\"Returns the current admin. NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}. TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call. `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`\"},\"changeAdmin(address)\":{\"details\":\"Changes the admin of the proxy. Emits an {AdminChanged} event. NOTE: Only the admin can call this function. See {ProxyAdmin-changeProxyAdmin}.\"},\"constructor\":{\"details\":\"Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and optionally initialized with `_data` as explained in {UpgradeableProxy-constructor}.\"},\"implementation()\":{\"details\":\"Returns the current implementation. NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}. TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call. `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`\"},\"upgradeTo(address)\":{\"details\":\"Upgrade the implementation of the proxy. NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}.\"},\"upgradeToAndCall(address,bytes)\":{\"details\":\"Upgrade the implementation of the proxy, and then call a function from the new implementation as specified by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the proxied contract. NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}.\"}},\"stateVariables\":{\"_ADMIN_SLOT\":{\"details\":\"Storage slot with the admin of the contract. This is the keccak-256 hash of \\\"eip1967.proxy.admin\\\" subtracted by 1, and is validated in the constructor.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/openzeppelin/proxy/TransparentUpgradeableProxy.sol\":\"TransparentUpgradeableProxy\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/openzeppelin/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.7.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n * \\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n * \\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n * \\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal {\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 { revert(0, returndatasize()) }\\n default { return(0, returndatasize()) }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal virtual view returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n * \\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback () payable external {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive () payable external {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n * \\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {\\n }\\n}\\n\",\"keccak256\":\"0xc33f9858a67e34c77831163d5611d21fc627dfd2c303806a98a6c9db5a01b034\",\"license\":\"MIT\"},\"solc_0.7/openzeppelin/proxy/TransparentUpgradeableProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.7.0;\\n\\nimport \\\"./UpgradeableProxy.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that is upgradeable by an admin.\\n * \\n * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector\\n * clashing], which can potentially be used in an attack, this contract uses the\\n * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two\\n * things that go hand in hand:\\n * \\n * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if\\n * that call matches one of the admin functions exposed by the proxy itself.\\n * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the\\n * implementation. If the admin tries to call a function on the implementation it will fail with an error that says\\n * \\\"admin cannot fallback to proxy target\\\".\\n * \\n * These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing\\n * the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due\\n * to sudden errors when trying to call a function from the proxy implementation.\\n * \\n * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way,\\n * you should think of the `ProxyAdmin` instance as the real administrative inerface of your proxy.\\n */\\ncontract TransparentUpgradeableProxy is UpgradeableProxy {\\n /**\\n * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and\\n * optionally initialized with `_data` as explained in {UpgradeableProxy-constructor}.\\n */\\n constructor(address initialLogic, address initialAdmin, bytes memory _data) payable UpgradeableProxy(initialLogic, _data) {\\n assert(_ADMIN_SLOT == bytes32(uint256(keccak256(\\\"eip1967.proxy.admin\\\")) - 1));\\n _setAdmin(initialAdmin);\\n }\\n\\n /**\\n * @dev Emitted when the admin account has changed.\\n */\\n event AdminChanged(address previousAdmin, address newAdmin);\\n\\n /**\\n * @dev Storage slot with the admin of the contract.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.admin\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 private constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\\n\\n /**\\n * @dev Modifier used internally that will delegate the call to the implementation unless the sender is the admin.\\n */\\n modifier ifAdmin() {\\n if (msg.sender == _admin()) {\\n _;\\n } else {\\n _fallback();\\n }\\n }\\n\\n /**\\n * @dev Returns the current admin.\\n * \\n * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}.\\n * \\n * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the\\n * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\\n * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`\\n */\\n function admin() external ifAdmin returns (address) {\\n return _admin();\\n }\\n\\n /**\\n * @dev Returns the current implementation.\\n * \\n * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}.\\n * \\n * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the\\n * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\\n * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`\\n */\\n function implementation() external ifAdmin returns (address) {\\n return _implementation();\\n }\\n\\n /**\\n * @dev Changes the admin of the proxy.\\n * \\n * Emits an {AdminChanged} event.\\n * \\n * NOTE: Only the admin can call this function. See {ProxyAdmin-changeProxyAdmin}.\\n */\\n function changeAdmin(address newAdmin) external ifAdmin {\\n require(newAdmin != address(0), \\\"TransparentUpgradeableProxy: new admin is the zero address\\\");\\n emit AdminChanged(_admin(), newAdmin);\\n _setAdmin(newAdmin);\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy.\\n * \\n * NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}.\\n */\\n function upgradeTo(address newImplementation) external ifAdmin {\\n _upgradeTo(newImplementation);\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified\\n * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the\\n * proxied contract.\\n * \\n * NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}.\\n */\\n function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {\\n _upgradeTo(newImplementation);\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success,) = newImplementation.delegatecall(data);\\n require(success);\\n }\\n\\n /**\\n * @dev Returns the current admin.\\n */\\n function _admin() internal view returns (address adm) {\\n bytes32 slot = _ADMIN_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n adm := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 admin slot.\\n */\\n function _setAdmin(address newAdmin) private {\\n bytes32 slot = _ADMIN_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, newAdmin)\\n }\\n }\\n\\n /**\\n * @dev Makes sure the admin cannot access the fallback function. See {Proxy-_beforeFallback}.\\n */\\n function _beforeFallback() internal override virtual {\\n require(msg.sender != _admin(), \\\"TransparentUpgradeableProxy: admin cannot fallback to proxy target\\\");\\n super._beforeFallback();\\n }\\n}\\n\",\"keccak256\":\"0xd6cecbe00dc78355aff1a16d83487bb73c54701004d61a2e48cdb81e2bcacc26\",\"license\":\"MIT\"},\"solc_0.7/openzeppelin/proxy/UpgradeableProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.7.0;\\n\\nimport \\\"./Proxy.sol\\\";\\nimport \\\"../utils/Address.sol\\\";\\n\\n/**\\n * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an\\n * implementation address that can be changed. This address is stored in storage in the location specified by\\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the\\n * implementation behind the proxy.\\n * \\n * Upgradeability is only provided internally through {_upgradeTo}. For an externally upgradeable proxy see\\n * {TransparentUpgradeableProxy}.\\n */\\ncontract UpgradeableProxy is Proxy {\\n /**\\n * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.\\n * \\n * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded\\n * function call, and allows initializating the storage of the proxy like a Solidity constructor.\\n */\\n constructor(address _logic, bytes memory _data) payable {\\n assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256(\\\"eip1967.proxy.implementation\\\")) - 1));\\n _setImplementation(_logic);\\n if(_data.length > 0) {\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success,) = _logic.delegatecall(_data);\\n require(success);\\n }\\n }\\n\\n /**\\n * @dev Emitted when the implementation is upgraded.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Storage slot with the address of the current implementation.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.implementation\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 private constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function _implementation() internal override view returns (address impl) {\\n bytes32 slot = _IMPLEMENTATION_SLOT;\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n impl := sload(slot)\\n }\\n }\\n\\n /**\\n * @dev Upgrades the proxy to a new implementation.\\n * \\n * Emits an {Upgraded} event.\\n */\\n function _upgradeTo(address newImplementation) internal {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 implementation slot.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(Address.isContract(newImplementation), \\\"UpgradeableProxy: new implementation is not a contract\\\");\\n\\n bytes32 slot = _IMPLEMENTATION_SLOT;\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n sstore(slot, newImplementation)\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd68f4c11941712db79a61b9dca81a5db663cfacec3d7bb19f8d2c23bb1ab8afe\",\"license\":\"MIT\"},\"solc_0.7/openzeppelin/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.7.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // According to EIP-1052, 0x0 is the value returned for not-yet created accounts\\n // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned\\n // for accounts without code, i.e. `keccak256('')`\\n bytes32 codehash;\\n bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { codehash := extcodehash(account) }\\n return (codehash != accountHash && codehash != 0x0);\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return _functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n return _functionCallWithValue(target, data, value, errorMessage);\\n }\\n\\n function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x698f929f1097637d051976b322a2d532c27df022b09010e8d091e2888a5ebdf8\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "0x6080604052604051610aaa380380610aaa8339818101604052606081101561002657600080fd5b8151602083015160408085018051915193959294830192918464010000000082111561005157600080fd5b90830190602082018581111561006657600080fd5b825164010000000081118282018810171561008057600080fd5b82525081516020918201929091019080838360005b838110156100ad578181015183820152602001610095565b50505050905090810190601f1680156100da5780820380516001836020036101000a031916815260200191505b50604052508491508290506100ee826101bf565b8051156101a6576000826001600160a01b0316826040518082805190602001908083835b602083106101315780518252601f199092019160209182019101610112565b6001836020036101000a038019825116818451168082178552505050505050905001915050600060405180830381855af49150503d8060008114610191576040519150601f19603f3d011682016040523d82523d6000602084013e610196565b606091505b50509050806101a457600080fd5b505b506101ae9050565b6101b782610231565b505050610291565b6101d28161025560201b6104bb1760201c565b61020d5760405162461bcd60e51b8152600401808060200182810382526036815260200180610a746036913960400191505060405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc55565b7fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d610355565b6000813f7fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47081811480159061028957508115155b949350505050565b6107d4806102a06000396000f3fe60806040526004361061005e5760003560e01c80635c60da1b116100435780635c60da1b146101425780638f28397014610180578063f851a440146101c05761006d565b80633659cfe6146100755780634f1ef286146100b55761006d565b3661006d5761006b6101d5565b005b61006b6101d5565b34801561008157600080fd5b5061006b6004803603602081101561009857600080fd5b503573ffffffffffffffffffffffffffffffffffffffff166101ef565b61006b600480360360408110156100cb57600080fd5b73ffffffffffffffffffffffffffffffffffffffff823516919081019060408101602082013564010000000081111561010357600080fd5b82018360208201111561011557600080fd5b8035906020019184600183028401116401000000008311171561013757600080fd5b509092509050610243565b34801561014e57600080fd5b50610157610317565b6040805173ffffffffffffffffffffffffffffffffffffffff9092168252519081900360200190f35b34801561018c57600080fd5b5061006b600480360360208110156101a357600080fd5b503573ffffffffffffffffffffffffffffffffffffffff1661036e565b3480156101cc57600080fd5b50610157610476565b6101dd6104f7565b6101ed6101e861058b565b6105b0565b565b6101f76105d4565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16141561023857610233816105f9565b610240565b6102406101d5565b50565b61024b6105d4565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16141561030a57610287836105f9565b60008373ffffffffffffffffffffffffffffffffffffffff1683836040518083838082843760405192019450600093509091505080830381855af49150503d80600081146102f1576040519150601f19603f3d011682016040523d82523d6000602084013e6102f6565b606091505b505090508061030457600080fd5b50610312565b6103126101d5565b505050565b60006103216105d4565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614156103635761035c61058b565b905061036b565b61036b6101d5565b90565b6103766105d4565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614156102385773ffffffffffffffffffffffffffffffffffffffff8116610415576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252603a8152602001806106ed603a913960400191505060405180910390fd5b7f7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f61043e6105d4565b6040805173ffffffffffffffffffffffffffffffffffffffff928316815291841660208301528051918290030190a161023381610646565b60006104806105d4565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614156103635761035c6105d4565b6000813f7fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a4708181148015906104ef57508115155b949350505050565b6104ff6105d4565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415610583576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252604281526020018061075d6042913960600191505060405180910390fd5b6101ed6101ed565b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc5490565b3660008037600080366000845af43d6000803e8080156105cf573d6000f35b3d6000fd5b7fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d61035490565b6106028161066a565b60405173ffffffffffffffffffffffffffffffffffffffff8216907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a250565b7fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d610355565b610673816104bb565b6106c8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260368152602001806107276036913960400191505060405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc5556fe5472616e73706172656e745570677261646561626c6550726f78793a206e65772061646d696e20697320746865207a65726f20616464726573735570677261646561626c6550726f78793a206e657720696d706c656d656e746174696f6e206973206e6f74206120636f6e74726163745472616e73706172656e745570677261646561626c6550726f78793a2061646d696e2063616e6e6f742066616c6c6261636b20746f2070726f787920746172676574a2646970667358221220b141ef72de179b8b56cef31601d40ff2875391088197e73cac39eba1ddcd0fdd64736f6c634300070600335570677261646561626c6550726f78793a206e657720696d706c656d656e746174696f6e206973206e6f74206120636f6e7472616374", + "deployedBytecode": "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", + "devdoc": { + "details": "This contract implements a proxy that is upgradeable by an admin. To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector clashing], which can potentially be used in an attack, this contract uses the https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two things that go hand in hand: 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if that call matches one of the admin functions exposed by the proxy itself. 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the implementation. If the admin tries to call a function on the implementation it will fail with an error that says \"admin cannot fallback to proxy target\". These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due to sudden errors when trying to call a function from the proxy implementation. Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way, you should think of the `ProxyAdmin` instance as the real administrative inerface of your proxy.", + "events": { + "AdminChanged(address,address)": { + "details": "Emitted when the admin account has changed." + } + }, + "kind": "dev", + "methods": { + "admin()": { + "details": "Returns the current admin. NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}. TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call. `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`" + }, + "changeAdmin(address)": { + "details": "Changes the admin of the proxy. Emits an {AdminChanged} event. NOTE: Only the admin can call this function. See {ProxyAdmin-changeProxyAdmin}." + }, + "constructor": { + "details": "Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and optionally initialized with `_data` as explained in {UpgradeableProxy-constructor}." + }, + "implementation()": { + "details": "Returns the current implementation. NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}. TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call. `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`" + }, + "upgradeTo(address)": { + "details": "Upgrade the implementation of the proxy. NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}." + }, + "upgradeToAndCall(address,bytes)": { + "details": "Upgrade the implementation of the proxy, and then call a function from the new implementation as specified by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the proxied contract. NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}." + } + }, + "stateVariables": { + "_ADMIN_SLOT": { + "details": "Storage slot with the admin of the contract. This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1, and is validated in the constructor." + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/TellerNFTDistributor.json b/deployments/polygon_mumbai/TellerNFTDistributor.json new file mode 100644 index 000000000..f6e780eae --- /dev/null +++ b/deployments/polygon_mumbai/TellerNFTDistributor.json @@ -0,0 +1,785 @@ +{ + "address": "0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "grantRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_nft", + "type": "address" + }, + { + "internalType": "address", + "name": "_dictionary", + "type": "address" + }, + { + "internalType": "address", + "name": "admin", + "type": "address" + } + ], + "name": "initialize", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "tierIndex", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "addMerkle", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "index", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "tierIndex", + "type": "uint256" + } + ], + "name": "moveMerkle", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "merkleIndex", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "nodeIndex", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "merkleProof", + "type": "bytes32[]" + } + ], + "internalType": "struct ClaimNFTRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "claim", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "dictionary", + "type": "address" + } + ], + "name": "setNFTDictionaryAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getMerkleRoots", + "outputs": [ + { + "components": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "tierIndex", + "type": "uint256" + } + ], + "internalType": "struct MerkleRoot[]", + "name": "roots_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "merkleIndex", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "nodeIndex", + "type": "uint256" + } + ], + "name": "isClaimed", + "outputs": [ + { + "internalType": "bool", + "name": "claimed_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "nft", + "outputs": [ + { + "internalType": "contract ITellerNFT", + "name": "nft_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "2717542", + "logsBloom": "0x00000004000000000000000000008010000000000000800000800000000000200000000000000000000000000010000000008000002000000000000000000000000000000000000000000000000000800101000001000000040900000000000000000000020000020000008000000800000000000000000080000000000000400020000000000000000000004000001000000000000000000000000000000000200000000000000000000000100000000000008000000000001040000000005000000000000100000001000000000000000000000020000100100000000020000000000000000800000000000000000000000000004000000000000000108000", + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1", + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000a1175721346e2fb8e9fc0b8ecd25e785db862b91", + "logIndex": 2, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000c275dc8be39f50d12f66b6a63629c39da5bae5bd" + ], + "data": "0x0000000000000000000000000000000000000000000000000121a3b3972a88000000000000000000000000000000000000000000000000004fd06bd36f32e0000000000000000000000000000000000000000000000000b40955915743a4e1d50000000000000000000000000000000000000000000000004eaec81fd80858000000000000000000000000000000000000000000000000b40a77350adacf69d5", + "logIndex": 6, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000a1175721346e2fb8e9fc0b8ecd25e785db862b91", + "logIndex": 2, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1", + "args": ["0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91"], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000c275dc8be39f50d12f66b6a63629c39da5bae5bd" + ], + "data": "0x0000000000000000000000000000000000000000000000000121a3b3972a88000000000000000000000000000000000000000000000000004fd06bd36f32e0000000000000000000000000000000000000000000000000b40955915743a4e1d50000000000000000000000000000000000000000000000004eaec81fd80858000000000000000000000000000000000000000000000000b40a77350adacf69d5", + "logIndex": 6, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + } + ], + "blockNumber": 15692311, + "cumulativeGasUsed": "2717542", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0xb72717Ad0e150399b47183AB0613b2098296b53c", + "functionSelectors": ["0x2f2ff15d", "0xc0c53b8b"], + "action": 0 + }, + { + "facetAddress": "0x2c06A917921eA2f1AB18AE7bb85A2d4Ef3E5BC50", + "functionSelectors": ["0x98fa2abf"], + "action": 0 + }, + { + "facetAddress": "0x32Cd9474007782d4EECDd320284E3a9851aE353f", + "functionSelectors": ["0x7b8f5697"], + "action": 0 + }, + { + "facetAddress": "0xe3a22D5FB394c9137993404aC01a1E6208694b90", + "functionSelectors": ["0x89e21733", "0xd9a6fc4a"], + "action": 0 + }, + { + "facetAddress": "0x3B6a45031041BAd9E3217D817Dccf92CD525Ad27", + "functionSelectors": ["0x85135a1a", "0xf364c90c", "0x47ccca02"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "facets": [ + { + "facetAddress": "0xb72717Ad0e150399b47183AB0613b2098296b53c", + "functionSelectors": ["0x2f2ff15d", "0xc0c53b8b"] + }, + { + "facetAddress": "0x2c06A917921eA2f1AB18AE7bb85A2d4Ef3E5BC50", + "functionSelectors": ["0x98fa2abf"] + }, + { + "facetAddress": "0x32Cd9474007782d4EECDd320284E3a9851aE353f", + "functionSelectors": ["0x7b8f5697"] + }, + { + "facetAddress": "0xe3a22D5FB394c9137993404aC01a1E6208694b90", + "functionSelectors": ["0x89e21733", "0xd9a6fc4a"] + }, + { + "facetAddress": "0x3B6a45031041BAd9E3217D817Dccf92CD525Ad27", + "functionSelectors": ["0x85135a1a", "0xf364c90c", "0x47ccca02"] + } + ], + "diamondCut": [ + { + "facetAddress": "0xb72717Ad0e150399b47183AB0613b2098296b53c", + "functionSelectors": ["0x2f2ff15d", "0xc0c53b8b"], + "action": 0 + }, + { + "facetAddress": "0x2c06A917921eA2f1AB18AE7bb85A2d4Ef3E5BC50", + "functionSelectors": ["0x98fa2abf"], + "action": 0 + }, + { + "facetAddress": "0x32Cd9474007782d4EECDd320284E3a9851aE353f", + "functionSelectors": ["0x7b8f5697"], + "action": 0 + }, + { + "facetAddress": "0xe3a22D5FB394c9137993404aC01a1E6208694b90", + "functionSelectors": ["0x89e21733", "0xd9a6fc4a"], + "action": 0 + }, + { + "facetAddress": "0x3B6a45031041BAd9E3217D817Dccf92CD525Ad27", + "functionSelectors": ["0x85135a1a", "0xf364c90c", "0x47ccca02"], + "action": 0 + } + ], + "execute": { + "methodName": "initialize", + "args": [ + "0xfd7f9D58340DC9849e46752314a6A85d24446bbF", + "0x60FD8B742dFc3f9c51C436EE15a1341886199791", + "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5" + ] + }, + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/TellerNFTDistributor_DiamondProxy.json b/deployments/polygon_mumbai/TellerNFTDistributor_DiamondProxy.json new file mode 100644 index 000000000..9e9d6fda2 --- /dev/null +++ b/deployments/polygon_mumbai/TellerNFTDistributor_DiamondProxy.json @@ -0,0 +1,536 @@ +{ + "address": "0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91", + "abi": [ + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "internalType": "struct Diamond.DiamondArgs", + "name": "_args", + "type": "tuple" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "stateMutability": "payable", + "type": "receive" + }, + { + "anonymous": false, + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "indexed": false, + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "DiamondCut", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "enum IDiamondCut.FacetCutAction", + "name": "action", + "type": "uint8" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondCut.FacetCut[]", + "name": "_diamondCut", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "_init", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_calldata", + "type": "bytes" + } + ], + "name": "diamondCut", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_functionSelector", + "type": "bytes4" + } + ], + "name": "facetAddress", + "outputs": [ + { + "internalType": "address", + "name": "facetAddress_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facetAddresses", + "outputs": [ + { + "internalType": "address[]", + "name": "facetAddresses_", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_facet", + "type": "address" + } + ], + "name": "facetFunctionSelectors", + "outputs": [ + { + "internalType": "bytes4[]", + "name": "facetFunctionSelectors_", + "type": "bytes4[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "facets", + "outputs": [ + { + "components": [ + { + "internalType": "address", + "name": "facetAddress", + "type": "address" + }, + { + "internalType": "bytes4[]", + "name": "functionSelectors", + "type": "bytes4[]" + } + ], + "internalType": "struct IDiamondLoupe.Facet[]", + "name": "facets_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "_interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "owner_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "Diamond", + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "receipt": { + "to": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": null, + "transactionIndex": 0, + "gasUsed": "2717542", + "logsBloom": "0x00000004000000000000000000008010000000000000800000800000000000200000000000000000000000000010000000008000002000000000000000000000000000000000000000000000000000800101000001000000040900000000000000000000020000020000008000000800000000000000000080000000000000400020000000000000000000004000001000000000000000000000000000000000200000000000000000000000100000000000008000000000001040000000005000000000000100000001000000000000000000000020000100100000000020000000000000000800000000000000000000000000004000000000000000108000", + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1", + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000a1175721346e2fb8e9fc0b8ecd25e785db862b91", + "logIndex": 2, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000c275dc8be39f50d12f66b6a63629c39da5bae5bd" + ], + "data": "0x0000000000000000000000000000000000000000000000000121a3b3972a88000000000000000000000000000000000000000000000000004fd06bd36f32e0000000000000000000000000000000000000000000000000b40955915743a4e1d50000000000000000000000000000000000000000000000004eaec81fd80858000000000000000000000000000000000000000000000000b40a77350adacf69d5", + "logIndex": 6, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + } + ], + "events": [ + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000022000000000000000000000000035d80a53f7be635f75152221d4d71cd4dcb07e5c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c00000000000000000000000000000000000000000000000000000000000000000000000000000000c1bbdf9f8c0b6ae0b4d35e9a778080b691a72a3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005adfca15e000000000000000000000000000000000000000000000000000000007a0ed62700000000000000000000000000000000000000000000000000000000cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c0000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000cfee10af6c7a91863c2bbdbcca3bcb5064a447be000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002f2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "logIndex": 0, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 1, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492", + "topics": [ + "0x644ca5b0a8b0418e9faf3880659eeb84eaad45ad838b0173808e5ca72f5efc49" + ], + "data": "0x000000000000000000000000a1175721346e2fb8e9fc0b8ecd25e785db862b91", + "logIndex": 2, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1", + "args": ["0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91"], + "event": "DiamondCreated", + "eventSignature": "DiamondCreated(address)" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91", + "topics": [ + "0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673" + ], + "data": "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", + "logIndex": 3, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91", + "topics": [ + "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", + "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492" + ], + "data": "0x", + "logIndex": 4, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0xA1175721346E2fb8e9Fc0b8eCD25e785DB862B91", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x000000000000000000000000b812f503607ee2259e9607cb5e5836b550ac6492", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5" + ], + "data": "0x", + "logIndex": 5, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + }, + { + "transactionIndex": 0, + "blockNumber": 15692311, + "transactionHash": "0xf1800755ec602affeeecc72bd44b01b8553acc2aa6ac17ab73913576a0ee47d7", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000c275dc8be39f50d12f66b6a63629c39da5bae5bd" + ], + "data": "0x0000000000000000000000000000000000000000000000000121a3b3972a88000000000000000000000000000000000000000000000000004fd06bd36f32e0000000000000000000000000000000000000000000000000b40955915743a4e1d50000000000000000000000000000000000000000000000004eaec81fd80858000000000000000000000000000000000000000000000000b40a77350adacf69d5", + "logIndex": 6, + "blockHash": "0x4a4f3e15de6ebaa81405dda4badc2c64e73b6ad62598d2683ef520ed406d6cc1" + } + ], + "blockNumber": 15692311, + "cumulativeGasUsed": "2717542", + "status": 1, + "byzantium": true + }, + "args": [ + [ + { + "facetAddress": "0xb72717Ad0e150399b47183AB0613b2098296b53c", + "functionSelectors": ["0x2f2ff15d", "0xc0c53b8b"], + "action": 0 + }, + { + "facetAddress": "0x2c06A917921eA2f1AB18AE7bb85A2d4Ef3E5BC50", + "functionSelectors": ["0x98fa2abf"], + "action": 0 + }, + { + "facetAddress": "0x32Cd9474007782d4EECDd320284E3a9851aE353f", + "functionSelectors": ["0x7b8f5697"], + "action": 0 + }, + { + "facetAddress": "0xe3a22D5FB394c9137993404aC01a1E6208694b90", + "functionSelectors": ["0x89e21733", "0xd9a6fc4a"], + "action": 0 + }, + { + "facetAddress": "0x3B6a45031041BAd9E3217D817Dccf92CD525Ad27", + "functionSelectors": ["0x85135a1a", "0xf364c90c", "0x47ccca02"], + "action": 0 + } + ], + { + "owner": "0xB812f503607Ee2259E9607Cb5E5836B550ac6492" + } + ], + "solcInputHash": "1d060b65b8264d57d416f20cb1fe798a", + "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"internalType\":\"struct Diamond.DiamondArgs\",\"name\":\"_args\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"solc_0.7/diamond/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":999999},\"remappings\":[]},\"sources\":{\"solc_0.7/diamond/Diamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n* \\n* Implementation of a diamond.\\n/******************************************************************************/\\n\\nimport \\\"./libraries/LibDiamond.sol\\\";\\nimport \\\"./interfaces/IDiamondLoupe.sol\\\";\\nimport \\\"./interfaces/IDiamondCut.sol\\\";\\nimport \\\"./interfaces/IERC173.sol\\\";\\nimport \\\"./interfaces/IERC165.sol\\\";\\n\\ncontract Diamond {\\n // more arguments are added to this struct\\n // this avoids stack too deep errors\\n struct DiamondArgs {\\n address owner;\\n }\\n\\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\\n LibDiamond.setContractOwner(_args.owner);\\n\\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\\n\\n // adding ERC165 data\\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\\n }\\n\\n // Find facet for function that is called and execute the\\n // function if a facet is found and return any value.\\n fallback() external payable {\\n LibDiamond.DiamondStorage storage ds;\\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\\n require(facet != address(0), \\\"Diamond: Function does not exist\\\");\\n assembly {\\n calldatacopy(0, 0, calldatasize())\\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\\n returndatacopy(0, 0, returndatasize())\\n switch result\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x968d41f1fbb08e012a0617f3a8b865c06f60d783e043b675280741b791216202\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\ninterface IDiamondCut {\\n enum FacetCutAction {Add, Replace, Remove}\\n // Add=0, Replace=1, Remove=2\\n\\n struct FacetCut {\\n address facetAddress;\\n FacetCutAction action;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Add/replace/remove any number of functions and optionally execute\\n /// a function with delegatecall\\n /// @param _diamondCut Contains the facet addresses and function selectors\\n /// @param _init The address of the contract or facet to execute _calldata\\n /// @param _calldata A function call, including function selector and arguments\\n /// _calldata is executed with delegatecall on _init\\n function diamondCut(\\n FacetCut[] calldata _diamondCut,\\n address _init,\\n bytes calldata _calldata\\n ) external;\\n\\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n}\\n\",\"keccak256\":\"0xfb3c1af58cd19e1e49f065e33c7c68045ce451c3e16920614979624c44faf892\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\n// A loupe is a small magnifying glass used to look at diamonds.\\n// These functions look at diamonds\\ninterface IDiamondLoupe {\\n /// These functions are expected to be called frequently\\n /// by tools.\\n\\n struct Facet {\\n address facetAddress;\\n bytes4[] functionSelectors;\\n }\\n\\n /// @notice Gets all facet addresses and their four byte function selectors.\\n /// @return facets_ Facet\\n function facets() external view returns (Facet[] memory facets_);\\n\\n /// @notice Gets all the function selectors supported by a specific facet.\\n /// @param _facet The facet address.\\n /// @return facetFunctionSelectors_\\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n /// @notice Get all the facet addresses used by a diamond.\\n /// @return facetAddresses_\\n function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n /// @notice Gets the facet that supports the given selector.\\n /// @dev If facet is not found return address(0).\\n /// @param _functionSelector The function selector.\\n /// @return facetAddress_ The facet address.\\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xf4bc76153335588e7cb5fe1c9701857fd2ae0340ad94976adbf1c49054f82dfe\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\ninterface IERC165 {\\n /// @notice Query if a contract implements an interface\\n /// @param interfaceId The interface identifier, as specified in ERC-165\\n /// @dev Interface identification is specified in ERC-165. This function\\n /// uses less than 30,000 gas.\\n /// @return `true` if the contract implements `interfaceID` and\\n /// `interfaceID` is not 0xffffffff, `false` otherwise\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe3ccc62939f8e880bdd4d5a34b05ccb9576810b8e999df6d16124e51019a0603\",\"license\":\"MIT\"},\"solc_0.7/diamond/interfaces/IERC173.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\n\\n/// @title ERC-173 Contract Ownership Standard\\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\\n/* is ERC165 */\\ninterface IERC173 {\\n /// @dev This emits when ownership of a contract changes.\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /// @notice Get the address of the owner\\n /// @return owner_ The address of the owner.\\n function owner() external view returns (address owner_);\\n\\n /// @notice Set the address of the new owner of the contract\\n /// @dev Set _newOwner to address(0) to renounce any ownership.\\n /// @param _newOwner The address of the new owner of the contract\\n function transferOwnership(address _newOwner) external;\\n}\\n\",\"keccak256\":\"0xa4023156092d7cb99c69e21bc95b910e13c54e582d6814601579bc2fb594ecf8\",\"license\":\"MIT\"},\"solc_0.7/diamond/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.7.6;\\npragma experimental ABIEncoderV2;\\n\\n/******************************************************************************\\\\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\\n/******************************************************************************/\\n\\nimport \\\"../interfaces/IDiamondCut.sol\\\";\\n\\nlibrary LibDiamond {\\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\\\"diamond.standard.diamond.storage\\\");\\n\\n struct FacetAddressAndPosition {\\n address facetAddress;\\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\\n }\\n\\n struct FacetFunctionSelectors {\\n bytes4[] functionSelectors;\\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\\n }\\n\\n struct DiamondStorage {\\n // maps function selector to the facet address and\\n // the position of the selector in the facetFunctionSelectors.selectors array\\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\\n // maps facet addresses to function selectors\\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\\n // facet addresses\\n address[] facetAddresses;\\n // Used to query if a contract implements an interface.\\n // Used to implement ERC-165.\\n mapping(bytes4 => bool) supportedInterfaces;\\n // owner of the contract\\n address contractOwner;\\n }\\n\\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n bytes32 position = DIAMOND_STORAGE_POSITION;\\n assembly {\\n ds.slot := position\\n }\\n }\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n function setContractOwner(address _newOwner) internal {\\n DiamondStorage storage ds = diamondStorage();\\n address previousOwner = ds.contractOwner;\\n ds.contractOwner = _newOwner;\\n emit OwnershipTransferred(previousOwner, _newOwner);\\n }\\n\\n function contractOwner() internal view returns (address contractOwner_) {\\n contractOwner_ = diamondStorage().contractOwner;\\n }\\n\\n function enforceIsContractOwner() internal view {\\n require(msg.sender == diamondStorage().contractOwner, \\\"LibDiamond: Must be contract owner\\\");\\n }\\n\\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n // Internal function version of diamondCut\\n function diamondCut(\\n IDiamondCut.FacetCut[] memory _diamondCut,\\n address _init,\\n bytes memory _calldata\\n ) internal {\\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\\n if (action == IDiamondCut.FacetCutAction.Add) {\\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\\n } else {\\n revert(\\\"LibDiamondCut: Incorrect FacetCutAction\\\");\\n }\\n }\\n emit DiamondCut(_diamondCut, _init, _calldata);\\n initializeDiamondCut(_init, _calldata);\\n }\\n\\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress == address(0), \\\"LibDiamondCut: Can't add function that already exists\\\");\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n selectorPosition++;\\n }\\n }\\n\\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Add facet can't be address(0)\\\");\\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\\n // add new facet address if it does not exist\\n if (selectorPosition == 0) {\\n enforceHasContractCode(_facetAddress, \\\"LibDiamondCut: New facet has no code\\\");\\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\\n ds.facetAddresses.push(_facetAddress);\\n }\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n require(oldFacetAddress != _facetAddress, \\\"LibDiamondCut: Can't replace function with same function\\\");\\n removeFunction(oldFacetAddress, selector);\\n // add function\\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\\n selectorPosition++;\\n }\\n }\\n\\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\\n require(_functionSelectors.length > 0, \\\"LibDiamondCut: No selectors in facet to cut\\\");\\n DiamondStorage storage ds = diamondStorage();\\n // if function does not exist then do nothing and return\\n require(_facetAddress == address(0), \\\"LibDiamondCut: Remove facet address must be address(0)\\\");\\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\\n bytes4 selector = _functionSelectors[selectorIndex];\\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\\n removeFunction(oldFacetAddress, selector);\\n }\\n }\\n\\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\\n DiamondStorage storage ds = diamondStorage();\\n require(_facetAddress != address(0), \\\"LibDiamondCut: Can't remove function that doesn't exist\\\");\\n // an immutable function is a function defined directly in a diamond\\n require(_facetAddress != address(this), \\\"LibDiamondCut: Can't remove immutable function\\\");\\n // replace selector with last selector, then delete last selector\\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\\n // if not the same then replace _selector with lastSelector\\n if (selectorPosition != lastSelectorPosition) {\\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\\n }\\n // delete the last selector\\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\\n delete ds.selectorToFacetAndPosition[_selector];\\n\\n // if no more selectors for facet address then delete the facet address\\n if (lastSelectorPosition == 0) {\\n // replace facet address with last facet address and delete last facet address\\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n if (facetAddressPosition != lastFacetAddressPosition) {\\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\\n }\\n ds.facetAddresses.pop();\\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\\n }\\n }\\n\\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\\n if (_init == address(0)) {\\n require(_calldata.length == 0, \\\"LibDiamondCut: _init is address(0) but_calldata is not empty\\\");\\n } else {\\n require(_calldata.length > 0, \\\"LibDiamondCut: _calldata is empty but _init is not address(0)\\\");\\n if (_init != address(this)) {\\n enforceHasContractCode(_init, \\\"LibDiamondCut: _init address has no code\\\");\\n }\\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n if (!success) {\\n if (error.length > 0) {\\n // bubble up the error\\n revert(string(error));\\n } else {\\n revert(\\\"LibDiamondCut: _init function reverted\\\");\\n }\\n }\\n }\\n }\\n\\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\\n uint256 contractSize;\\n assembly {\\n contractSize := extcodesize(_contract)\\n }\\n require(contractSize > 0, _errorMessage);\\n }\\n}\\n\",\"keccak256\":\"0x4eac03abb9864ad822b50481746c975a8e3e3278e179032cfc1b4b9c8e2320bc\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/ent_addMerkle_NFTDistributor_v1.json b/deployments/polygon_mumbai/ent_addMerkle_NFTDistributor_v1.json new file mode 100644 index 000000000..b5fcf8a20 --- /dev/null +++ b/deployments/polygon_mumbai/ent_addMerkle_NFTDistributor_v1.json @@ -0,0 +1,86 @@ +{ + "address": "0x2c06A917921eA2f1AB18AE7bb85A2d4Ef3E5BC50", + "abi": [ + { + "inputs": [ + { + "internalType": "uint256", + "name": "tierIndex", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + } + ], + "name": "addMerkle", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "ent_addMerkle_NFTDistributor_v1", + "transactionHash": "0x84c35a539eec7d994935435cf36fb08b6c36609c04a78ead5d5699a057c5b562", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x2c06A917921eA2f1AB18AE7bb85A2d4Ef3E5BC50", + "transactionIndex": 1, + "gasUsed": "179473", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000002000000000000000000000000000000000000000000000000000800100000000000000040100000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000040000000004000000000000100000001000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0xb85fa3ee76d4f0bf368d56d7cbe0fa60ae0f629d2df29d1577d11d8b68ef1cd7", + "transactionHash": "0x84c35a539eec7d994935435cf36fb08b6c36609c04a78ead5d5699a057c5b562", + "logs": [ + { + "transactionIndex": 1, + "blockNumber": 15692295, + "transactionHash": "0x84c35a539eec7d994935435cf36fb08b6c36609c04a78ead5d5699a057c5b562", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000c275dc8be39f50d12f66b6a63629c39da5bae5bd" + ], + "data": "0x000000000000000000000000000000000000000000000000001320e46c5a6c000000000000000000000000000000000000000000000000005060d7a89dc700000000000000000000000000000000000000000000000000b4089aa52fc76e81d5000000000000000000000000000000000000000000000000504db6c4316c94000000000000000000000000000000000000000000000000b408adc61433c8edd5", + "logIndex": 2, + "blockHash": "0xb85fa3ee76d4f0bf368d56d7cbe0fa60ae0f629d2df29d1577d11d8b68ef1cd7" + } + ], + "blockNumber": 15692295, + "cumulativeGasUsed": "200473", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tierIndex\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"merkleRoot\",\"type\":\"bytes32\"}],\"name\":\"addMerkle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"addMerkle(uint256,bytes32)\":{\"params\":{\"merkleRoot\":\"The merkle root to assign to the new tier. Requirements: - Caller must be an admin\",\"tierIndex\":\"Index of NFT tier to assign merkle for.\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"addMerkle(uint256,bytes32)\":{\"notice\":\"Adds a new merkle to be able to claim NFTs.\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/nft/distributor/entry/add-merkle.sol\":\"ent_addMerkle_NFTDistributor_v1\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"contracts/contexts/access-control/data.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct RoleData {\\n mapping(address => bool) members;\\n bytes32 adminRole;\\n}\\n\\nlibrary AccessControlEvents {\\n event OwnerSet(address indexed owner);\\n\\n event OwnerTransferred(address indexed owner, address indexed prevOwner);\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(\\n bytes32 indexed role,\\n bytes32 indexed previousAdminRole,\\n bytes32 indexed newAdminRole\\n );\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n}\\n\",\"keccak256\":\"0xe810f81cc2c393f9f7df19841cae3cb78ac914c5501238713d6c62192ac026a9\",\"license\":\"MIT\"},\"contracts/contexts/access-control/internal/has-role.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"../storage/roles.sol\\\";\\n\\nabstract contract int_hasRole_AccessControl_v1 is sto_AccessControl_Roles {\\n function _hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool hasRole_)\\n {\\n hasRole_ = accessControlRolesStore().roles[role].members[account];\\n }\\n}\\n\",\"keccak256\":\"0x631c0c260f7de64c32a205405e3ec424a6b34aec27987ced91a0254fdabfb1a7\",\"license\":\"MIT\"},\"contracts/contexts/access-control/internal/require-authorization.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./has-role.sol\\\";\\n\\nabstract contract int_requireAuthorization_AccessControl_v1 is\\n int_hasRole_AccessControl_v1\\n{\\n function _requireAuthorization(bytes32 role, address account)\\n internal\\n view\\n {\\n require(_hasRole(role, account), \\\"AccessControl: unauthorized\\\");\\n }\\n}\\n\",\"keccak256\":\"0x5c3bc56480df5bf9e9d37962f00dc46ddd4df10e8eddcb45a8ad6c9538c86d67\",\"license\":\"MIT\"},\"contracts/contexts/access-control/modifiers/authorized.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n int_requireAuthorization_AccessControl_v1\\n} from \\\"../internal/require-authorization.sol\\\";\\n\\nabstract contract mod_authorized_AccessControl_v1 is\\n int_requireAuthorization_AccessControl_v1\\n{\\n modifier authorized(bytes32 role, address account) {\\n _requireAuthorization(role, account);\\n _;\\n }\\n}\\n\\nabstract contract mod_authorized_AccessControl is\\n mod_authorized_AccessControl_v1\\n{}\\n\",\"keccak256\":\"0x07b59ca25af7579afacf46fd29c611a89928dc3df8381f6a3dd5ba8ded407d61\",\"license\":\"MIT\"},\"contracts/contexts/access-control/storage/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RoleData } from \\\"../data.sol\\\";\\n\\ncontract sto_AccessControl_Roles {\\n bytes32 internal constant POS =\\n keccak256(\\\"teller_protocol.storage.access_control.roles\\\");\\n\\n struct AccessControlRolesStorage {\\n mapping(bytes32 => RoleData) roles;\\n }\\n\\n function accessControlRolesStore()\\n internal\\n pure\\n returns (AccessControlRolesStorage storage s)\\n {\\n bytes32 position = POS;\\n\\n assembly {\\n s.slot := position\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd3173b189dddc069a22ac5a5f2d411305846c9de523f8ce279b7219f2ee51470\",\"license\":\"MIT\"},\"contracts/nft/IStakeableNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IStakeableNFT {\\n function tokenBaseLoanSize(uint256 tokenId) external view returns (uint256);\\n\\n function tokenURIHash(uint256 tokenId)\\n external\\n view\\n returns (string memory);\\n\\n function tokenContributionAsset(uint256 tokenId)\\n external\\n view\\n returns (address);\\n\\n function tokenContributionSize(uint256 tokenId)\\n external\\n view\\n returns (uint256);\\n\\n function tokenContributionMultiplier(uint256 tokenId)\\n external\\n view\\n returns (uint8);\\n}\\n\",\"keccak256\":\"0xfbf44350ad91a54de26f39195d714580d7dade556ea4c7991a51eef5aa839105\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFTDictionary.sol\":{\"content\":\"/**\\n * @notice TellerNFTDictionary Version 1.02\\n *\\n * @notice This contract is used to gather data for TellerV1 NFTs more efficiently.\\n * @notice This contract has data which must be continuously synchronized with the TellerV1 NFT data\\n *\\n * @author develop@teller.finance\\n */\\n\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Interfaces\\nimport \\\"./IStakeableNFT.sol\\\";\\n\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFTDictionary is IStakeableNFT, AccessControlUpgradeable {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n mapping(uint256 => uint256) public baseLoanSizes;\\n mapping(uint256 => string[]) public hashes;\\n mapping(uint256 => address) public contributionAssets;\\n mapping(uint256 => uint256) public contributionSizes;\\n mapping(uint256 => uint8) public contributionMultipliers;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n\\n /* State Variables */\\n\\n mapping(uint256 => uint256) public _tokenTierMappingCompressed;\\n bool public _tokenTierMappingCompressedSet;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFTDictionary: not admin\\\");\\n _;\\n }\\n\\n function initialize(address initialAdmin) public {\\n _setupRole(ADMIN, initialAdmin);\\n _setRoleAdmin(ADMIN, ADMIN);\\n\\n __AccessControl_init();\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTierIndex(uint256 tokenId)\\n public\\n view\\n returns (uint8 index_)\\n {\\n //32 * 8 = 256 - each uint256 holds the data of 32 tokens . 8 bits each.\\n\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 compressedRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n //use 31 instead of 32 to account for the '0x' in the start.\\n //the '31 -' reverses our bytes order which is necessary\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint8 tierIndex = uint8((compressedRegister >> offset));\\n\\n return tierIndex;\\n }\\n\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory)\\n {\\n return hashes[tierIndex];\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTier(uint256 index, Tier memory newTier)\\n external\\n onlyAdmin\\n returns (bool)\\n {\\n baseLoanSizes[index] = newTier.baseLoanSize;\\n hashes[index] = newTier.hashes;\\n contributionAssets[index] = newTier.contributionAsset;\\n contributionSizes[index] = newTier.contributionSize;\\n contributionMultipliers[index] = newTier.contributionMultiplier;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param tiersMapping Information about the new tiers to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setAllTokenTierMappings(uint256[] memory tiersMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n require(\\n !_tokenTierMappingCompressedSet,\\n \\\"TellerNFTDictionary: token tier mapping already set\\\"\\n );\\n for (uint256 i = 0; i < tiersMapping.length; i++) {\\n _tokenTierMappingCompressed[i] = tiersMapping[i];\\n }\\n\\n _tokenTierMappingCompressedSet = true;\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param index the mapping row, each holds data for 32 tokens\\n * @param tierMapping Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierMapping(uint256 index, uint256 tierMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n _tokenTierMappingCompressed[index] = tierMapping;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenIds the NFT token Ids for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenIds(\\n uint256[] calldata tokenIds,\\n uint256 tokenTier\\n ) public onlyAdmin returns (bool) {\\n for (uint256 i; i < tokenIds.length; i++) {\\n setTokenTierForTokenId(tokenIds[i], tokenTier);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenId the NFT token Id for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenId(uint256 tokenId, uint256 tokenTier)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 existingRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint256 updateMaskShifted =\\n 0x00000000000000000000000000000000000000000000000000000000000000FF <<\\n offset;\\n\\n uint256 updateMaskShiftedNegated = ~updateMaskShifted;\\n\\n uint256 tokenTierShifted =\\n ((0x0000000000000000000000000000000000000000000000000000000000000000 |\\n tokenTier) << offset);\\n\\n uint256 existingRegisterClearedWithMask =\\n existingRegister & updateMaskShiftedNegated;\\n\\n uint256 updatedRegister =\\n existingRegisterClearedWithMask | tokenTierShifted;\\n\\n _tokenTierMappingCompressed[mappingIndex] = updatedRegister;\\n\\n return true;\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(IStakeableNFT).interfaceId ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n New methods for the dictionary\\n */\\n\\n /**\\n * @notice It returns Base Loan Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenBaseLoanSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return baseLoanSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Token URI Hash for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenURIHash(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n string[] memory tierImageHashes = hashes[tokenTier];\\n return tierImageHashes[tokenId % (tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice It returns Contribution Asset for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionAsset(uint256 tokenId)\\n public\\n view\\n override\\n returns (address)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionAssets[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Multiplier for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionMultiplier(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint8)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionMultipliers[tokenTier];\\n }\\n}\\n\",\"keccak256\":\"0xf33e3fa1f609fdd2abb3b5fb9c232269d13363a3e4fa5697ea96269e361e74fa\"},\"contracts/nft/distributor/data.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant MINTER = keccak256(\\\"MINTER\\\");\\n\\nstruct MerkleRoot {\\n bytes32 merkleRoot;\\n uint256 tierIndex;\\n}\\n\\nstruct ClaimNFTRequest {\\n uint256 merkleIndex;\\n uint256 nodeIndex;\\n uint256 amount;\\n bytes32[] merkleProof;\\n}\\n\\nlibrary DistributorEvents {\\n event Claimed(address indexed account);\\n\\n event MerkleAdded(uint256 index);\\n}\\n\",\"keccak256\":\"0x3d0d14b0ed21ead3c29e3cd4195c5d40fb987bda0e6e4b61a60d8e2c5c1807c3\",\"license\":\"MIT\"},\"contracts/nft/distributor/entry/add-merkle.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"../store.sol\\\";\\nimport \\\"../../../contexts/access-control/modifiers/authorized.sol\\\";\\n\\n// Utils\\nimport { DistributorEvents, ADMIN, MerkleRoot } from \\\"../data.sol\\\";\\n\\ncontract ent_addMerkle_NFTDistributor_v1 is\\n sto_NFTDistributor,\\n mod_authorized_AccessControl_v1\\n{\\n /**\\n * @notice Adds a new merkle to be able to claim NFTs.\\n * @param tierIndex Index of NFT tier to assign merkle for.\\n * @param merkleRoot The merkle root to assign to the new tier.\\n *\\n * Requirements:\\n * - Caller must be an admin\\n */\\n function addMerkle(uint256 tierIndex, bytes32 merkleRoot)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n MerkleRoot storage merkle = distributorStore().merkleRoots.push();\\n merkle.tierIndex = tierIndex;\\n merkle.merkleRoot = merkleRoot;\\n\\n emit DistributorEvents.MerkleAdded(\\n distributorStore().merkleRoots.length - 1\\n );\\n }\\n}\\n\",\"keccak256\":\"0xe7d0392951e47084fcb574972d57cacabdf6100b5ac75435c6c0aee9ecf54c6b\",\"license\":\"MIT\"},\"contracts/nft/distributor/store.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport \\\"../ITellerNFT.sol\\\";\\nimport \\\"../TellerNFTDictionary.sol\\\";\\n\\n// Utils\\nimport { MerkleRoot } from \\\"./data.sol\\\";\\n\\nabstract contract sto_NFTDistributor {\\n struct DistributorStorage {\\n ITellerNFT nft;\\n MerkleRoot[] merkleRoots;\\n mapping(uint256 => mapping(uint256 => uint256)) claimedBitMap;\\n TellerNFTDictionary dictionary;\\n }\\n\\n bytes32 constant POSITION = keccak256(\\\"teller_nft.distributor\\\");\\n\\n function distributorStore()\\n internal\\n pure\\n returns (DistributorStorage storage s)\\n {\\n bytes32 P = POSITION;\\n assembly {\\n s.slot := P\\n }\\n }\\n}\\n\",\"keccak256\":\"0xc4b5c728c22c137e44c8b911105e45d0d85f42cb3a6a2ca31136cb4029d5fc7e\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "0x608060405234801561001057600080fd5b50610248806100206000396000f3fe608060405234801561001057600080fd5b506004361061002b5760003560e01c806398fa2abf14610030575b600080fd5b61004361003e3660046101ce565b610045565b005b7fdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42336100718282610135565b7fcf1e960f2172c22b0a7308b10d2fa40d0d089ee0367c8e6cb72a5803f164c361805460018082018355600083905260029091027fb9fa352bc973ec2d8453aa141171c316a3808e25ed4edf76f3674c4a7b18977881018790557fb9fa352bc973ec2d8453aa141171c316a3808e25ed4edf76f3674c4a7b1897770185815591547ff670e7d62789fc7ea11733fd5bc314d1f0f2000089c979a679949b37b03d4c8d9161011d916101ef565b60405190815260200160405180910390a15050505050565b60008281527f337c29a31b05a860fb532911919dbe85ab303a7465176333f1deb496e9fdd19e602090815260408083206001600160a01b038516845290915290205460ff166101ca5760405162461bcd60e51b815260206004820152601b60248201527f416363657373436f6e74726f6c3a20756e617574686f72697a65640000000000604482015260640160405180910390fd5b5050565b600080604083850312156101e0578182fd5b50508035926020909101359150565b60008282101561020d57634e487b7160e01b81526011600452602481fd5b50039056fea2646970667358221220e4b4753bca956725ae0481b41edcfcbb1cd54dedce3ec82b4b2e548881a4af7764736f6c63430008030033", + "deployedBytecode": "0x608060405234801561001057600080fd5b506004361061002b5760003560e01c806398fa2abf14610030575b600080fd5b61004361003e3660046101ce565b610045565b005b7fdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42336100718282610135565b7fcf1e960f2172c22b0a7308b10d2fa40d0d089ee0367c8e6cb72a5803f164c361805460018082018355600083905260029091027fb9fa352bc973ec2d8453aa141171c316a3808e25ed4edf76f3674c4a7b18977881018790557fb9fa352bc973ec2d8453aa141171c316a3808e25ed4edf76f3674c4a7b1897770185815591547ff670e7d62789fc7ea11733fd5bc314d1f0f2000089c979a679949b37b03d4c8d9161011d916101ef565b60405190815260200160405180910390a15050505050565b60008281527f337c29a31b05a860fb532911919dbe85ab303a7465176333f1deb496e9fdd19e602090815260408083206001600160a01b038516845290915290205460ff166101ca5760405162461bcd60e51b815260206004820152601b60248201527f416363657373436f6e74726f6c3a20756e617574686f72697a65640000000000604482015260640160405180910390fd5b5050565b600080604083850312156101e0578182fd5b50508035926020909101359150565b60008282101561020d57634e487b7160e01b81526011600452602481fd5b50039056fea2646970667358221220e4b4753bca956725ae0481b41edcfcbb1cd54dedce3ec82b4b2e548881a4af7764736f6c63430008030033", + "devdoc": { + "kind": "dev", + "methods": { + "addMerkle(uint256,bytes32)": { + "params": { + "merkleRoot": "The merkle root to assign to the new tier. Requirements: - Caller must be an admin", + "tierIndex": "Index of NFT tier to assign merkle for." + } + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "addMerkle(uint256,bytes32)": { + "notice": "Adds a new merkle to be able to claim NFTs." + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/ent_claim_NFTDistributor_v1.json b/deployments/polygon_mumbai/ent_claim_NFTDistributor_v1.json new file mode 100644 index 000000000..951e6d1b0 --- /dev/null +++ b/deployments/polygon_mumbai/ent_claim_NFTDistributor_v1.json @@ -0,0 +1,121 @@ +{ + "address": "0xe3a22D5FB394c9137993404aC01a1E6208694b90", + "abi": [ + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "merkleIndex", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "nodeIndex", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "merkleProof", + "type": "bytes32[]" + } + ], + "internalType": "struct ClaimNFTRequest[]", + "name": "requests", + "type": "tuple[]" + } + ], + "name": "claim", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "dictionary", + "type": "address" + } + ], + "name": "setNFTDictionaryAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "ent_claim_NFTDistributor_v1", + "transactionHash": "0x4cbac6ed6e54c0b6a066470dcc31a3635224e27a095857f73145adc6aed91260", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0xe3a22D5FB394c9137993404aC01a1E6208694b90", + "transactionIndex": 0, + "gasUsed": "822355", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000002000000000000000000000000000000000000000000000000000800100000000000000040100000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000040000000004000000000000100000001000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0xd5408530234fe29c70f2d72095d001c6c407cc0ba57457697af9840262d4b92b", + "transactionHash": "0x4cbac6ed6e54c0b6a066470dcc31a3635224e27a095857f73145adc6aed91260", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692303, + "transactionHash": "0x4cbac6ed6e54c0b6a066470dcc31a3635224e27a095857f73145adc6aed91260", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000c275dc8be39f50d12f66b6a63629c39da5bae5bd" + ], + "data": "0x0000000000000000000000000000000000000000000000000057a5d351a0c400000000000000000000000000000000000000000000000000503da705ced008000000000000000000000000000000000000000000000000b408da88aa8e9d01d50000000000000000000000000000000000000000000000004fe601327d2f44000000000000000000000000000000000000000000000000b409322e7de03dc5d5", + "logIndex": 0, + "blockHash": "0xd5408530234fe29c70f2d72095d001c6c407cc0ba57457697af9840262d4b92b" + } + ], + "blockNumber": 15692303, + "cumulativeGasUsed": "822355", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"merkleIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nodeIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes32[]\",\"name\":\"merkleProof\",\"type\":\"bytes32[]\"}],\"internalType\":\"struct ClaimNFTRequest[]\",\"name\":\"requests\",\"type\":\"tuple[]\"}],\"name\":\"claim\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"dictionary\",\"type\":\"address\"}],\"name\":\"setNFTDictionaryAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"claim(address,(uint256,uint256,uint256,bytes32[])[])\":{\"params\":{\"account\":\"The address to claim NFTs on behalf.\",\"requests\":\"An array requests data generated from the merkle tree. Requirements: - Node in the merkle root must not be claimed already - Proof of the node must match the merkle tree\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"claim(address,(uint256,uint256,uint256,bytes32[])[])\":{\"notice\":\"Claims TellerNFTs for a given verifiable merkle proofs for each tier.\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/nft/distributor/entry/claim.sol\":\"ent_claim_NFTDistributor_v1\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Trees proofs.\\n *\\n * The proofs can be generated using the JavaScript library\\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\\n *\\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n bytes32 computedHash = leaf;\\n\\n for (uint256 i = 0; i < proof.length; i++) {\\n bytes32 proofElement = proof[i];\\n\\n if (computedHash <= proofElement) {\\n // Hash(current computed hash + current element of the proof)\\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\\n } else {\\n // Hash(current element of the proof + current computed hash)\\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\\n }\\n }\\n\\n // Check if the computed hash (root) is equal to the provided root\\n return computedHash == root;\\n }\\n}\\n\",\"keccak256\":\"0xeee34bfb413657b6cd6c8e1e15c2080ba5ebaac479578515922804346fb63f7c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"contracts/contexts/access-control/data.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct RoleData {\\n mapping(address => bool) members;\\n bytes32 adminRole;\\n}\\n\\nlibrary AccessControlEvents {\\n event OwnerSet(address indexed owner);\\n\\n event OwnerTransferred(address indexed owner, address indexed prevOwner);\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(\\n bytes32 indexed role,\\n bytes32 indexed previousAdminRole,\\n bytes32 indexed newAdminRole\\n );\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n}\\n\",\"keccak256\":\"0xe810f81cc2c393f9f7df19841cae3cb78ac914c5501238713d6c62192ac026a9\",\"license\":\"MIT\"},\"contracts/contexts/access-control/internal/has-role.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"../storage/roles.sol\\\";\\n\\nabstract contract int_hasRole_AccessControl_v1 is sto_AccessControl_Roles {\\n function _hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool hasRole_)\\n {\\n hasRole_ = accessControlRolesStore().roles[role].members[account];\\n }\\n}\\n\",\"keccak256\":\"0x631c0c260f7de64c32a205405e3ec424a6b34aec27987ced91a0254fdabfb1a7\",\"license\":\"MIT\"},\"contracts/contexts/access-control/internal/require-authorization.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./has-role.sol\\\";\\n\\nabstract contract int_requireAuthorization_AccessControl_v1 is\\n int_hasRole_AccessControl_v1\\n{\\n function _requireAuthorization(bytes32 role, address account)\\n internal\\n view\\n {\\n require(_hasRole(role, account), \\\"AccessControl: unauthorized\\\");\\n }\\n}\\n\",\"keccak256\":\"0x5c3bc56480df5bf9e9d37962f00dc46ddd4df10e8eddcb45a8ad6c9538c86d67\",\"license\":\"MIT\"},\"contracts/contexts/access-control/modifiers/authorized.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n int_requireAuthorization_AccessControl_v1\\n} from \\\"../internal/require-authorization.sol\\\";\\n\\nabstract contract mod_authorized_AccessControl_v1 is\\n int_requireAuthorization_AccessControl_v1\\n{\\n modifier authorized(bytes32 role, address account) {\\n _requireAuthorization(role, account);\\n _;\\n }\\n}\\n\\nabstract contract mod_authorized_AccessControl is\\n mod_authorized_AccessControl_v1\\n{}\\n\",\"keccak256\":\"0x07b59ca25af7579afacf46fd29c611a89928dc3df8381f6a3dd5ba8ded407d61\",\"license\":\"MIT\"},\"contracts/contexts/access-control/storage/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RoleData } from \\\"../data.sol\\\";\\n\\ncontract sto_AccessControl_Roles {\\n bytes32 internal constant POS =\\n keccak256(\\\"teller_protocol.storage.access_control.roles\\\");\\n\\n struct AccessControlRolesStorage {\\n mapping(bytes32 => RoleData) roles;\\n }\\n\\n function accessControlRolesStore()\\n internal\\n pure\\n returns (AccessControlRolesStorage storage s)\\n {\\n bytes32 position = POS;\\n\\n assembly {\\n s.slot := position\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd3173b189dddc069a22ac5a5f2d411305846c9de523f8ce279b7219f2ee51470\",\"license\":\"MIT\"},\"contracts/nft/IStakeableNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IStakeableNFT {\\n function tokenBaseLoanSize(uint256 tokenId) external view returns (uint256);\\n\\n function tokenURIHash(uint256 tokenId)\\n external\\n view\\n returns (string memory);\\n\\n function tokenContributionAsset(uint256 tokenId)\\n external\\n view\\n returns (address);\\n\\n function tokenContributionSize(uint256 tokenId)\\n external\\n view\\n returns (uint256);\\n\\n function tokenContributionMultiplier(uint256 tokenId)\\n external\\n view\\n returns (uint8);\\n}\\n\",\"keccak256\":\"0xfbf44350ad91a54de26f39195d714580d7dade556ea4c7991a51eef5aa839105\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFTDictionary.sol\":{\"content\":\"/**\\n * @notice TellerNFTDictionary Version 1.02\\n *\\n * @notice This contract is used to gather data for TellerV1 NFTs more efficiently.\\n * @notice This contract has data which must be continuously synchronized with the TellerV1 NFT data\\n *\\n * @author develop@teller.finance\\n */\\n\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Interfaces\\nimport \\\"./IStakeableNFT.sol\\\";\\n\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFTDictionary is IStakeableNFT, AccessControlUpgradeable {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n mapping(uint256 => uint256) public baseLoanSizes;\\n mapping(uint256 => string[]) public hashes;\\n mapping(uint256 => address) public contributionAssets;\\n mapping(uint256 => uint256) public contributionSizes;\\n mapping(uint256 => uint8) public contributionMultipliers;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n\\n /* State Variables */\\n\\n mapping(uint256 => uint256) public _tokenTierMappingCompressed;\\n bool public _tokenTierMappingCompressedSet;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFTDictionary: not admin\\\");\\n _;\\n }\\n\\n function initialize(address initialAdmin) public {\\n _setupRole(ADMIN, initialAdmin);\\n _setRoleAdmin(ADMIN, ADMIN);\\n\\n __AccessControl_init();\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTierIndex(uint256 tokenId)\\n public\\n view\\n returns (uint8 index_)\\n {\\n //32 * 8 = 256 - each uint256 holds the data of 32 tokens . 8 bits each.\\n\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 compressedRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n //use 31 instead of 32 to account for the '0x' in the start.\\n //the '31 -' reverses our bytes order which is necessary\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint8 tierIndex = uint8((compressedRegister >> offset));\\n\\n return tierIndex;\\n }\\n\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory)\\n {\\n return hashes[tierIndex];\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTier(uint256 index, Tier memory newTier)\\n external\\n onlyAdmin\\n returns (bool)\\n {\\n baseLoanSizes[index] = newTier.baseLoanSize;\\n hashes[index] = newTier.hashes;\\n contributionAssets[index] = newTier.contributionAsset;\\n contributionSizes[index] = newTier.contributionSize;\\n contributionMultipliers[index] = newTier.contributionMultiplier;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param tiersMapping Information about the new tiers to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setAllTokenTierMappings(uint256[] memory tiersMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n require(\\n !_tokenTierMappingCompressedSet,\\n \\\"TellerNFTDictionary: token tier mapping already set\\\"\\n );\\n for (uint256 i = 0; i < tiersMapping.length; i++) {\\n _tokenTierMappingCompressed[i] = tiersMapping[i];\\n }\\n\\n _tokenTierMappingCompressedSet = true;\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param index the mapping row, each holds data for 32 tokens\\n * @param tierMapping Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierMapping(uint256 index, uint256 tierMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n _tokenTierMappingCompressed[index] = tierMapping;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenIds the NFT token Ids for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenIds(\\n uint256[] calldata tokenIds,\\n uint256 tokenTier\\n ) public onlyAdmin returns (bool) {\\n for (uint256 i; i < tokenIds.length; i++) {\\n setTokenTierForTokenId(tokenIds[i], tokenTier);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenId the NFT token Id for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenId(uint256 tokenId, uint256 tokenTier)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 existingRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint256 updateMaskShifted =\\n 0x00000000000000000000000000000000000000000000000000000000000000FF <<\\n offset;\\n\\n uint256 updateMaskShiftedNegated = ~updateMaskShifted;\\n\\n uint256 tokenTierShifted =\\n ((0x0000000000000000000000000000000000000000000000000000000000000000 |\\n tokenTier) << offset);\\n\\n uint256 existingRegisterClearedWithMask =\\n existingRegister & updateMaskShiftedNegated;\\n\\n uint256 updatedRegister =\\n existingRegisterClearedWithMask | tokenTierShifted;\\n\\n _tokenTierMappingCompressed[mappingIndex] = updatedRegister;\\n\\n return true;\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(IStakeableNFT).interfaceId ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n New methods for the dictionary\\n */\\n\\n /**\\n * @notice It returns Base Loan Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenBaseLoanSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return baseLoanSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Token URI Hash for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenURIHash(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n string[] memory tierImageHashes = hashes[tokenTier];\\n return tierImageHashes[tokenId % (tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice It returns Contribution Asset for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionAsset(uint256 tokenId)\\n public\\n view\\n override\\n returns (address)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionAssets[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Multiplier for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionMultiplier(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint8)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionMultipliers[tokenTier];\\n }\\n}\\n\",\"keccak256\":\"0xf33e3fa1f609fdd2abb3b5fb9c232269d13363a3e4fa5697ea96269e361e74fa\"},\"contracts/nft/distributor/data.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant MINTER = keccak256(\\\"MINTER\\\");\\n\\nstruct MerkleRoot {\\n bytes32 merkleRoot;\\n uint256 tierIndex;\\n}\\n\\nstruct ClaimNFTRequest {\\n uint256 merkleIndex;\\n uint256 nodeIndex;\\n uint256 amount;\\n bytes32[] merkleProof;\\n}\\n\\nlibrary DistributorEvents {\\n event Claimed(address indexed account);\\n\\n event MerkleAdded(uint256 index);\\n}\\n\",\"keccak256\":\"0x3d0d14b0ed21ead3c29e3cd4195c5d40fb987bda0e6e4b61a60d8e2c5c1807c3\",\"license\":\"MIT\"},\"contracts/nft/distributor/entry/claim.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"../store.sol\\\";\\nimport \\\"../../../contexts/access-control/modifiers/authorized.sol\\\";\\n\\nimport \\\"../internal/distributor.sol\\\";\\n\\n// Utils\\nimport { ClaimNFTRequest, ADMIN, DistributorEvents } from \\\"../data.sol\\\";\\n\\ncontract ent_claim_NFTDistributor_v1 is\\n sto_NFTDistributor,\\n int_distributor_NFT_v1,\\n mod_authorized_AccessControl_v1\\n{\\n /**\\n * @notice Claims TellerNFTs for a given verifiable merkle proofs for each tier.\\n * @param account The address to claim NFTs on behalf.\\n * @param requests An array requests data generated from the merkle tree.\\n *\\n * Requirements:\\n * - Node in the merkle root must not be claimed already\\n * - Proof of the node must match the merkle tree\\n */\\n function claim(address account, ClaimNFTRequest[] calldata requests)\\n external\\n {\\n for (uint256 i; i < requests.length; i++) {\\n require(\\n !_isClaimed(requests[i].merkleIndex, requests[i].nodeIndex),\\n \\\"TellerNFT Distributor: already claimed\\\"\\n );\\n require(\\n _verifyProof(account, requests[i]),\\n \\\"TellerNFT Distributor: invalid proof\\\"\\n );\\n\\n // Mark it claimed and send the token.\\n _setClaimed(requests[i].merkleIndex, requests[i].nodeIndex);\\n uint256 tierIndex =\\n distributorStore().merkleRoots[requests[i].merkleIndex]\\n .tierIndex;\\n for (uint256 j; j < requests[i].amount; j++) {\\n distributorStore().nft.mint(tierIndex, account);\\n }\\n\\n //Find the newly minted tokens and add to memory\\n uint256[] memory postOwnedTokens =\\n distributorStore().nft.getOwnedTokens(account);\\n\\n uint256[] memory newlyMintedTokenIds =\\n new uint256[](requests[i].amount);\\n\\n uint256 offset = postOwnedTokens.length - requests[i].amount;\\n\\n for (uint256 k; k < requests[i].amount; k++) {\\n newlyMintedTokenIds[k] = postOwnedTokens[k + offset];\\n }\\n\\n //For each newly minted token, set the tier index in the Dictionary contract\\n distributorStore().dictionary.setTokenTierForTokenIds(\\n newlyMintedTokenIds,\\n tierIndex\\n );\\n }\\n\\n emit DistributorEvents.Claimed(account);\\n }\\n\\n function setNFTDictionaryAddress(address dictionary)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n distributorStore().dictionary = TellerNFTDictionary(dictionary);\\n }\\n}\\n\",\"keccak256\":\"0x906afe386f8f90ee46df8609fe6f5853488ddf4b4b47f7c6cc41854d5bba72d8\",\"license\":\"MIT\"},\"contracts/nft/distributor/internal/distributor.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"../store.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\n\\n// Utils\\nimport { ClaimNFTRequest } from \\\"../data.sol\\\";\\n\\ncontract int_distributor_NFT_v1 is sto_NFTDistributor {\\n /**\\n * @notice It checks the merkle root for a tier if it has already been claimed.\\n * @param merkleIndex Index of the tier.\\n * @param nodeIndex Index of the node in the merkle root.\\n */\\n function _setClaimed(uint256 merkleIndex, uint256 nodeIndex) internal {\\n uint256 claimedWordIndex = nodeIndex / 256;\\n uint256 claimedBitIndex = nodeIndex % 256;\\n distributorStore().claimedBitMap[merkleIndex][claimedWordIndex] =\\n distributorStore().claimedBitMap[merkleIndex][claimedWordIndex] |\\n (1 << claimedBitIndex);\\n }\\n\\n /**\\n * @notice It checks the merkle root for a tier if it has already been claimed.\\n * @param merkleIndex Index of the tier.\\n * @param nodeIndex Index of the node in the merkle root.\\n * @return claimed_ returns a boolean to check if the tier has already been claimed\\n */\\n function _isClaimed(uint256 merkleIndex, uint256 nodeIndex)\\n internal\\n view\\n returns (bool)\\n {\\n uint256 claimedWordIndex = nodeIndex / 256;\\n uint256 claimedBitIndex = nodeIndex % 256;\\n uint256 claimedWord =\\n distributorStore().claimedBitMap[merkleIndex][claimedWordIndex];\\n uint256 mask = (1 << claimedBitIndex);\\n return claimedWord & mask == mask;\\n }\\n\\n /**\\n * @notice it verifies the request's merkle proof with the merkle root in order to claim an NFT\\n * @param account the account's address to be hashed and verified with the claim\\n * @param request the request with the merkle proof to verify\\n */\\n function _verifyProof(address account, ClaimNFTRequest memory request)\\n internal\\n view\\n returns (bool verified)\\n {\\n verified = MerkleProof.verify(\\n request.merkleProof,\\n distributorStore().merkleRoots[request.merkleIndex].merkleRoot,\\n keccak256(\\n abi.encodePacked(request.nodeIndex, account, request.amount)\\n )\\n );\\n }\\n}\\n\",\"keccak256\":\"0x72f48bd977226301a39bb5a351f63fc5b3019b49df4cc7d9f1af22738cb99938\",\"license\":\"MIT\"},\"contracts/nft/distributor/store.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport \\\"../ITellerNFT.sol\\\";\\nimport \\\"../TellerNFTDictionary.sol\\\";\\n\\n// Utils\\nimport { MerkleRoot } from \\\"./data.sol\\\";\\n\\nabstract contract sto_NFTDistributor {\\n struct DistributorStorage {\\n ITellerNFT nft;\\n MerkleRoot[] merkleRoots;\\n mapping(uint256 => mapping(uint256 => uint256)) claimedBitMap;\\n TellerNFTDictionary dictionary;\\n }\\n\\n bytes32 constant POSITION = keccak256(\\\"teller_nft.distributor\\\");\\n\\n function distributorStore()\\n internal\\n pure\\n returns (DistributorStorage storage s)\\n {\\n bytes32 P = POSITION;\\n assembly {\\n s.slot := P\\n }\\n }\\n}\\n\",\"keccak256\":\"0xc4b5c728c22c137e44c8b911105e45d0d85f42cb3a6a2ca31136cb4029d5fc7e\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "0x608060405234801561001057600080fd5b50610deb806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c806389e217331461003b578063d9a6fc4a14610050575b600080fd5b61004e610049366004610a51565b610063565b005b61004e61005e366004610a37565b6106c9565b60005b8181101561068f576100df83838381811061009157634e487b7160e01b600052603260045260246000fd5b90506020028101906100a39190610bd2565b358484848181106100c457634e487b7160e01b600052603260045260246000fd5b90506020028101906100d69190610bd2565b60200135610738565b156101405760405162461bcd60e51b815260206004820152602660248201527f54656c6c65724e4654204469737472696275746f723a20616c726561647920636044820152651b185a5b595960d21b60648201526084015b60405180910390fd5b6101848484848481811061016457634e487b7160e01b600052603260045260246000fd5b90506020028101906101769190610bd2565b61017f90610c89565b6107a2565b6101dc5760405162461bcd60e51b8152602060048201526024808201527f54656c6c65724e4654204469737472696275746f723a20696e76616c696420706044820152633937b7b360e11b6064820152608401610137565b61024d8383838181106101ff57634e487b7160e01b600052603260045260246000fd5b90506020028101906102119190610bd2565b3584848481811061023257634e487b7160e01b600052603260045260246000fd5b90506020028101906102449190610bd2565b60200135610861565b60007fcf1e960f2172c22b0a7308b10d2fa40d0d089ee0367c8e6cb72a5803f164c36184848481811061029057634e487b7160e01b600052603260045260246000fd5b90506020028101906102a29190610bd2565b60000135815481106102c457634e487b7160e01b600052603260045260246000fd5b906000526020600020906002020160010154905060005b8484848181106102fb57634e487b7160e01b600052603260045260246000fd5b905060200281019061030d9190610bd2565b604001358110156103b0577fcf1e960f2172c22b0a7308b10d2fa40d0d089ee0367c8e6cb72a5803f164c360546040516394bf804d60e01b8152600481018490526001600160a01b038881166024830152909116906394bf804d90604401600060405180830381600087803b15801561038557600080fd5b505af1158015610399573d6000803e3d6000fd5b5050505080806103a890610d44565b9150506102db565b5060007fcf1e960f2172c22b0a7308b10d2fa40d0d089ee0367c8e6cb72a5803f164c3605460405163d9d6165560e01b81526001600160a01b0388811660048301529091169063d9d616559060240160006040518083038186803b15801561041757600080fd5b505afa15801561042b573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526104539190810190610ad2565b9050600085858581811061047757634e487b7160e01b600052603260045260246000fd5b90506020028101906104899190610bd2565b6040013567ffffffffffffffff8111156104b357634e487b7160e01b600052604160045260246000fd5b6040519080825280602002602001820160405280156104dc578160200160208202803683370190505b509050600086868681811061050157634e487b7160e01b600052603260045260246000fd5b90506020028101906105139190610bd2565b6040013583516105239190610c72565b905060005b87878781811061054857634e487b7160e01b600052603260045260246000fd5b905060200281019061055a9190610bd2565b604001358110156105d357836105708383610c46565b8151811061058e57634e487b7160e01b600052603260045260246000fd5b60200260200101518382815181106105b657634e487b7160e01b600052603260045260246000fd5b6020908102919091010152806105cb81610d44565b915050610528565b507fcf1e960f2172c22b0a7308b10d2fa40d0d089ee0367c8e6cb72a5803f164c36354604051637c4d134760e11b81526001600160a01b039091169063f89a268e906106259085908890600401610b8a565b602060405180830381600087803b15801561063f57600080fd5b505af1158015610653573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106779190610b6a565b5050505050808061068790610d44565b915050610066565b506040516001600160a01b038416907fb449c24d261a59627b537c8c41c57ab559f4205c56bea745ff61c5521bece21490600090a2505050565b7fdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42336106f582826108c9565b50507fcf1e960f2172c22b0a7308b10d2fa40d0d089ee0367c8e6cb72a5803f164c36380546001600160a01b0319166001600160a01b0392909216919091179055565b60008061074761010084610c5e565b9050600061075761010085610d5f565b60009586527fcf1e960f2172c22b0a7308b10d2fa40d0d089ee0367c8e6cb72a5803f164c362602090815260408088209488529390529190942054600190911b908116149392505050565b600061085a82606001516107d37fcf1e960f2172c22b0a7308b10d2fa40d0d089ee0367c8e6cb72a5803f164c36090565b6001018460000151815481106107f957634e487b7160e01b600052603260045260246000fd5b600091825260209182902060029091020154858201516040808801518151948501929092526bffffffffffffffffffffffff1960608a901b16908401526054830152906074016040516020818303038152906040528051906020012061095e565b9392505050565b600061086f61010083610c5e565b9050600061087f61010084610d5f565b60009485527fcf1e960f2172c22b0a7308b10d2fa40d0d089ee0367c8e6cb72a5803f164c36260209081526040808720948752939052919093208054600190921b90911790555050565b60008281527f337c29a31b05a860fb532911919dbe85ab303a7465176333f1deb496e9fdd19e602090815260408083206001600160a01b038516845290915290205460ff1661095a5760405162461bcd60e51b815260206004820152601b60248201527f416363657373436f6e74726f6c3a20756e617574686f72697a656400000000006044820152606401610137565b5050565b600081815b8551811015610a1057600086828151811061098e57634e487b7160e01b600052603260045260246000fd5b602002602001015190508083116109d05760408051602081018590529081018290526060016040516020818303038152906040528051906020012092506109fd565b60408051602081018390529081018490526060016040516020818303038152906040528051906020012092505b5080610a0881610d44565b915050610963565b509092149392505050565b80356001600160a01b0381168114610a3257600080fd5b919050565b600060208284031215610a48578081fd5b61085a82610a1b565b600080600060408486031215610a65578182fd5b610a6e84610a1b565b9250602084013567ffffffffffffffff80821115610a8a578384fd5b818601915086601f830112610a9d578384fd5b813581811115610aab578485fd5b8760208260051b8501011115610abf578485fd5b6020830194508093505050509250925092565b60006020808385031215610ae4578182fd5b825167ffffffffffffffff811115610afa578283fd5b8301601f81018513610b0a578283fd5b8051610b1d610b1882610c22565b610bf1565b80828252848201915084840188868560051b8701011115610b3c578687fd5b8694505b83851015610b5e578051835260019490940193918501918501610b40565b50979650505050505050565b600060208284031215610b7b578081fd5b8151801515811461085a578182fd5b604080825283519082018190526000906020906060840190828701845b82811015610bc357815184529284019290840190600101610ba7565b50505092019290925292915050565b60008235607e19833603018112610be7578182fd5b9190910192915050565b604051601f8201601f1916810167ffffffffffffffff81118282101715610c1a57610c1a610d9f565b604052919050565b600067ffffffffffffffff821115610c3c57610c3c610d9f565b5060051b60200190565b60008219821115610c5957610c59610d73565b500190565b600082610c6d57610c6d610d89565b500490565b600082821015610c8457610c84610d73565b500390565b600060808236031215610c9a578081fd5b610ca46080610bf1565b823581526020808401358183015260408401356040830152606084013567ffffffffffffffff811115610cd5578384fd5b840136601f820112610ce5578384fd5b8035610cf3610b1882610c22565b8181528381019083850136600585901b860187011115610d11578788fd5b8794505b83851015610d33578035835260019490940193918501918501610d15565b506060860152509295945050505050565b6000600019821415610d5857610d58610d73565b5060010190565b600082610d6e57610d6e610d89565b500690565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052601260045260246000fd5b634e487b7160e01b600052604160045260246000fdfea2646970667358221220932c7b63c0208fe2b5d6b34c25e3641be6e352743e29081f74a075cc3806bdce64736f6c63430008030033", + "deployedBytecode": "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", + "devdoc": { + "kind": "dev", + "methods": { + "claim(address,(uint256,uint256,uint256,bytes32[])[])": { + "params": { + "account": "The address to claim NFTs on behalf.", + "requests": "An array requests data generated from the merkle tree. Requirements: - Node in the merkle root must not be claimed already - Proof of the node must match the merkle tree" + } + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "claim(address,(uint256,uint256,uint256,bytes32[])[])": { + "notice": "Claims TellerNFTs for a given verifiable merkle proofs for each tier." + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/ent_initialize_NFTDistributor_v1.json b/deployments/polygon_mumbai/ent_initialize_NFTDistributor_v1.json new file mode 100644 index 000000000..b04901a7d --- /dev/null +++ b/deployments/polygon_mumbai/ent_initialize_NFTDistributor_v1.json @@ -0,0 +1,112 @@ +{ + "address": "0xb72717Ad0e150399b47183AB0613b2098296b53c", + "abi": [ + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "grantRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_nft", + "type": "address" + }, + { + "internalType": "address", + "name": "_dictionary", + "type": "address" + }, + { + "internalType": "address", + "name": "admin", + "type": "address" + } + ], + "name": "initialize", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "ent_initialize_NFTDistributor_v1", + "transactionHash": "0xfa5789df74c49d3af607004e1010852f045e5b9d790ecbee2fa86f93e919084e", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0xb72717Ad0e150399b47183AB0613b2098296b53c", + "transactionIndex": 0, + "gasUsed": "272685", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000002000000000000000000000000000000000000000000000000000800100000000000000040100000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000040000000004000000000000100000001000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0x4cbe26dc9e52f522c00563058526c16e78b029a5bc30c45896db474c6ca1419c", + "transactionHash": "0xfa5789df74c49d3af607004e1010852f045e5b9d790ecbee2fa86f93e919084e", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692292, + "transactionHash": "0xfa5789df74c49d3af607004e1010852f045e5b9d790ecbee2fa86f93e919084e", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000c275dc8be39f50d12f66b6a63629c39da5bae5bd" + ], + "data": "0x000000000000000000000000000000000000000000000000001d102ab8d13c00000000000000000000000000000000000000000000000000507de7d356983c000000000000000000000000000000000000000000000000b408716398f98f35d50000000000000000000000000000000000000000000000005060d7a89dc700000000000000000000000000000000000000000000000000b4088e73c3b26071d5", + "logIndex": 0, + "blockHash": "0x4cbe26dc9e52f522c00563058526c16e78b029a5bc30c45896db474c6ca1419c" + } + ], + "blockNumber": 15692292, + "cumulativeGasUsed": "272685", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"grantRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_nft\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_dictionary\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"initialize(address,address,address)\":{\"params\":{\"_nft\":\"The address of the TellerNFT.\",\"admin\":\"The address of an admin.\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"grantRole(bytes32,address)\":{\"notice\":\"Grants an address a new role. Requirements: - Sender must be role admin.\"},\"initialize(address,address,address)\":{\"notice\":\"Initializes the Distributor contract with the TellerNFT\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/nft/distributor/entry/initialize.sol\":\"ent_initialize_NFTDistributor_v1\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"contracts/contexts/access-control/data.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct RoleData {\\n mapping(address => bool) members;\\n bytes32 adminRole;\\n}\\n\\nlibrary AccessControlEvents {\\n event OwnerSet(address indexed owner);\\n\\n event OwnerTransferred(address indexed owner, address indexed prevOwner);\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(\\n bytes32 indexed role,\\n bytes32 indexed previousAdminRole,\\n bytes32 indexed newAdminRole\\n );\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n}\\n\",\"keccak256\":\"0xe810f81cc2c393f9f7df19841cae3cb78ac914c5501238713d6c62192ac026a9\",\"license\":\"MIT\"},\"contracts/contexts/access-control/entry/grant-role.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"../data.sol\\\";\\nimport \\\"../internal/grant-role.sol\\\";\\nimport \\\"../internal/is-admin-for-role.sol\\\";\\n\\ncontract ent_grantRole_AccessControl_v1 is\\n int_grantRole_AccessControl_v1,\\n int_isAdminForRole_AccessControl_v1\\n{\\n /**\\n * @notice Grants an address a new role.\\n *\\n * Requirements:\\n * - Sender must be role admin.\\n */\\n function grantRole(bytes32 role, address account) external {\\n require(_isAdminForRole(role, msg.sender), \\\"AccessControl: not admin\\\");\\n _grantRole(role, account);\\n }\\n}\\n\",\"keccak256\":\"0xb806e676e1e37ed92178ff51c2b5d9a6e281f753fecf5d54e498ef0a8eba6010\",\"license\":\"MIT\"},\"contracts/contexts/access-control/internal/grant-role.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport { AccessControlEvents } from \\\"../data.sol\\\";\\nimport \\\"./has-role.sol\\\";\\n\\nabstract contract int_grantRole_AccessControl_v1 is\\n int_hasRole_AccessControl_v1\\n{\\n /**\\n * @dev Should only use when circumventing admin checking. See {../entry/grant-role.sol}\\n */\\n function _grantRole(bytes32 role, address account) internal {\\n if (_hasRole(role, account)) return;\\n accessControlRolesStore().roles[role].members[account] = true;\\n emit AccessControlEvents.RoleGranted(role, account, msg.sender);\\n }\\n}\\n\",\"keccak256\":\"0x00d1772a83d5853b217eca18921f6c1b338919e7112fe4acf559847a21fd41f4\",\"license\":\"MIT\"},\"contracts/contexts/access-control/internal/has-role.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"../storage/roles.sol\\\";\\n\\nabstract contract int_hasRole_AccessControl_v1 is sto_AccessControl_Roles {\\n function _hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool hasRole_)\\n {\\n hasRole_ = accessControlRolesStore().roles[role].members[account];\\n }\\n}\\n\",\"keccak256\":\"0x631c0c260f7de64c32a205405e3ec424a6b34aec27987ced91a0254fdabfb1a7\",\"license\":\"MIT\"},\"contracts/contexts/access-control/internal/is-admin-for-role.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"../storage/roles.sol\\\";\\n\\nabstract contract int_isAdminForRole_AccessControl_v1 is\\n sto_AccessControl_Roles\\n{\\n function _isAdminForRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool isAdminForRole_)\\n {\\n isAdminForRole_ = accessControlRolesStore().roles[\\n accessControlRolesStore().roles[role].adminRole\\n ]\\n .members[account];\\n }\\n}\\n\",\"keccak256\":\"0xaa04218771b81b87c6d4d604de5d075c3a2d7eafe970ad5fe28fec8b915cc78c\",\"license\":\"MIT\"},\"contracts/contexts/access-control/storage/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RoleData } from \\\"../data.sol\\\";\\n\\ncontract sto_AccessControl_Roles {\\n bytes32 internal constant POS =\\n keccak256(\\\"teller_protocol.storage.access_control.roles\\\");\\n\\n struct AccessControlRolesStorage {\\n mapping(bytes32 => RoleData) roles;\\n }\\n\\n function accessControlRolesStore()\\n internal\\n pure\\n returns (AccessControlRolesStorage storage s)\\n {\\n bytes32 position = POS;\\n\\n assembly {\\n s.slot := position\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd3173b189dddc069a22ac5a5f2d411305846c9de523f8ce279b7219f2ee51470\",\"license\":\"MIT\"},\"contracts/contexts/initializable/modifiers/initializer.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"../storage.sol\\\";\\n\\nabstract contract mod_initializer_Initializable_v1 is sto_Initializable {\\n modifier initializer {\\n require(\\n !initializableStorage().initialized,\\n \\\"Teller: already initialized\\\"\\n );\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x2f7b6a9d7b4b7a93bd8bf857eed576fcb5f8a4bbc068870e92548e02b34f3f2d\",\"license\":\"MIT\"},\"contracts/contexts/initializable/storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ncontract sto_Initializable {\\n struct InitializableLayout {\\n bool initialized;\\n }\\n\\n bytes32 internal constant INITIALIZABLE_STORAGE_POSITION =\\n keccak256(abi.encode(\\\"teller_protocol.context.initializable.v1\\\"));\\n\\n function initializableStorage()\\n internal\\n pure\\n returns (InitializableLayout storage l_)\\n {\\n bytes32 position = INITIALIZABLE_STORAGE_POSITION;\\n\\n assembly {\\n l_.slot := position\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5f5031385df5132017a84f53744755f78df94ea99560137b36cb85d89f7365c3\",\"license\":\"MIT\"},\"contracts/nft/IStakeableNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IStakeableNFT {\\n function tokenBaseLoanSize(uint256 tokenId) external view returns (uint256);\\n\\n function tokenURIHash(uint256 tokenId)\\n external\\n view\\n returns (string memory);\\n\\n function tokenContributionAsset(uint256 tokenId)\\n external\\n view\\n returns (address);\\n\\n function tokenContributionSize(uint256 tokenId)\\n external\\n view\\n returns (uint256);\\n\\n function tokenContributionMultiplier(uint256 tokenId)\\n external\\n view\\n returns (uint8);\\n}\\n\",\"keccak256\":\"0xfbf44350ad91a54de26f39195d714580d7dade556ea4c7991a51eef5aa839105\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFTDictionary.sol\":{\"content\":\"/**\\n * @notice TellerNFTDictionary Version 1.02\\n *\\n * @notice This contract is used to gather data for TellerV1 NFTs more efficiently.\\n * @notice This contract has data which must be continuously synchronized with the TellerV1 NFT data\\n *\\n * @author develop@teller.finance\\n */\\n\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Interfaces\\nimport \\\"./IStakeableNFT.sol\\\";\\n\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFTDictionary is IStakeableNFT, AccessControlUpgradeable {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n mapping(uint256 => uint256) public baseLoanSizes;\\n mapping(uint256 => string[]) public hashes;\\n mapping(uint256 => address) public contributionAssets;\\n mapping(uint256 => uint256) public contributionSizes;\\n mapping(uint256 => uint8) public contributionMultipliers;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n\\n /* State Variables */\\n\\n mapping(uint256 => uint256) public _tokenTierMappingCompressed;\\n bool public _tokenTierMappingCompressedSet;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFTDictionary: not admin\\\");\\n _;\\n }\\n\\n function initialize(address initialAdmin) public {\\n _setupRole(ADMIN, initialAdmin);\\n _setRoleAdmin(ADMIN, ADMIN);\\n\\n __AccessControl_init();\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTierIndex(uint256 tokenId)\\n public\\n view\\n returns (uint8 index_)\\n {\\n //32 * 8 = 256 - each uint256 holds the data of 32 tokens . 8 bits each.\\n\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 compressedRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n //use 31 instead of 32 to account for the '0x' in the start.\\n //the '31 -' reverses our bytes order which is necessary\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint8 tierIndex = uint8((compressedRegister >> offset));\\n\\n return tierIndex;\\n }\\n\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory)\\n {\\n return hashes[tierIndex];\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTier(uint256 index, Tier memory newTier)\\n external\\n onlyAdmin\\n returns (bool)\\n {\\n baseLoanSizes[index] = newTier.baseLoanSize;\\n hashes[index] = newTier.hashes;\\n contributionAssets[index] = newTier.contributionAsset;\\n contributionSizes[index] = newTier.contributionSize;\\n contributionMultipliers[index] = newTier.contributionMultiplier;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param tiersMapping Information about the new tiers to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setAllTokenTierMappings(uint256[] memory tiersMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n require(\\n !_tokenTierMappingCompressedSet,\\n \\\"TellerNFTDictionary: token tier mapping already set\\\"\\n );\\n for (uint256 i = 0; i < tiersMapping.length; i++) {\\n _tokenTierMappingCompressed[i] = tiersMapping[i];\\n }\\n\\n _tokenTierMappingCompressedSet = true;\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param index the mapping row, each holds data for 32 tokens\\n * @param tierMapping Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierMapping(uint256 index, uint256 tierMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n _tokenTierMappingCompressed[index] = tierMapping;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenIds the NFT token Ids for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenIds(\\n uint256[] calldata tokenIds,\\n uint256 tokenTier\\n ) public onlyAdmin returns (bool) {\\n for (uint256 i; i < tokenIds.length; i++) {\\n setTokenTierForTokenId(tokenIds[i], tokenTier);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenId the NFT token Id for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenId(uint256 tokenId, uint256 tokenTier)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 existingRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint256 updateMaskShifted =\\n 0x00000000000000000000000000000000000000000000000000000000000000FF <<\\n offset;\\n\\n uint256 updateMaskShiftedNegated = ~updateMaskShifted;\\n\\n uint256 tokenTierShifted =\\n ((0x0000000000000000000000000000000000000000000000000000000000000000 |\\n tokenTier) << offset);\\n\\n uint256 existingRegisterClearedWithMask =\\n existingRegister & updateMaskShiftedNegated;\\n\\n uint256 updatedRegister =\\n existingRegisterClearedWithMask | tokenTierShifted;\\n\\n _tokenTierMappingCompressed[mappingIndex] = updatedRegister;\\n\\n return true;\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(IStakeableNFT).interfaceId ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n New methods for the dictionary\\n */\\n\\n /**\\n * @notice It returns Base Loan Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenBaseLoanSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return baseLoanSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Token URI Hash for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenURIHash(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n string[] memory tierImageHashes = hashes[tokenTier];\\n return tierImageHashes[tokenId % (tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice It returns Contribution Asset for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionAsset(uint256 tokenId)\\n public\\n view\\n override\\n returns (address)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionAssets[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Multiplier for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionMultiplier(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint8)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionMultipliers[tokenTier];\\n }\\n}\\n\",\"keccak256\":\"0xf33e3fa1f609fdd2abb3b5fb9c232269d13363a3e4fa5697ea96269e361e74fa\"},\"contracts/nft/distributor/data.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant MINTER = keccak256(\\\"MINTER\\\");\\n\\nstruct MerkleRoot {\\n bytes32 merkleRoot;\\n uint256 tierIndex;\\n}\\n\\nstruct ClaimNFTRequest {\\n uint256 merkleIndex;\\n uint256 nodeIndex;\\n uint256 amount;\\n bytes32[] merkleProof;\\n}\\n\\nlibrary DistributorEvents {\\n event Claimed(address indexed account);\\n\\n event MerkleAdded(uint256 index);\\n}\\n\",\"keccak256\":\"0x3d0d14b0ed21ead3c29e3cd4195c5d40fb987bda0e6e4b61a60d8e2c5c1807c3\",\"license\":\"MIT\"},\"contracts/nft/distributor/entry/initialize.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"../store.sol\\\";\\nimport \\\"../../../contexts/initializable/modifiers/initializer.sol\\\";\\nimport \\\"../../../contexts/access-control/entry/grant-role.sol\\\";\\n\\n// Utils\\nimport { ADMIN } from \\\"../data.sol\\\";\\n\\n// Interfaces\\nimport \\\"../../ITellerNFT.sol\\\";\\nimport \\\"../../TellerNFTDictionary.sol\\\";\\n\\ncontract ent_initialize_NFTDistributor_v1 is\\n sto_NFTDistributor,\\n mod_initializer_Initializable_v1,\\n ent_grantRole_AccessControl_v1\\n{\\n /**\\n * @notice Initializes the Distributor contract with the TellerNFT\\n * @param _nft The address of the TellerNFT.\\n * @param admin The address of an admin.\\n */\\n function initialize(\\n address _nft,\\n address _dictionary,\\n address admin\\n ) external initializer {\\n distributorStore().nft = ITellerNFT(_nft);\\n distributorStore().dictionary = TellerNFTDictionary(_dictionary);\\n\\n _grantRole(ADMIN, admin);\\n }\\n}\\n\",\"keccak256\":\"0x82e8feea11a684dd32c4d510df19036182ed7cbfda95017428c3a433c1b1a324\",\"license\":\"MIT\"},\"contracts/nft/distributor/store.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport \\\"../ITellerNFT.sol\\\";\\nimport \\\"../TellerNFTDictionary.sol\\\";\\n\\n// Utils\\nimport { MerkleRoot } from \\\"./data.sol\\\";\\n\\nabstract contract sto_NFTDistributor {\\n struct DistributorStorage {\\n ITellerNFT nft;\\n MerkleRoot[] merkleRoots;\\n mapping(uint256 => mapping(uint256 => uint256)) claimedBitMap;\\n TellerNFTDictionary dictionary;\\n }\\n\\n bytes32 constant POSITION = keccak256(\\\"teller_nft.distributor\\\");\\n\\n function distributorStore()\\n internal\\n pure\\n returns (DistributorStorage storage s)\\n {\\n bytes32 P = POSITION;\\n assembly {\\n s.slot := P\\n }\\n }\\n}\\n\",\"keccak256\":\"0xc4b5c728c22c137e44c8b911105e45d0d85f42cb3a6a2ca31136cb4029d5fc7e\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "0x608060405234801561001057600080fd5b506103f8806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c80632f2ff15d1461003b578063c0c53b8b14610050575b600080fd5b61004e610049366004610397565b610063565b005b61004e61005e366004610355565b610107565b60008281527f337c29a31b05a860fb532911919dbe85ab303a7465176333f1deb496e9fdd19e6020908152604080832060010154835280832033845290915290205460ff166100f95760405162461bcd60e51b815260206004820152601860248201527f416363657373436f6e74726f6c3a206e6f742061646d696e000000000000000060448201526064015b60405180910390fd5b61010382826101fd565b5050565b61010f6102c6565b5460ff16156101605760405162461bcd60e51b815260206004820152601b60248201527f54656c6c65723a20616c726561647920696e697469616c697a6564000000000060448201526064016100f0565b7fcf1e960f2172c22b0a7308b10d2fa40d0d089ee0367c8e6cb72a5803f164c36080546001600160a01b038086166001600160a01b0319928316179092557fcf1e960f2172c22b0a7308b10d2fa40d0d089ee0367c8e6cb72a5803f164c3638054928516929091169190911790556101f87fdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42826101fd565b505050565b60008281527f337c29a31b05a860fb532911919dbe85ab303a7465176333f1deb496e9fdd19e602090815260408083206001600160a01b038516845290915290205460ff161561024c57610103565b60008281527f337c29a31b05a860fb532911919dbe85ab303a7465176333f1deb496e9fdd19e602090815260408083206001600160a01b0385168085529252808320805460ff1916600117905551339285917f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d9190a45050565b60008060405160200161031b9060208082526028908201527f74656c6c65725f70726f746f636f6c2e636f6e746578742e696e697469616c696040820152677a61626c652e763160c01b606082015260800190565b60408051601f19818403018152919052805160209091012092915050565b80356001600160a01b038116811461035057600080fd5b919050565b600080600060608486031215610369578283fd5b61037284610339565b925061038060208501610339565b915061038e60408501610339565b90509250925092565b600080604083850312156103a9578081fd5b823591506103b960208401610339565b9050925092905056fea264697066735822122042f4e63a508f4b722fa28200351f0ee16088e2422bd4209e4e338d02be7831c464736f6c63430008030033", + "deployedBytecode": "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", + "devdoc": { + "kind": "dev", + "methods": { + "initialize(address,address,address)": { + "params": { + "_nft": "The address of the TellerNFT.", + "admin": "The address of an admin." + } + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "grantRole(bytes32,address)": { + "notice": "Grants an address a new role. Requirements: - Sender must be role admin." + }, + "initialize(address,address,address)": { + "notice": "Initializes the Distributor contract with the TellerNFT" + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/ent_moveMerkle_NFTDistributor_v1.json b/deployments/polygon_mumbai/ent_moveMerkle_NFTDistributor_v1.json new file mode 100644 index 000000000..dae4d7aaf --- /dev/null +++ b/deployments/polygon_mumbai/ent_moveMerkle_NFTDistributor_v1.json @@ -0,0 +1,86 @@ +{ + "address": "0x32Cd9474007782d4EECDd320284E3a9851aE353f", + "abi": [ + { + "inputs": [ + { + "internalType": "uint256", + "name": "index", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "tierIndex", + "type": "uint256" + } + ], + "name": "moveMerkle", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "artifactName": "ent_moveMerkle_NFTDistributor_v1", + "transactionHash": "0x060fecb95876485825de17ff232ba792358df4d46c07fe15f6c9fb0867c8c384", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x32Cd9474007782d4EECDd320284E3a9851aE353f", + "transactionIndex": 0, + "gasUsed": "150697", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000002000000000000000000000000000000000000000000000000000800100000000000000040100000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000040000000004000000000000100000001000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0x3b7386b6b21912476aec12174583706a2d08ec807afd77480cf82fc098a8da53", + "transactionHash": "0x060fecb95876485825de17ff232ba792358df4d46c07fe15f6c9fb0867c8c384", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692299, + "transactionHash": "0x060fecb95876485825de17ff232ba792358df4d46c07fe15f6c9fb0867c8c384", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000c275dc8be39f50d12f66b6a63629c39da5bae5bd" + ], + "data": "0x00000000000000000000000000000000000000000000000000100fbe629c8c00000000000000000000000000000000000000000000000000504db6c4316c94000000000000000000000000000000000000000000000000b408c2c1e67597e5d5000000000000000000000000000000000000000000000000503da705ced008000000000000000000000000000000000000000000000000b408d2d1a4d83471d5", + "logIndex": 0, + "blockHash": "0x3b7386b6b21912476aec12174583706a2d08ec807afd77480cf82fc098a8da53" + } + ], + "blockNumber": 15692299, + "cumulativeGasUsed": "150697", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"tierIndex\",\"type\":\"uint256\"}],\"name\":\"moveMerkle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"moveMerkle(uint256,uint256)\":{\"params\":{\"index\":\"Index of merkle to set.\",\"tierIndex\":\"Index of NFT tier to assign merkle for. Requirements: - Caller must be an admin\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"moveMerkle(uint256,uint256)\":{\"notice\":\"Change a merkle to be for a different tier to be able to claim NFTs.\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/nft/distributor/entry/move-merkle.sol\":\"ent_moveMerkle_NFTDistributor_v1\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"contracts/contexts/access-control/data.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nstruct RoleData {\\n mapping(address => bool) members;\\n bytes32 adminRole;\\n}\\n\\nlibrary AccessControlEvents {\\n event OwnerSet(address indexed owner);\\n\\n event OwnerTransferred(address indexed owner, address indexed prevOwner);\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(\\n bytes32 indexed role,\\n bytes32 indexed previousAdminRole,\\n bytes32 indexed newAdminRole\\n );\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(\\n bytes32 indexed role,\\n address indexed account,\\n address indexed sender\\n );\\n}\\n\",\"keccak256\":\"0xe810f81cc2c393f9f7df19841cae3cb78ac914c5501238713d6c62192ac026a9\",\"license\":\"MIT\"},\"contracts/contexts/access-control/internal/has-role.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"../storage/roles.sol\\\";\\n\\nabstract contract int_hasRole_AccessControl_v1 is sto_AccessControl_Roles {\\n function _hasRole(bytes32 role, address account)\\n internal\\n view\\n returns (bool hasRole_)\\n {\\n hasRole_ = accessControlRolesStore().roles[role].members[account];\\n }\\n}\\n\",\"keccak256\":\"0x631c0c260f7de64c32a205405e3ec424a6b34aec27987ced91a0254fdabfb1a7\",\"license\":\"MIT\"},\"contracts/contexts/access-control/internal/require-authorization.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./has-role.sol\\\";\\n\\nabstract contract int_requireAuthorization_AccessControl_v1 is\\n int_hasRole_AccessControl_v1\\n{\\n function _requireAuthorization(bytes32 role, address account)\\n internal\\n view\\n {\\n require(_hasRole(role, account), \\\"AccessControl: unauthorized\\\");\\n }\\n}\\n\",\"keccak256\":\"0x5c3bc56480df5bf9e9d37962f00dc46ddd4df10e8eddcb45a8ad6c9538c86d67\",\"license\":\"MIT\"},\"contracts/contexts/access-control/modifiers/authorized.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport {\\n int_requireAuthorization_AccessControl_v1\\n} from \\\"../internal/require-authorization.sol\\\";\\n\\nabstract contract mod_authorized_AccessControl_v1 is\\n int_requireAuthorization_AccessControl_v1\\n{\\n modifier authorized(bytes32 role, address account) {\\n _requireAuthorization(role, account);\\n _;\\n }\\n}\\n\\nabstract contract mod_authorized_AccessControl is\\n mod_authorized_AccessControl_v1\\n{}\\n\",\"keccak256\":\"0x07b59ca25af7579afacf46fd29c611a89928dc3df8381f6a3dd5ba8ded407d61\",\"license\":\"MIT\"},\"contracts/contexts/access-control/storage/roles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport { RoleData } from \\\"../data.sol\\\";\\n\\ncontract sto_AccessControl_Roles {\\n bytes32 internal constant POS =\\n keccak256(\\\"teller_protocol.storage.access_control.roles\\\");\\n\\n struct AccessControlRolesStorage {\\n mapping(bytes32 => RoleData) roles;\\n }\\n\\n function accessControlRolesStore()\\n internal\\n pure\\n returns (AccessControlRolesStorage storage s)\\n {\\n bytes32 position = POS;\\n\\n assembly {\\n s.slot := position\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd3173b189dddc069a22ac5a5f2d411305846c9de523f8ce279b7219f2ee51470\",\"license\":\"MIT\"},\"contracts/nft/IStakeableNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IStakeableNFT {\\n function tokenBaseLoanSize(uint256 tokenId) external view returns (uint256);\\n\\n function tokenURIHash(uint256 tokenId)\\n external\\n view\\n returns (string memory);\\n\\n function tokenContributionAsset(uint256 tokenId)\\n external\\n view\\n returns (address);\\n\\n function tokenContributionSize(uint256 tokenId)\\n external\\n view\\n returns (uint256);\\n\\n function tokenContributionMultiplier(uint256 tokenId)\\n external\\n view\\n returns (uint8);\\n}\\n\",\"keccak256\":\"0xfbf44350ad91a54de26f39195d714580d7dade556ea4c7991a51eef5aa839105\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFTDictionary.sol\":{\"content\":\"/**\\n * @notice TellerNFTDictionary Version 1.02\\n *\\n * @notice This contract is used to gather data for TellerV1 NFTs more efficiently.\\n * @notice This contract has data which must be continuously synchronized with the TellerV1 NFT data\\n *\\n * @author develop@teller.finance\\n */\\n\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Interfaces\\nimport \\\"./IStakeableNFT.sol\\\";\\n\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFTDictionary is IStakeableNFT, AccessControlUpgradeable {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n mapping(uint256 => uint256) public baseLoanSizes;\\n mapping(uint256 => string[]) public hashes;\\n mapping(uint256 => address) public contributionAssets;\\n mapping(uint256 => uint256) public contributionSizes;\\n mapping(uint256 => uint8) public contributionMultipliers;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n\\n /* State Variables */\\n\\n mapping(uint256 => uint256) public _tokenTierMappingCompressed;\\n bool public _tokenTierMappingCompressedSet;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFTDictionary: not admin\\\");\\n _;\\n }\\n\\n function initialize(address initialAdmin) public {\\n _setupRole(ADMIN, initialAdmin);\\n _setRoleAdmin(ADMIN, ADMIN);\\n\\n __AccessControl_init();\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTierIndex(uint256 tokenId)\\n public\\n view\\n returns (uint8 index_)\\n {\\n //32 * 8 = 256 - each uint256 holds the data of 32 tokens . 8 bits each.\\n\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 compressedRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n //use 31 instead of 32 to account for the '0x' in the start.\\n //the '31 -' reverses our bytes order which is necessary\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint8 tierIndex = uint8((compressedRegister >> offset));\\n\\n return tierIndex;\\n }\\n\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory)\\n {\\n return hashes[tierIndex];\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTier(uint256 index, Tier memory newTier)\\n external\\n onlyAdmin\\n returns (bool)\\n {\\n baseLoanSizes[index] = newTier.baseLoanSize;\\n hashes[index] = newTier.hashes;\\n contributionAssets[index] = newTier.contributionAsset;\\n contributionSizes[index] = newTier.contributionSize;\\n contributionMultipliers[index] = newTier.contributionMultiplier;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param tiersMapping Information about the new tiers to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setAllTokenTierMappings(uint256[] memory tiersMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n require(\\n !_tokenTierMappingCompressedSet,\\n \\\"TellerNFTDictionary: token tier mapping already set\\\"\\n );\\n for (uint256 i = 0; i < tiersMapping.length; i++) {\\n _tokenTierMappingCompressed[i] = tiersMapping[i];\\n }\\n\\n _tokenTierMappingCompressedSet = true;\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param index the mapping row, each holds data for 32 tokens\\n * @param tierMapping Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierMapping(uint256 index, uint256 tierMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n _tokenTierMappingCompressed[index] = tierMapping;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenIds the NFT token Ids for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenIds(\\n uint256[] calldata tokenIds,\\n uint256 tokenTier\\n ) public onlyAdmin returns (bool) {\\n for (uint256 i; i < tokenIds.length; i++) {\\n setTokenTierForTokenId(tokenIds[i], tokenTier);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenId the NFT token Id for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenId(uint256 tokenId, uint256 tokenTier)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 existingRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint256 updateMaskShifted =\\n 0x00000000000000000000000000000000000000000000000000000000000000FF <<\\n offset;\\n\\n uint256 updateMaskShiftedNegated = ~updateMaskShifted;\\n\\n uint256 tokenTierShifted =\\n ((0x0000000000000000000000000000000000000000000000000000000000000000 |\\n tokenTier) << offset);\\n\\n uint256 existingRegisterClearedWithMask =\\n existingRegister & updateMaskShiftedNegated;\\n\\n uint256 updatedRegister =\\n existingRegisterClearedWithMask | tokenTierShifted;\\n\\n _tokenTierMappingCompressed[mappingIndex] = updatedRegister;\\n\\n return true;\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(IStakeableNFT).interfaceId ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n New methods for the dictionary\\n */\\n\\n /**\\n * @notice It returns Base Loan Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenBaseLoanSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return baseLoanSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Token URI Hash for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenURIHash(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n string[] memory tierImageHashes = hashes[tokenTier];\\n return tierImageHashes[tokenId % (tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice It returns Contribution Asset for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionAsset(uint256 tokenId)\\n public\\n view\\n override\\n returns (address)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionAssets[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Multiplier for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionMultiplier(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint8)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionMultipliers[tokenTier];\\n }\\n}\\n\",\"keccak256\":\"0xf33e3fa1f609fdd2abb3b5fb9c232269d13363a3e4fa5697ea96269e361e74fa\"},\"contracts/nft/distributor/data.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant MINTER = keccak256(\\\"MINTER\\\");\\n\\nstruct MerkleRoot {\\n bytes32 merkleRoot;\\n uint256 tierIndex;\\n}\\n\\nstruct ClaimNFTRequest {\\n uint256 merkleIndex;\\n uint256 nodeIndex;\\n uint256 amount;\\n bytes32[] merkleProof;\\n}\\n\\nlibrary DistributorEvents {\\n event Claimed(address indexed account);\\n\\n event MerkleAdded(uint256 index);\\n}\\n\",\"keccak256\":\"0x3d0d14b0ed21ead3c29e3cd4195c5d40fb987bda0e6e4b61a60d8e2c5c1807c3\",\"license\":\"MIT\"},\"contracts/nft/distributor/entry/move-merkle.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"../store.sol\\\";\\nimport \\\"../../../contexts/access-control/modifiers/authorized.sol\\\";\\n\\n// Utils\\nimport { DistributorEvents, ADMIN, MerkleRoot } from \\\"../data.sol\\\";\\n\\ncontract ent_moveMerkle_NFTDistributor_v1 is\\n sto_NFTDistributor,\\n mod_authorized_AccessControl_v1\\n{\\n /**\\n * @notice Change a merkle to be for a different tier to be able to claim NFTs.\\n * @param index Index of merkle to set.\\n * @param tierIndex Index of NFT tier to assign merkle for.\\n *\\n * Requirements:\\n * - Caller must be an admin\\n */\\n function moveMerkle(uint256 index, uint256 tierIndex)\\n external\\n authorized(ADMIN, msg.sender)\\n {\\n MerkleRoot storage merkle = distributorStore().merkleRoots[index];\\n merkle.tierIndex = tierIndex;\\n }\\n}\\n\",\"keccak256\":\"0x0e47277c70c01f65f5f89567a647c8d42cc3123cb466c1beffd8bbb436faab53\",\"license\":\"MIT\"},\"contracts/nft/distributor/store.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport \\\"../ITellerNFT.sol\\\";\\nimport \\\"../TellerNFTDictionary.sol\\\";\\n\\n// Utils\\nimport { MerkleRoot } from \\\"./data.sol\\\";\\n\\nabstract contract sto_NFTDistributor {\\n struct DistributorStorage {\\n ITellerNFT nft;\\n MerkleRoot[] merkleRoots;\\n mapping(uint256 => mapping(uint256 => uint256)) claimedBitMap;\\n TellerNFTDictionary dictionary;\\n }\\n\\n bytes32 constant POSITION = keccak256(\\\"teller_nft.distributor\\\");\\n\\n function distributorStore()\\n internal\\n pure\\n returns (DistributorStorage storage s)\\n {\\n bytes32 P = POSITION;\\n assembly {\\n s.slot := P\\n }\\n }\\n}\\n\",\"keccak256\":\"0xc4b5c728c22c137e44c8b911105e45d0d85f42cb3a6a2ca31136cb4029d5fc7e\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "0x608060405234801561001057600080fd5b506101c3806100206000396000f3fe608060405234801561001057600080fd5b506004361061002b5760003560e01c80637b8f569714610030575b600080fd5b61004361003e36600461016c565b610045565b005b7fdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec423361007182826100d3565b60007fcf1e960f2172c22b0a7308b10d2fa40d0d089ee0367c8e6cb72a5803f164c36060010185815481106100b657634e487b7160e01b600052603260045260246000fd5b600091825260209091206001600290920201019390935550505050565b60008281527f337c29a31b05a860fb532911919dbe85ab303a7465176333f1deb496e9fdd19e602090815260408083206001600160a01b038516845290915290205460ff166101685760405162461bcd60e51b815260206004820152601b60248201527f416363657373436f6e74726f6c3a20756e617574686f72697a65640000000000604482015260640160405180910390fd5b5050565b6000806040838503121561017e578182fd5b5050803592602090910135915056fea264697066735822122076a3cec80ed40f4c43780c70885bc1969d7ab6bd3c1e98789f8b7385a867863464736f6c63430008030033", + "deployedBytecode": "0x608060405234801561001057600080fd5b506004361061002b5760003560e01c80637b8f569714610030575b600080fd5b61004361003e36600461016c565b610045565b005b7fdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec423361007182826100d3565b60007fcf1e960f2172c22b0a7308b10d2fa40d0d089ee0367c8e6cb72a5803f164c36060010185815481106100b657634e487b7160e01b600052603260045260246000fd5b600091825260209091206001600290920201019390935550505050565b60008281527f337c29a31b05a860fb532911919dbe85ab303a7465176333f1deb496e9fdd19e602090815260408083206001600160a01b038516845290915290205460ff166101685760405162461bcd60e51b815260206004820152601b60248201527f416363657373436f6e74726f6c3a20756e617574686f72697a65640000000000604482015260640160405180910390fd5b5050565b6000806040838503121561017e578182fd5b5050803592602090910135915056fea264697066735822122076a3cec80ed40f4c43780c70885bc1969d7ab6bd3c1e98789f8b7385a867863464736f6c63430008030033", + "devdoc": { + "kind": "dev", + "methods": { + "moveMerkle(uint256,uint256)": { + "params": { + "index": "Index of merkle to set.", + "tierIndex": "Index of NFT tier to assign merkle for. Requirements: - Caller must be an admin" + } + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "moveMerkle(uint256,uint256)": { + "notice": "Change a merkle to be for a different tier to be able to claim NFTs." + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/ext_distributor_NFT_v1.json b/deployments/polygon_mumbai/ext_distributor_NFT_v1.json new file mode 100644 index 000000000..5fe99e338 --- /dev/null +++ b/deployments/polygon_mumbai/ext_distributor_NFT_v1.json @@ -0,0 +1,149 @@ +{ + "address": "0x3B6a45031041BAd9E3217D817Dccf92CD525Ad27", + "abi": [ + { + "inputs": [], + "name": "getMerkleRoots", + "outputs": [ + { + "components": [ + { + "internalType": "bytes32", + "name": "merkleRoot", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "tierIndex", + "type": "uint256" + } + ], + "internalType": "struct MerkleRoot[]", + "name": "roots_", + "type": "tuple[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "merkleIndex", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "nodeIndex", + "type": "uint256" + } + ], + "name": "isClaimed", + "outputs": [ + { + "internalType": "bool", + "name": "claimed_", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "nft", + "outputs": [ + { + "internalType": "contract ITellerNFT", + "name": "nft_", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + } + ], + "artifactName": "ext_distributor_NFT_v1", + "transactionHash": "0xf31cf06e9b1795a0c103831bcac5d147822883ffd195a0e05ca84daaccc5c52b", + "receipt": { + "to": null, + "from": "0xAFe87013dc96edE1E116a288D80FcaA0eFFE5fe5", + "contractAddress": "0x3B6a45031041BAd9E3217D817Dccf92CD525Ad27", + "transactionIndex": 0, + "gasUsed": "202507", + "logsBloom": "0x00000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000008000002000000000000000000000000000000000000000000000000000800100000000000000040100000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000040000000004000000000000100000001000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000100000", + "blockHash": "0x3abe05473efcafde86d5c34c0e84452d6326b75d21f1d185ae88565820975f1b", + "transactionHash": "0xf31cf06e9b1795a0c103831bcac5d147822883ffd195a0e05ca84daaccc5c52b", + "logs": [ + { + "transactionIndex": 0, + "blockNumber": 15692307, + "transactionHash": "0xf31cf06e9b1795a0c103831bcac5d147822883ffd195a0e05ca84daaccc5c52b", + "address": "0x0000000000000000000000000000000000001010", + "topics": [ + "0x4dfe1bbbcf077ddc3e01291eea2d5c70c2b422b415d95645b9adcfd678cb1d63", + "0x0000000000000000000000000000000000000000000000000000000000001010", + "0x000000000000000000000000afe87013dc96ede1e116a288d80fcaa0effe5fe5", + "0x000000000000000000000000c275dc8be39f50d12f66b6a63629c39da5bae5bd" + ], + "data": "0x0000000000000000000000000000000000000000000000000015955f0dfc64000000000000000000000000000000000000000000000000004fe601327d2f44000000000000000000000000000000000000000000000000b409322e7de03dc5d50000000000000000000000000000000000000000000000004fd06bd36f32e0000000000000000000000000000000000000000000000000b40947c3dcee3a29d5", + "logIndex": 0, + "blockHash": "0x3abe05473efcafde86d5c34c0e84452d6326b75d21f1d185ae88565820975f1b" + } + ], + "blockNumber": 15692307, + "cumulativeGasUsed": "202507", + "status": 1, + "byzantium": true + }, + "args": [], + "solcInputHash": "f7f185d0f2f1a27625ce9f4cd28bcad1", + "metadata": "{\"compiler\":{\"version\":\"0.8.3+commit.8d00100c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"getMerkleRoots\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"merkleRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"tierIndex\",\"type\":\"uint256\"}],\"internalType\":\"struct MerkleRoot[]\",\"name\":\"roots_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"merkleIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nodeIndex\",\"type\":\"uint256\"}],\"name\":\"isClaimed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"claimed_\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"nft\",\"outputs\":[{\"internalType\":\"contract ITellerNFT\",\"name\":\"nft_\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"getMerkleRoots()\":{\"returns\":{\"roots_\":\"returns the merkle\"}},\"isClaimed(uint256,uint256)\":{\"params\":{\"merkleIndex\":\"Index of the tier.\",\"nodeIndex\":\"Index of the node in the merkle root.\"},\"returns\":{\"claimed_\":\"returns a boolean to check if the tier has already been claimed\"}},\"nft()\":{\"returns\":{\"nft_\":\"returns the NFT instance\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"getMerkleRoots()\":{\"notice\":\"It gets the merkle roots for NFTs it can distribute.\"},\"isClaimed(uint256,uint256)\":{\"notice\":\"It checks the merkle root for a tier if it has already been claimed.\"},\"nft()\":{\"notice\":\"It gets the TellerNFT diamond instance used to mint.\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/nft/distributor/external/distributor.sol\":\"ext_distributor_NFT_v1\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n function grantRole(bytes32 role, address account) external;\\n function revokeRole(bytes32 role, address account) external;\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n function __AccessControl_init() internal initializer {\\n __Context_init_unchained();\\n __ERC165_init_unchained();\\n __AccessControl_init_unchained();\\n }\\n\\n function __AccessControl_init_unchained() internal initializer {\\n }\\n struct RoleData {\\n mapping (address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping (bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role, _msgSender());\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\\n || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view {\\n if(!hasRole(role, account)) {\\n revert(string(abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n StringsUpgradeable.toHexString(uint160(account), 20),\\n \\\" is missing role \\\",\\n StringsUpgradeable.toHexString(uint256(role), 32)\\n )));\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\\n _roles[role].adminRole = adminRole;\\n }\\n\\n function _grantRole(bytes32 role, address account) private {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n function _revokeRole(bytes32 role, address account) private {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x719f71989e630280a6902f857ef2b038d761ef2d0d51611f9da463be6c7c4be5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67d2f282a9678e58e878a0b774041ba7a01e2740a262aea97a3f681339914713\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal initializer {\\n __Context_init_unchained();\\n }\\n\\n function __Context_init_unchained() internal initializer {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return msg.data;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x8e9eb503de1189f50c5f16fef327da310b11898d6b9ab3ca937df07c35233b9e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n bytes16 private constant alphabet = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = alphabet[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n}\\n\",\"keccak256\":\"0x6964377da5c19ade6b3e96bae0c0e82494d518af70cf12d2cdb3276f78fb3d85\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n function __ERC165_init() internal initializer {\\n __ERC165_init_unchained();\\n }\\n\\n function __ERC165_init_unchained() internal initializer {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165Upgradeable).interfaceId;\\n }\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x17c9c5d2d6b56527215ee7b3da6dde66b6f23f1b3d5c66cc436e753ef349a97a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x1c4860acd323e34a67b3e97faab9aaa55fe8e92b1dcf08b5f47f3468d58ce75c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\\n}\\n\",\"keccak256\":\"0xc1c941ad1e580b4623007305921efe2f26fc7320a4edc226234dd707c658a428\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb8d11e77eb1ed34a33720edb551d7d6a6b0eee2bfaa40a7024020e1fdf879b16\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Trees proofs.\\n *\\n * The proofs can be generated using the JavaScript library\\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\\n *\\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n bytes32 computedHash = leaf;\\n\\n for (uint256 i = 0; i < proof.length; i++) {\\n bytes32 proofElement = proof[i];\\n\\n if (computedHash <= proofElement) {\\n // Hash(current computed hash + current element of the proof)\\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\\n } else {\\n // Hash(current element of the proof + current computed hash)\\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\\n }\\n }\\n\\n // Check if the computed hash (root) is equal to the provided root\\n return computedHash == root;\\n }\\n}\\n\",\"keccak256\":\"0xeee34bfb413657b6cd6c8e1e15c2080ba5ebaac479578515922804346fb63f7c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xa28007762d9da9db878dd421960c8cb9a10471f47ab5c1b3309bfe48e9e79ff4\",\"license\":\"MIT\"},\"contracts/nft/IStakeableNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IStakeableNFT {\\n function tokenBaseLoanSize(uint256 tokenId) external view returns (uint256);\\n\\n function tokenURIHash(uint256 tokenId)\\n external\\n view\\n returns (string memory);\\n\\n function tokenContributionAsset(uint256 tokenId)\\n external\\n view\\n returns (address);\\n\\n function tokenContributionSize(uint256 tokenId)\\n external\\n view\\n returns (uint256);\\n\\n function tokenContributionMultiplier(uint256 tokenId)\\n external\\n view\\n returns (uint8);\\n}\\n\",\"keccak256\":\"0xfbf44350ad91a54de26f39195d714580d7dade556ea4c7991a51eef5aa839105\",\"license\":\"MIT\"},\"contracts/nft/ITellerNFT.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma experimental ABIEncoderV2;\\n\\n// Interfaces\\nimport \\\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\\\";\\n\\ninterface ITellerNFT {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n /**\\n * @notice The contract metadata URI.\\n * @return the contractURI in string\\n */\\n function contractURI() external view returns (string memory);\\n\\n /**\\n * @notice It returns information about a Tier with from a tier index\\n * @param index Tier index to get info.\\n * @return tier_ the tier which belongs to the respective index\\n */\\n function getTier(uint256 index) external view returns (Tier memory tier_);\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n * @return index_ the index of the tier the tokenID belongs in\\n * @return tier_ the tier where the tokenID belongs in\\n */\\n function getTokenTier(uint256 tokenId)\\n external\\n view\\n returns (uint256 index_, Tier memory tier_);\\n\\n /**\\n * @notice It returns an array of hashes in a tier\\n * @param tierIndex the tier index to get the tier hashes\\n * @return hashes_ all the tokenID hashes\\n */\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory hashes_);\\n\\n /**\\n * @notice It returns an array of token IDs owned by an address.\\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\\n * @dev Can be costly if calling within a contract for address with many tokens.\\n * @return owned the array of tokenIDs owned by the address\\n */\\n function getOwnedTokens(address owner)\\n external\\n view\\n returns (uint256[] memory owned);\\n\\n /**\\n * @notice It mints a new token for a Tier index.\\n * @param tierIndex the tier index to mint the token in\\n * @param owner the owner of the new token\\n * Requirements:\\n * - Caller must be an authorized minter\\n */\\n function mint(uint256 tierIndex, address owner) external;\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {MINTER} role\\n */\\n function addTier(Tier memory newTier) external;\\n\\n /**\\n * @notice Sets the contract level metadata URI hash.\\n * @param contractURIHash The hash to the initial contract level metadata.\\n */\\n function setContractURIHash(string memory contractURIHash) external;\\n\\n /**\\n * @notice Initializes the TellerNFT.\\n * @param minters The addresses that should allowed to mint tokens.\\n */\\n function initialize(address[] calldata minters) external;\\n}\\n\",\"keccak256\":\"0x39eb585b176c0ed9b155976fb6396827902f68366c1a91d23548758058509288\",\"license\":\"MIT\"},\"contracts/nft/TellerNFTDictionary.sol\":{\"content\":\"/**\\n * @notice TellerNFTDictionary Version 1.02\\n *\\n * @notice This contract is used to gather data for TellerV1 NFTs more efficiently.\\n * @notice This contract has data which must be continuously synchronized with the TellerV1 NFT data\\n *\\n * @author develop@teller.finance\\n */\\n\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n// Interfaces\\nimport \\\"./IStakeableNFT.sol\\\";\\n\\n/**\\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\\n *\\n * @author develop@teller.finance\\n */\\ncontract TellerNFTDictionary is IStakeableNFT, AccessControlUpgradeable {\\n struct Tier {\\n uint256 baseLoanSize;\\n string[] hashes;\\n address contributionAsset;\\n uint256 contributionSize;\\n uint8 contributionMultiplier;\\n }\\n\\n mapping(uint256 => uint256) public baseLoanSizes;\\n mapping(uint256 => string[]) public hashes;\\n mapping(uint256 => address) public contributionAssets;\\n mapping(uint256 => uint256) public contributionSizes;\\n mapping(uint256 => uint8) public contributionMultipliers;\\n\\n /* Constants */\\n\\n bytes32 public constant ADMIN = keccak256(\\\"ADMIN\\\");\\n\\n /* State Variables */\\n\\n mapping(uint256 => uint256) public _tokenTierMappingCompressed;\\n bool public _tokenTierMappingCompressedSet;\\n\\n /* Modifiers */\\n\\n modifier onlyAdmin() {\\n require(hasRole(ADMIN, _msgSender()), \\\"TellerNFTDictionary: not admin\\\");\\n _;\\n }\\n\\n function initialize(address initialAdmin) public {\\n _setupRole(ADMIN, initialAdmin);\\n _setRoleAdmin(ADMIN, ADMIN);\\n\\n __AccessControl_init();\\n }\\n\\n /* External Functions */\\n\\n /**\\n * @notice It returns information about a Tier for a token ID.\\n * @param tokenId ID of the token to get Tier info.\\n */\\n function getTokenTierIndex(uint256 tokenId)\\n public\\n view\\n returns (uint8 index_)\\n {\\n //32 * 8 = 256 - each uint256 holds the data of 32 tokens . 8 bits each.\\n\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 compressedRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n //use 31 instead of 32 to account for the '0x' in the start.\\n //the '31 -' reverses our bytes order which is necessary\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint8 tierIndex = uint8((compressedRegister >> offset));\\n\\n return tierIndex;\\n }\\n\\n function getTierHashes(uint256 tierIndex)\\n external\\n view\\n returns (string[] memory)\\n {\\n return hashes[tierIndex];\\n }\\n\\n /**\\n * @notice Adds a new Tier to be minted with the given information.\\n * @dev It auto increments the index of the next tier to add.\\n * @param newTier Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTier(uint256 index, Tier memory newTier)\\n external\\n onlyAdmin\\n returns (bool)\\n {\\n baseLoanSizes[index] = newTier.baseLoanSize;\\n hashes[index] = newTier.hashes;\\n contributionAssets[index] = newTier.contributionAsset;\\n contributionSizes[index] = newTier.contributionSize;\\n contributionMultipliers[index] = newTier.contributionMultiplier;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param tiersMapping Information about the new tiers to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setAllTokenTierMappings(uint256[] memory tiersMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n require(\\n !_tokenTierMappingCompressedSet,\\n \\\"TellerNFTDictionary: token tier mapping already set\\\"\\n );\\n for (uint256 i = 0; i < tiersMapping.length; i++) {\\n _tokenTierMappingCompressed[i] = tiersMapping[i];\\n }\\n\\n _tokenTierMappingCompressedSet = true;\\n return true;\\n }\\n\\n /**\\n * @notice Sets the tiers for each tokenId using compressed data.\\n * @param index the mapping row, each holds data for 32 tokens\\n * @param tierMapping Information about the new tier to add.\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierMapping(uint256 index, uint256 tierMapping)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n _tokenTierMappingCompressed[index] = tierMapping;\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenIds the NFT token Ids for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenIds(\\n uint256[] calldata tokenIds,\\n uint256 tokenTier\\n ) public onlyAdmin returns (bool) {\\n for (uint256 i; i < tokenIds.length; i++) {\\n setTokenTierForTokenId(tokenIds[i], tokenTier);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @notice Sets a specific tier for a specific tokenId using compressed data.\\n * @param tokenId the NFT token Id for which to add data\\n * @param tokenTier the index of the tier that these tokenIds should have\\n *\\n * Requirements:\\n * - Caller must have the {Admin} role\\n */\\n function setTokenTierForTokenId(uint256 tokenId, uint256 tokenTier)\\n public\\n onlyAdmin\\n returns (bool)\\n {\\n uint256 mappingIndex = tokenId / 32;\\n\\n uint256 existingRegister = _tokenTierMappingCompressed[mappingIndex];\\n\\n uint256 offset = ((31 - (tokenId % 32)) * 8);\\n\\n uint256 updateMaskShifted =\\n 0x00000000000000000000000000000000000000000000000000000000000000FF <<\\n offset;\\n\\n uint256 updateMaskShiftedNegated = ~updateMaskShifted;\\n\\n uint256 tokenTierShifted =\\n ((0x0000000000000000000000000000000000000000000000000000000000000000 |\\n tokenTier) << offset);\\n\\n uint256 existingRegisterClearedWithMask =\\n existingRegister & updateMaskShiftedNegated;\\n\\n uint256 updatedRegister =\\n existingRegisterClearedWithMask | tokenTierShifted;\\n\\n _tokenTierMappingCompressed[mappingIndex] = updatedRegister;\\n\\n return true;\\n }\\n\\n function supportsInterface(bytes4 interfaceId)\\n public\\n view\\n override(AccessControlUpgradeable)\\n returns (bool)\\n {\\n return\\n interfaceId == type(IStakeableNFT).interfaceId ||\\n AccessControlUpgradeable.supportsInterface(interfaceId);\\n }\\n\\n /**\\n New methods for the dictionary\\n */\\n\\n /**\\n * @notice It returns Base Loan Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenBaseLoanSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return baseLoanSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Token URI Hash for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenURIHash(uint256 tokenId)\\n public\\n view\\n override\\n returns (string memory)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n string[] memory tierImageHashes = hashes[tokenTier];\\n return tierImageHashes[tokenId % (tierImageHashes.length)];\\n }\\n\\n /**\\n * @notice It returns Contribution Asset for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionAsset(uint256 tokenId)\\n public\\n view\\n override\\n returns (address)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionAssets[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Size for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionSize(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint256)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionSizes[tokenTier];\\n }\\n\\n /**\\n * @notice It returns Contribution Multiplier for a token ID.\\n * @param tokenId ID of the token to get info.\\n */\\n function tokenContributionMultiplier(uint256 tokenId)\\n public\\n view\\n override\\n returns (uint8)\\n {\\n uint8 tokenTier = getTokenTierIndex(tokenId);\\n\\n return contributionMultipliers[tokenTier];\\n }\\n}\\n\",\"keccak256\":\"0xf33e3fa1f609fdd2abb3b5fb9c232269d13363a3e4fa5697ea96269e361e74fa\"},\"contracts/nft/distributor/data.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nbytes32 constant ADMIN = keccak256(\\\"ADMIN\\\");\\nbytes32 constant MINTER = keccak256(\\\"MINTER\\\");\\n\\nstruct MerkleRoot {\\n bytes32 merkleRoot;\\n uint256 tierIndex;\\n}\\n\\nstruct ClaimNFTRequest {\\n uint256 merkleIndex;\\n uint256 nodeIndex;\\n uint256 amount;\\n bytes32[] merkleProof;\\n}\\n\\nlibrary DistributorEvents {\\n event Claimed(address indexed account);\\n\\n event MerkleAdded(uint256 index);\\n}\\n\",\"keccak256\":\"0x3d0d14b0ed21ead3c29e3cd4195c5d40fb987bda0e6e4b61a60d8e2c5c1807c3\",\"license\":\"MIT\"},\"contracts/nft/distributor/external/distributor.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"../store.sol\\\";\\nimport \\\"../internal/distributor.sol\\\";\\n\\ncontract ext_distributor_NFT_v1 is sto_NFTDistributor, int_distributor_NFT_v1 {\\n /**\\n * @notice It gets the TellerNFT diamond instance used to mint.\\n * @return nft_ returns the NFT instance\\n */\\n function nft() external view returns (ITellerNFT nft_) {\\n nft_ = distributorStore().nft;\\n }\\n\\n /**\\n * @notice It gets the merkle roots for NFTs it can distribute.\\n * @return roots_ returns the merkle\\n */\\n function getMerkleRoots()\\n external\\n view\\n returns (MerkleRoot[] memory roots_)\\n {\\n roots_ = distributorStore().merkleRoots;\\n }\\n\\n /**\\n * @notice It checks the merkle root for a tier if it has already been claimed.\\n * @param merkleIndex Index of the tier.\\n * @param nodeIndex Index of the node in the merkle root.\\n * @return claimed_ returns a boolean to check if the tier has already been claimed\\n */\\n function isClaimed(uint256 merkleIndex, uint256 nodeIndex)\\n external\\n view\\n returns (bool claimed_)\\n {\\n claimed_ = _isClaimed(merkleIndex, nodeIndex);\\n }\\n}\\n\\ncontract ext_distributor_NFT is ext_distributor_NFT_v1 {}\\n\",\"keccak256\":\"0x74d1ccf5ef13fb7ef3819fd5de4faa02eedbe422dcac651722e44d702d543aac\",\"license\":\"MIT\"},\"contracts/nft/distributor/internal/distributor.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Contracts\\nimport \\\"../store.sol\\\";\\n\\n// Libraries\\nimport \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\n\\n// Utils\\nimport { ClaimNFTRequest } from \\\"../data.sol\\\";\\n\\ncontract int_distributor_NFT_v1 is sto_NFTDistributor {\\n /**\\n * @notice It checks the merkle root for a tier if it has already been claimed.\\n * @param merkleIndex Index of the tier.\\n * @param nodeIndex Index of the node in the merkle root.\\n */\\n function _setClaimed(uint256 merkleIndex, uint256 nodeIndex) internal {\\n uint256 claimedWordIndex = nodeIndex / 256;\\n uint256 claimedBitIndex = nodeIndex % 256;\\n distributorStore().claimedBitMap[merkleIndex][claimedWordIndex] =\\n distributorStore().claimedBitMap[merkleIndex][claimedWordIndex] |\\n (1 << claimedBitIndex);\\n }\\n\\n /**\\n * @notice It checks the merkle root for a tier if it has already been claimed.\\n * @param merkleIndex Index of the tier.\\n * @param nodeIndex Index of the node in the merkle root.\\n * @return claimed_ returns a boolean to check if the tier has already been claimed\\n */\\n function _isClaimed(uint256 merkleIndex, uint256 nodeIndex)\\n internal\\n view\\n returns (bool)\\n {\\n uint256 claimedWordIndex = nodeIndex / 256;\\n uint256 claimedBitIndex = nodeIndex % 256;\\n uint256 claimedWord =\\n distributorStore().claimedBitMap[merkleIndex][claimedWordIndex];\\n uint256 mask = (1 << claimedBitIndex);\\n return claimedWord & mask == mask;\\n }\\n\\n /**\\n * @notice it verifies the request's merkle proof with the merkle root in order to claim an NFT\\n * @param account the account's address to be hashed and verified with the claim\\n * @param request the request with the merkle proof to verify\\n */\\n function _verifyProof(address account, ClaimNFTRequest memory request)\\n internal\\n view\\n returns (bool verified)\\n {\\n verified = MerkleProof.verify(\\n request.merkleProof,\\n distributorStore().merkleRoots[request.merkleIndex].merkleRoot,\\n keccak256(\\n abi.encodePacked(request.nodeIndex, account, request.amount)\\n )\\n );\\n }\\n}\\n\",\"keccak256\":\"0x72f48bd977226301a39bb5a351f63fc5b3019b49df4cc7d9f1af22738cb99938\",\"license\":\"MIT\"},\"contracts/nft/distributor/store.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\n// Interfaces\\nimport \\\"../ITellerNFT.sol\\\";\\nimport \\\"../TellerNFTDictionary.sol\\\";\\n\\n// Utils\\nimport { MerkleRoot } from \\\"./data.sol\\\";\\n\\nabstract contract sto_NFTDistributor {\\n struct DistributorStorage {\\n ITellerNFT nft;\\n MerkleRoot[] merkleRoots;\\n mapping(uint256 => mapping(uint256 => uint256)) claimedBitMap;\\n TellerNFTDictionary dictionary;\\n }\\n\\n bytes32 constant POSITION = keccak256(\\\"teller_nft.distributor\\\");\\n\\n function distributorStore()\\n internal\\n pure\\n returns (DistributorStorage storage s)\\n {\\n bytes32 P = POSITION;\\n assembly {\\n s.slot := P\\n }\\n }\\n}\\n\",\"keccak256\":\"0xc4b5c728c22c137e44c8b911105e45d0d85f42cb3a6a2ca31136cb4029d5fc7e\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "0x608060405234801561001057600080fd5b506102b3806100206000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c806347ccca021461004657806385135a1a14610085578063f364c90c1461009a575b600080fd5b7fcf1e960f2172c22b0a7308b10d2fa40d0d089ee0367c8e6cb72a5803f164c360546040516001600160a01b0390911681526020015b60405180910390f35b61008d6100bd565b60405161007c91906101f0565b6100ad6100a83660046101cf565b610152565b604051901515815260200161007c565b60607fcf1e960f2172c22b0a7308b10d2fa40d0d089ee0367c8e6cb72a5803f164c360600101805480602002602001604051908101604052809291908181526020016000905b8282101561014957838290600052602060002090600202016040518060400160405290816000820154815260200160018201548152505081526020019060010190610103565b50505050905090565b600061015e8383610165565b9392505050565b6000806101746101008461023f565b9050600061018461010085610253565b60009586527fcf1e960f2172c22b0a7308b10d2fa40d0d089ee0367c8e6cb72a5803f164c362602090815260408088209488529390529190942054600190911b908116149392505050565b600080604083850312156101e1578182fd5b50508035926020909101359150565b602080825282518282018190526000919060409081850190868401855b828110156102325781518051855286015186850152928401929085019060010161020d565b5091979650505050505050565b60008261024e5761024e610267565b500490565b60008261026257610262610267565b500690565b634e487b7160e01b600052601260045260246000fdfea26469706673582212205704a687306b0402a26a8d54d15823904c9b54804452856dec8b7a14bab32cf964736f6c63430008030033", + "deployedBytecode": "0x608060405234801561001057600080fd5b50600436106100415760003560e01c806347ccca021461004657806385135a1a14610085578063f364c90c1461009a575b600080fd5b7fcf1e960f2172c22b0a7308b10d2fa40d0d089ee0367c8e6cb72a5803f164c360546040516001600160a01b0390911681526020015b60405180910390f35b61008d6100bd565b60405161007c91906101f0565b6100ad6100a83660046101cf565b610152565b604051901515815260200161007c565b60607fcf1e960f2172c22b0a7308b10d2fa40d0d089ee0367c8e6cb72a5803f164c360600101805480602002602001604051908101604052809291908181526020016000905b8282101561014957838290600052602060002090600202016040518060400160405290816000820154815260200160018201548152505081526020019060010190610103565b50505050905090565b600061015e8383610165565b9392505050565b6000806101746101008461023f565b9050600061018461010085610253565b60009586527fcf1e960f2172c22b0a7308b10d2fa40d0d089ee0367c8e6cb72a5803f164c362602090815260408088209488529390529190942054600190911b908116149392505050565b600080604083850312156101e1578182fd5b50508035926020909101359150565b602080825282518282018190526000919060409081850190868401855b828110156102325781518051855286015186850152928401929085019060010161020d565b5091979650505050505050565b60008261024e5761024e610267565b500490565b60008261026257610262610267565b500690565b634e487b7160e01b600052601260045260246000fdfea26469706673582212205704a687306b0402a26a8d54d15823904c9b54804452856dec8b7a14bab32cf964736f6c63430008030033", + "devdoc": { + "kind": "dev", + "methods": { + "getMerkleRoots()": { + "returns": { + "roots_": "returns the merkle" + } + }, + "isClaimed(uint256,uint256)": { + "params": { + "merkleIndex": "Index of the tier.", + "nodeIndex": "Index of the node in the merkle root." + }, + "returns": { + "claimed_": "returns a boolean to check if the tier has already been claimed" + } + }, + "nft()": { + "returns": { + "nft_": "returns the NFT instance" + } + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "getMerkleRoots()": { + "notice": "It gets the merkle roots for NFTs it can distribute." + }, + "isClaimed(uint256,uint256)": { + "notice": "It checks the merkle root for a tier if it has already been claimed." + }, + "nft()": { + "notice": "It gets the TellerNFT diamond instance used to mint." + } + }, + "version": 1 + }, + "storageLayout": { + "storage": [], + "types": null + } +} diff --git a/deployments/polygon_mumbai/solcInputs/1635d55d57a0a2552952c0d22586ed23.json b/deployments/polygon_mumbai/solcInputs/1635d55d57a0a2552952c0d22586ed23.json new file mode 100644 index 000000000..6272d8cbd --- /dev/null +++ b/deployments/polygon_mumbai/solcInputs/1635d55d57a0a2552952c0d22586ed23.json @@ -0,0 +1,54 @@ +{ + "language": "Solidity", + "sources": { + "solc_0.7/openzeppelin/access/Ownable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\nimport \"../GSN/Context.sol\";\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\ncontract Ownable is Context {\n address private _owner;\n\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Initializes the contract setting the deployer as the initial owner.\n */\n constructor (address initialOwner) {\n _owner = initialOwner;\n emit OwnershipTransferred(address(0), initialOwner);\n }\n\n /**\n * @dev Returns the address of the current owner.\n */\n function owner() public view returns (address) {\n return _owner;\n }\n\n /**\n * @dev Throws if called by any account other than the owner.\n */\n modifier onlyOwner() {\n require(_owner == _msgSender(), \"Ownable: caller is not the owner\");\n _;\n }\n\n /**\n * @dev Leaves the contract without owner. It will not be possible to call\n * `onlyOwner` functions anymore. Can only be called by the current owner.\n *\n * NOTE: Renouncing ownership will leave the contract without an owner,\n * thereby removing any functionality that is only available to the owner.\n */\n function renounceOwnership() public virtual onlyOwner {\n emit OwnershipTransferred(_owner, address(0));\n _owner = address(0);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) public virtual onlyOwner {\n require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n emit OwnershipTransferred(_owner, newOwner);\n _owner = newOwner;\n }\n}\n" + }, + "solc_0.7/openzeppelin/GSN/Context.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\n/*\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with GSN meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n function _msgSender() internal view virtual returns (address payable) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes memory) {\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\n return msg.data;\n }\n}\n" + }, + "solc_0.7/openzeppelin/proxy/ProxyAdmin.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\nimport \"../access/Ownable.sol\";\nimport \"./TransparentUpgradeableProxy.sol\";\n\n/**\n * @dev This is an auxiliary contract meant to be assigned as the admin of a {TransparentUpgradeableProxy}. For an\n * explanation of why you would want to use this see the documentation for {TransparentUpgradeableProxy}.\n */\ncontract ProxyAdmin is Ownable {\n\n constructor(address owner) Ownable(owner) {}\n\n /**\n * @dev Returns the current implementation of `proxy`.\n *\n * Requirements:\n *\n * - This contract must be the admin of `proxy`.\n */\n function getProxyImplementation(TransparentUpgradeableProxy proxy) public view returns (address) {\n // We need to manually run the static call since the getter cannot be flagged as view\n // bytes4(keccak256(\"implementation()\")) == 0x5c60da1b\n (bool success, bytes memory returndata) = address(proxy).staticcall(hex\"5c60da1b\");\n require(success);\n return abi.decode(returndata, (address));\n }\n\n /**\n * @dev Returns the current admin of `proxy`.\n *\n * Requirements:\n *\n * - This contract must be the admin of `proxy`.\n */\n function getProxyAdmin(TransparentUpgradeableProxy proxy) public view returns (address) {\n // We need to manually run the static call since the getter cannot be flagged as view\n // bytes4(keccak256(\"admin()\")) == 0xf851a440\n (bool success, bytes memory returndata) = address(proxy).staticcall(hex\"f851a440\");\n require(success);\n return abi.decode(returndata, (address));\n }\n\n /**\n * @dev Changes the admin of `proxy` to `newAdmin`.\n *\n * Requirements:\n *\n * - This contract must be the current admin of `proxy`.\n */\n function changeProxyAdmin(TransparentUpgradeableProxy proxy, address newAdmin) public onlyOwner {\n proxy.changeAdmin(newAdmin);\n }\n\n /**\n * @dev Upgrades `proxy` to `implementation`. See {TransparentUpgradeableProxy-upgradeTo}.\n *\n * Requirements:\n *\n * - This contract must be the admin of `proxy`.\n */\n function upgrade(TransparentUpgradeableProxy proxy, address implementation) public onlyOwner {\n proxy.upgradeTo(implementation);\n }\n\n /**\n * @dev Upgrades `proxy` to `implementation` and calls a function on the new implementation. See\n * {TransparentUpgradeableProxy-upgradeToAndCall}.\n *\n * Requirements:\n *\n * - This contract must be the admin of `proxy`.\n */\n function upgradeAndCall(TransparentUpgradeableProxy proxy, address implementation, bytes memory data) public payable onlyOwner {\n proxy.upgradeToAndCall{value: msg.value}(implementation, data);\n }\n}\n" + }, + "solc_0.7/openzeppelin/proxy/TransparentUpgradeableProxy.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\nimport \"./UpgradeableProxy.sol\";\n\n/**\n * @dev This contract implements a proxy that is upgradeable by an admin.\n * \n * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector\n * clashing], which can potentially be used in an attack, this contract uses the\n * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two\n * things that go hand in hand:\n * \n * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if\n * that call matches one of the admin functions exposed by the proxy itself.\n * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the\n * implementation. If the admin tries to call a function on the implementation it will fail with an error that says\n * \"admin cannot fallback to proxy target\".\n * \n * These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing\n * the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due\n * to sudden errors when trying to call a function from the proxy implementation.\n * \n * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way,\n * you should think of the `ProxyAdmin` instance as the real administrative inerface of your proxy.\n */\ncontract TransparentUpgradeableProxy is UpgradeableProxy {\n /**\n * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and\n * optionally initialized with `_data` as explained in {UpgradeableProxy-constructor}.\n */\n constructor(address initialLogic, address initialAdmin, bytes memory _data) payable UpgradeableProxy(initialLogic, _data) {\n assert(_ADMIN_SLOT == bytes32(uint256(keccak256(\"eip1967.proxy.admin\")) - 1));\n _setAdmin(initialAdmin);\n }\n\n /**\n * @dev Emitted when the admin account has changed.\n */\n event AdminChanged(address previousAdmin, address newAdmin);\n\n /**\n * @dev Storage slot with the admin of the contract.\n * This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 private constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\n\n /**\n * @dev Modifier used internally that will delegate the call to the implementation unless the sender is the admin.\n */\n modifier ifAdmin() {\n if (msg.sender == _admin()) {\n _;\n } else {\n _fallback();\n }\n }\n\n /**\n * @dev Returns the current admin.\n * \n * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}.\n * \n * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the\n * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\n * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`\n */\n function admin() external ifAdmin returns (address) {\n return _admin();\n }\n\n /**\n * @dev Returns the current implementation.\n * \n * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}.\n * \n * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the\n * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\n * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`\n */\n function implementation() external ifAdmin returns (address) {\n return _implementation();\n }\n\n /**\n * @dev Changes the admin of the proxy.\n * \n * Emits an {AdminChanged} event.\n * \n * NOTE: Only the admin can call this function. See {ProxyAdmin-changeProxyAdmin}.\n */\n function changeAdmin(address newAdmin) external ifAdmin {\n require(newAdmin != address(0), \"TransparentUpgradeableProxy: new admin is the zero address\");\n emit AdminChanged(_admin(), newAdmin);\n _setAdmin(newAdmin);\n }\n\n /**\n * @dev Upgrade the implementation of the proxy.\n * \n * NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}.\n */\n function upgradeTo(address newImplementation) external ifAdmin {\n _upgradeTo(newImplementation);\n }\n\n /**\n * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified\n * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the\n * proxied contract.\n * \n * NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}.\n */\n function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {\n _upgradeTo(newImplementation);\n // solhint-disable-next-line avoid-low-level-calls\n (bool success,) = newImplementation.delegatecall(data);\n require(success);\n }\n\n /**\n * @dev Returns the current admin.\n */\n function _admin() internal view returns (address adm) {\n bytes32 slot = _ADMIN_SLOT;\n // solhint-disable-next-line no-inline-assembly\n assembly {\n adm := sload(slot)\n }\n }\n\n /**\n * @dev Stores a new address in the EIP1967 admin slot.\n */\n function _setAdmin(address newAdmin) private {\n bytes32 slot = _ADMIN_SLOT;\n\n // solhint-disable-next-line no-inline-assembly\n assembly {\n sstore(slot, newAdmin)\n }\n }\n\n /**\n * @dev Makes sure the admin cannot access the fallback function. See {Proxy-_beforeFallback}.\n */\n function _beforeFallback() internal override virtual {\n require(msg.sender != _admin(), \"TransparentUpgradeableProxy: admin cannot fallback to proxy target\");\n super._beforeFallback();\n }\n}\n" + }, + "solc_0.7/openzeppelin/proxy/UpgradeableProxy.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\nimport \"./Proxy.sol\";\nimport \"../utils/Address.sol\";\n\n/**\n * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an\n * implementation address that can be changed. This address is stored in storage in the location specified by\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the\n * implementation behind the proxy.\n * \n * Upgradeability is only provided internally through {_upgradeTo}. For an externally upgradeable proxy see\n * {TransparentUpgradeableProxy}.\n */\ncontract UpgradeableProxy is Proxy {\n /**\n * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.\n * \n * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded\n * function call, and allows initializating the storage of the proxy like a Solidity constructor.\n */\n constructor(address _logic, bytes memory _data) payable {\n assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256(\"eip1967.proxy.implementation\")) - 1));\n _setImplementation(_logic);\n if(_data.length > 0) {\n // solhint-disable-next-line avoid-low-level-calls\n (bool success,) = _logic.delegatecall(_data);\n require(success);\n }\n }\n\n /**\n * @dev Emitted when the implementation is upgraded.\n */\n event Upgraded(address indexed implementation);\n\n /**\n * @dev Storage slot with the address of the current implementation.\n * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 private constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n /**\n * @dev Returns the current implementation address.\n */\n function _implementation() internal override view returns (address impl) {\n bytes32 slot = _IMPLEMENTATION_SLOT;\n // solhint-disable-next-line no-inline-assembly\n assembly {\n impl := sload(slot)\n }\n }\n\n /**\n * @dev Upgrades the proxy to a new implementation.\n * \n * Emits an {Upgraded} event.\n */\n function _upgradeTo(address newImplementation) internal {\n _setImplementation(newImplementation);\n emit Upgraded(newImplementation);\n }\n\n /**\n * @dev Stores a new address in the EIP1967 implementation slot.\n */\n function _setImplementation(address newImplementation) private {\n require(Address.isContract(newImplementation), \"UpgradeableProxy: new implementation is not a contract\");\n\n bytes32 slot = _IMPLEMENTATION_SLOT;\n\n // solhint-disable-next-line no-inline-assembly\n assembly {\n sstore(slot, newImplementation)\n }\n }\n}\n" + }, + "solc_0.7/openzeppelin/proxy/Proxy.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\n/**\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\n * be specified by overriding the virtual {_implementation} function.\n * \n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\n * different contract through the {_delegate} function.\n * \n * The success and return data of the delegated call will be returned back to the caller of the proxy.\n */\nabstract contract Proxy {\n /**\n * @dev Delegates the current call to `implementation`.\n * \n * This function does not return to its internall call site, it will return directly to the external caller.\n */\n function _delegate(address implementation) internal {\n // solhint-disable-next-line no-inline-assembly\n assembly {\n // Copy msg.data. We take full control of memory in this inline assembly\n // block because it will not return to Solidity code. We overwrite the\n // Solidity scratch pad at memory position 0.\n calldatacopy(0, 0, calldatasize())\n\n // Call the implementation.\n // out and outsize are 0 because we don't know the size yet.\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\n\n // Copy the returned data.\n returndatacopy(0, 0, returndatasize())\n\n switch result\n // delegatecall returns 0 on error.\n case 0 { revert(0, returndatasize()) }\n default { return(0, returndatasize()) }\n }\n }\n\n /**\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\n * and {_fallback} should delegate.\n */\n function _implementation() internal virtual view returns (address);\n\n /**\n * @dev Delegates the current call to the address returned by `_implementation()`.\n * \n * This function does not return to its internall call site, it will return directly to the external caller.\n */\n function _fallback() internal {\n _beforeFallback();\n _delegate(_implementation());\n }\n\n /**\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\n * function in the contract matches the call data.\n */\n fallback () payable external {\n _fallback();\n }\n\n /**\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\n * is empty.\n */\n receive () payable external {\n _fallback();\n }\n\n /**\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\n * call, or as part of the Solidity `fallback` or `receive` functions.\n * \n * If overriden should call `super._beforeFallback()`.\n */\n function _beforeFallback() internal virtual {\n }\n}\n" + }, + "solc_0.7/openzeppelin/utils/Address.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // According to EIP-1052, 0x0 is the value returned for not-yet created accounts\n // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned\n // for accounts without code, i.e. `keccak256('')`\n bytes32 codehash;\n bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;\n // solhint-disable-next-line no-inline-assembly\n assembly { codehash := extcodehash(account) }\n return (codehash != accountHash && codehash != 0x0);\n }\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\n (bool success, ) = recipient.call{ value: amount }(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain`call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCall(target, data, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\n return _functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n return _functionCallWithValue(target, data, value, errorMessage);\n }\n\n function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {\n require(isContract(target), \"Address: call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);\n if (success) {\n return returndata;\n } else {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n }\n}\n" + }, + "solc_0.7/proxy/OptimizedTransparentUpgradeableProxy.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.7.0;\n\nimport \"../openzeppelin/proxy/UpgradeableProxy.sol\";\n\n/**\n * @dev This contract implements a proxy that is upgradeable by an admin.\n *\n * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector\n * clashing], which can potentially be used in an attack, this contract uses the\n * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two\n * things that go hand in hand:\n *\n * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if\n * that call matches one of the admin functions exposed by the proxy itself.\n * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the\n * implementation. If the admin tries to call a function on the implementation it will fail with an error that says\n * \"admin cannot fallback to proxy target\".\n *\n * These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing\n * the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due\n * to sudden errors when trying to call a function from the proxy implementation.\n *\n * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way,\n * you should think of the `ProxyAdmin` instance as the real administrative inerface of your proxy.\n */\ncontract OptimizedTransparentUpgradeableProxy is UpgradeableProxy {\n address internal immutable _ADMIN;\n\n /**\n * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and\n * optionally initialized with `_data` as explained in {UpgradeableProxy-constructor}.\n */\n constructor(\n address initialLogic,\n address initialAdmin,\n bytes memory _data\n ) payable UpgradeableProxy(initialLogic, _data) {\n assert(_ADMIN_SLOT == bytes32(uint256(keccak256(\"eip1967.proxy.admin\")) - 1));\n bytes32 slot = _ADMIN_SLOT;\n\n _ADMIN = initialAdmin;\n\n // still store it to work with EIP-1967\n // solhint-disable-next-line no-inline-assembly\n assembly {\n sstore(slot, initialAdmin)\n }\n }\n\n /**\n * @dev Storage slot with the admin of the contract.\n * This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 private constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\n\n /**\n * @dev Modifier used internally that will delegate the call to the implementation unless the sender is the admin.\n */\n modifier ifAdmin() {\n if (msg.sender == _admin()) {\n _;\n } else {\n _fallback();\n }\n }\n\n /**\n * @dev Returns the current admin.\n *\n * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}.\n *\n * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the\n * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\n * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`\n */\n function admin() external ifAdmin returns (address) {\n return _admin();\n }\n\n /**\n * @dev Returns the current implementation.\n *\n * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}.\n *\n * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the\n * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\n * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`\n */\n function implementation() external ifAdmin returns (address) {\n return _implementation();\n }\n\n /**\n * @dev Upgrade the implementation of the proxy.\n *\n * NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}.\n */\n function upgradeTo(address newImplementation) external ifAdmin {\n _upgradeTo(newImplementation);\n }\n\n /**\n * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified\n * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the\n * proxied contract.\n *\n * NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}.\n */\n function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {\n _upgradeTo(newImplementation);\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, ) = newImplementation.delegatecall(data);\n require(success);\n }\n\n /**\n * @dev Returns the current admin.\n */\n function _admin() internal view returns (address adm) {\n return _ADMIN;\n }\n\n /**\n * @dev Makes sure the admin cannot access the fallback function. See {Proxy-_beforeFallback}.\n */\n function _beforeFallback() internal virtual override {\n require(msg.sender != _admin(), \"TransparentUpgradeableProxy: admin cannot fallback to proxy target\");\n super._beforeFallback();\n }\n}\n" + } + }, + "settings": { + "optimizer": { + "enabled": true, + "runs": 999999 + }, + "outputSelection": { + "*": { + "*": [ + "abi", + "evm.bytecode", + "evm.deployedBytecode", + "evm.methodIdentifiers", + "metadata", + "devdoc", + "userdoc", + "storageLayout", + "evm.gasEstimates" + ], + "": ["ast"] + } + }, + "metadata": { + "useLiteralContent": true + } + } +} diff --git a/deployments/polygon_mumbai/solcInputs/1d060b65b8264d57d416f20cb1fe798a.json b/deployments/polygon_mumbai/solcInputs/1d060b65b8264d57d416f20cb1fe798a.json new file mode 100644 index 000000000..24a1449eb --- /dev/null +++ b/deployments/polygon_mumbai/solcInputs/1d060b65b8264d57d416f20cb1fe798a.json @@ -0,0 +1,60 @@ +{ + "language": "Solidity", + "sources": { + "solc_0.7/diamond/Diamantaire.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.7.1;\npragma experimental ABIEncoderV2;\n\nimport \"./interfaces/IDiamondCut.sol\";\nimport \"./Diamond.sol\";\nimport \"./facets/DiamondCutFacet.sol\";\nimport \"./facets/DiamondLoupeFacet.sol\";\nimport \"./facets/OwnershipFacet.sol\";\n\ncontract Diamantaire {\n event DiamondCreated(Diamond diamond);\n\n IDiamondCut.FacetCut[] internal _builtinDiamondCut;\n\n constructor() {\n bytes4[] memory functionSelectors;\n\n // -------------------------------------------------------------------------\n // adding diamondCut function\n // -------------------------------------------------------------------------\n DiamondCutFacet diamondCutFacet = new DiamondCutFacet();\n\n functionSelectors = new bytes4[](1);\n functionSelectors[0] = DiamondCutFacet.diamondCut.selector;\n _builtinDiamondCut.push(IDiamondCut.FacetCut({\n facetAddress:address(diamondCutFacet),\n action: IDiamondCut.FacetCutAction.Add,\n functionSelectors: functionSelectors\n }));\n\n\n // -------------------------------------------------------------------------\n // adding diamond loupe functions\n // -------------------------------------------------------------------------\n DiamondLoupeFacet diamondLoupeFacet = new DiamondLoupeFacet();\n\n functionSelectors = new bytes4[](5);\n functionSelectors[0] = DiamondLoupeFacet.facetFunctionSelectors.selector;\n functionSelectors[1] = DiamondLoupeFacet.facets.selector;\n functionSelectors[2] = DiamondLoupeFacet.facetAddress.selector;\n functionSelectors[3] = DiamondLoupeFacet.facetAddresses.selector;\n functionSelectors[4] = DiamondLoupeFacet.supportsInterface.selector;\n _builtinDiamondCut.push(IDiamondCut.FacetCut({\n facetAddress:address(diamondLoupeFacet),\n action: IDiamondCut.FacetCutAction.Add,\n functionSelectors: functionSelectors\n }));\n\n\n // -------------------------------------------------------------------------\n // adding ownership functions\n // -------------------------------------------------------------------------\n OwnershipFacet ownershipFacet = new OwnershipFacet();\n\n functionSelectors = new bytes4[](2);\n functionSelectors[0] = OwnershipFacet.transferOwnership.selector;\n functionSelectors[1] = OwnershipFacet.owner.selector;\n _builtinDiamondCut.push(IDiamondCut.FacetCut({\n facetAddress:address(ownershipFacet),\n action: IDiamondCut.FacetCutAction.Add,\n functionSelectors: functionSelectors\n }));\n }\n\n function createDiamond(\n address owner,\n IDiamondCut.FacetCut[] calldata _diamondCut,\n bytes calldata data,\n bytes32 salt\n ) external payable returns (Diamond diamond) {\n if (salt != 0x0000000000000000000000000000000000000000000000000000000000000000) {\n salt = keccak256(abi.encodePacked(salt, owner));\n diamond = new Diamond{value: msg.value, salt: salt}(\n _builtinDiamondCut,\n Diamond.DiamondArgs({owner:address(this)})\n );\n } else {\n diamond = new Diamond{value: msg.value}(_builtinDiamondCut, Diamond.DiamondArgs({owner:address(this)}));\n }\n emit DiamondCreated(diamond);\n\n IDiamondCut(address(diamond)).diamondCut(_diamondCut, data.length > 0 ? address(diamond) : address(0), data);\n IERC173(address(diamond)).transferOwnership(owner);\n }\n}\n" + }, + "solc_0.7/diamond/interfaces/IDiamondCut.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.7.6;\npragma experimental ABIEncoderV2;\n\n/******************************************************************************\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\n/******************************************************************************/\n\ninterface IDiamondCut {\n enum FacetCutAction {Add, Replace, Remove}\n // Add=0, Replace=1, Remove=2\n\n struct FacetCut {\n address facetAddress;\n FacetCutAction action;\n bytes4[] functionSelectors;\n }\n\n /// @notice Add/replace/remove any number of functions and optionally execute\n /// a function with delegatecall\n /// @param _diamondCut Contains the facet addresses and function selectors\n /// @param _init The address of the contract or facet to execute _calldata\n /// @param _calldata A function call, including function selector and arguments\n /// _calldata is executed with delegatecall on _init\n function diamondCut(\n FacetCut[] calldata _diamondCut,\n address _init,\n bytes calldata _calldata\n ) external;\n\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\n}\n" + }, + "solc_0.7/diamond/Diamond.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.7.6;\npragma experimental ABIEncoderV2;\n\n/******************************************************************************\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\n* \n* Implementation of a diamond.\n/******************************************************************************/\n\nimport \"./libraries/LibDiamond.sol\";\nimport \"./interfaces/IDiamondLoupe.sol\";\nimport \"./interfaces/IDiamondCut.sol\";\nimport \"./interfaces/IERC173.sol\";\nimport \"./interfaces/IERC165.sol\";\n\ncontract Diamond {\n // more arguments are added to this struct\n // this avoids stack too deep errors\n struct DiamondArgs {\n address owner;\n }\n\n constructor(IDiamondCut.FacetCut[] memory _diamondCut, DiamondArgs memory _args) payable {\n LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));\n LibDiamond.setContractOwner(_args.owner);\n\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\n\n // adding ERC165 data\n ds.supportedInterfaces[type(IERC165).interfaceId] = true;\n ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;\n ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;\n ds.supportedInterfaces[type(IERC173).interfaceId] = true;\n }\n\n // Find facet for function that is called and execute the\n // function if a facet is found and return any value.\n fallback() external payable {\n LibDiamond.DiamondStorage storage ds;\n bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\n assembly {\n ds.slot := position\n }\n address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\n require(facet != address(0), \"Diamond: Function does not exist\");\n assembly {\n calldatacopy(0, 0, calldatasize())\n let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\n returndatacopy(0, 0, returndatasize())\n switch result\n case 0 {\n revert(0, returndatasize())\n }\n default {\n return(0, returndatasize())\n }\n }\n }\n\n receive() external payable {}\n}\n" + }, + "solc_0.7/diamond/facets/DiamondCutFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.7.6;\npragma experimental ABIEncoderV2;\n\n/******************************************************************************\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\n/******************************************************************************/\n\nimport \"../interfaces/IDiamondCut.sol\";\nimport \"../libraries/LibDiamond.sol\";\n\ncontract DiamondCutFacet is IDiamondCut {\n /// @notice Add/replace/remove any number of functions and optionally execute\n /// a function with delegatecall\n /// @param _diamondCut Contains the facet addresses and function selectors\n /// @param _init The address of the contract or facet to execute _calldata\n /// @param _calldata A function call, including function selector and arguments\n /// _calldata is executed with delegatecall on _init\n function diamondCut(\n FacetCut[] calldata _diamondCut,\n address _init,\n bytes calldata _calldata\n ) external override {\n LibDiamond.enforceIsContractOwner();\n LibDiamond.diamondCut(_diamondCut, _init, _calldata);\n }\n}\n" + }, + "solc_0.7/diamond/facets/DiamondLoupeFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.7.6;\npragma experimental ABIEncoderV2;\n\n/******************************************************************************\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\n/******************************************************************************/\n\nimport \"../libraries/LibDiamond.sol\";\nimport \"../interfaces/IDiamondCut.sol\";\nimport \"../interfaces/IDiamondLoupe.sol\";\nimport \"../interfaces/IERC165.sol\";\n\ncontract DiamondLoupeFacet is IDiamondLoupe, IERC165 {\n // Diamond Loupe Functions\n ////////////////////////////////////////////////////////////////////\n /// These functions are expected to be called frequently by tools.\n //\n // struct Facet {\n // address facetAddress;\n // bytes4[] functionSelectors;\n // }\n\n /// @notice Gets all facets and their selectors.\n /// @return facets_ Facet\n function facets() external override view returns (Facet[] memory facets_) {\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\n uint256 numFacets = ds.facetAddresses.length;\n facets_ = new Facet[](numFacets);\n for (uint256 i; i < numFacets; i++) {\n address facetAddress_ = ds.facetAddresses[i];\n facets_[i].facetAddress = facetAddress_;\n facets_[i].functionSelectors = ds.facetFunctionSelectors[facetAddress_].functionSelectors;\n }\n }\n\n /// @notice Gets all the function selectors provided by a facet.\n /// @param _facet The facet address.\n /// @return facetFunctionSelectors_\n function facetFunctionSelectors(address _facet) external override view returns (bytes4[] memory facetFunctionSelectors_) {\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\n facetFunctionSelectors_ = ds.facetFunctionSelectors[_facet].functionSelectors;\n }\n\n /// @notice Get all the facet addresses used by a diamond.\n /// @return facetAddresses_\n function facetAddresses() external override view returns (address[] memory facetAddresses_) {\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\n facetAddresses_ = ds.facetAddresses;\n }\n\n /// @notice Gets the facet that supports the given selector.\n /// @dev If facet is not found return address(0).\n /// @param _functionSelector The function selector.\n /// @return facetAddress_ The facet address.\n function facetAddress(bytes4 _functionSelector) external override view returns (address facetAddress_) {\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\n facetAddress_ = ds.selectorToFacetAndPosition[_functionSelector].facetAddress;\n }\n\n // This implements ERC-165.\n function supportsInterface(bytes4 _interfaceId) external override view returns (bool) {\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\n return ds.supportedInterfaces[_interfaceId];\n }\n}\n" + }, + "solc_0.7/diamond/facets/OwnershipFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.7.6;\n\nimport \"../libraries/LibDiamond.sol\";\nimport \"../interfaces/IERC173.sol\";\n\ncontract OwnershipFacet is IERC173 {\n function transferOwnership(address _newOwner) external override {\n LibDiamond.enforceIsContractOwner();\n LibDiamond.setContractOwner(_newOwner);\n }\n\n function owner() external override view returns (address owner_) {\n owner_ = LibDiamond.contractOwner();\n }\n}\n" + }, + "solc_0.7/diamond/libraries/LibDiamond.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.7.6;\npragma experimental ABIEncoderV2;\n\n/******************************************************************************\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\n/******************************************************************************/\n\nimport \"../interfaces/IDiamondCut.sol\";\n\nlibrary LibDiamond {\n bytes32 constant DIAMOND_STORAGE_POSITION = keccak256(\"diamond.standard.diamond.storage\");\n\n struct FacetAddressAndPosition {\n address facetAddress;\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\n }\n\n struct FacetFunctionSelectors {\n bytes4[] functionSelectors;\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\n }\n\n struct DiamondStorage {\n // maps function selector to the facet address and\n // the position of the selector in the facetFunctionSelectors.selectors array\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\n // maps facet addresses to function selectors\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\n // facet addresses\n address[] facetAddresses;\n // Used to query if a contract implements an interface.\n // Used to implement ERC-165.\n mapping(bytes4 => bool) supportedInterfaces;\n // owner of the contract\n address contractOwner;\n }\n\n function diamondStorage() internal pure returns (DiamondStorage storage ds) {\n bytes32 position = DIAMOND_STORAGE_POSITION;\n assembly {\n ds.slot := position\n }\n }\n\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n function setContractOwner(address _newOwner) internal {\n DiamondStorage storage ds = diamondStorage();\n address previousOwner = ds.contractOwner;\n ds.contractOwner = _newOwner;\n emit OwnershipTransferred(previousOwner, _newOwner);\n }\n\n function contractOwner() internal view returns (address contractOwner_) {\n contractOwner_ = diamondStorage().contractOwner;\n }\n\n function enforceIsContractOwner() internal view {\n require(msg.sender == diamondStorage().contractOwner, \"LibDiamond: Must be contract owner\");\n }\n\n event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\n\n // Internal function version of diamondCut\n function diamondCut(\n IDiamondCut.FacetCut[] memory _diamondCut,\n address _init,\n bytes memory _calldata\n ) internal {\n for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\n if (action == IDiamondCut.FacetCutAction.Add) {\n addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\n replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\n removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\n } else {\n revert(\"LibDiamondCut: Incorrect FacetCutAction\");\n }\n }\n emit DiamondCut(_diamondCut, _init, _calldata);\n initializeDiamondCut(_init, _calldata);\n }\n\n function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\n require(_functionSelectors.length > 0, \"LibDiamondCut: No selectors in facet to cut\");\n DiamondStorage storage ds = diamondStorage();\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\n require(_facetAddress != address(0), \"LibDiamondCut: Add facet can't be address(0)\");\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\n // add new facet address if it does not exist\n if (selectorPosition == 0) {\n enforceHasContractCode(_facetAddress, \"LibDiamondCut: New facet has no code\");\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\n ds.facetAddresses.push(_facetAddress);\n }\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\n bytes4 selector = _functionSelectors[selectorIndex];\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\n require(oldFacetAddress == address(0), \"LibDiamondCut: Can't add function that already exists\");\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\n selectorPosition++;\n }\n }\n\n function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\n require(_functionSelectors.length > 0, \"LibDiamondCut: No selectors in facet to cut\");\n DiamondStorage storage ds = diamondStorage();\n require(_facetAddress != address(0), \"LibDiamondCut: Add facet can't be address(0)\");\n uint16 selectorPosition = uint16(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\n // add new facet address if it does not exist\n if (selectorPosition == 0) {\n enforceHasContractCode(_facetAddress, \"LibDiamondCut: New facet has no code\");\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = uint16(ds.facetAddresses.length);\n ds.facetAddresses.push(_facetAddress);\n }\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\n bytes4 selector = _functionSelectors[selectorIndex];\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\n require(oldFacetAddress != _facetAddress, \"LibDiamondCut: Can't replace function with same function\");\n removeFunction(oldFacetAddress, selector);\n // add function\n ds.selectorToFacetAndPosition[selector].functionSelectorPosition = selectorPosition;\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(selector);\n ds.selectorToFacetAndPosition[selector].facetAddress = _facetAddress;\n selectorPosition++;\n }\n }\n\n function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\n require(_functionSelectors.length > 0, \"LibDiamondCut: No selectors in facet to cut\");\n DiamondStorage storage ds = diamondStorage();\n // if function does not exist then do nothing and return\n require(_facetAddress == address(0), \"LibDiamondCut: Remove facet address must be address(0)\");\n for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {\n bytes4 selector = _functionSelectors[selectorIndex];\n address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\n removeFunction(oldFacetAddress, selector);\n }\n }\n\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\n DiamondStorage storage ds = diamondStorage();\n require(_facetAddress != address(0), \"LibDiamondCut: Can't remove function that doesn't exist\");\n // an immutable function is a function defined directly in a diamond\n require(_facetAddress != address(this), \"LibDiamondCut: Can't remove immutable function\");\n // replace selector with last selector, then delete last selector\n uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\n uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\n // if not the same then replace _selector with lastSelector\n if (selectorPosition != lastSelectorPosition) {\n bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\n ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint16(selectorPosition);\n }\n // delete the last selector\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\n delete ds.selectorToFacetAndPosition[_selector];\n\n // if no more selectors for facet address then delete the facet address\n if (lastSelectorPosition == 0) {\n // replace facet address with last facet address and delete last facet address\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\n uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\n if (facetAddressPosition != lastFacetAddressPosition) {\n address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\n ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = uint16(facetAddressPosition);\n }\n ds.facetAddresses.pop();\n delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\n }\n }\n\n function initializeDiamondCut(address _init, bytes memory _calldata) internal {\n if (_init == address(0)) {\n require(_calldata.length == 0, \"LibDiamondCut: _init is address(0) but_calldata is not empty\");\n } else {\n require(_calldata.length > 0, \"LibDiamondCut: _calldata is empty but _init is not address(0)\");\n if (_init != address(this)) {\n enforceHasContractCode(_init, \"LibDiamondCut: _init address has no code\");\n }\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\n if (!success) {\n if (error.length > 0) {\n // bubble up the error\n revert(string(error));\n } else {\n revert(\"LibDiamondCut: _init function reverted\");\n }\n }\n }\n }\n\n function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {\n uint256 contractSize;\n assembly {\n contractSize := extcodesize(_contract)\n }\n require(contractSize > 0, _errorMessage);\n }\n}\n" + }, + "solc_0.7/diamond/interfaces/IDiamondLoupe.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.7.6;\npragma experimental ABIEncoderV2;\n\n/******************************************************************************\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\n/******************************************************************************/\n\n// A loupe is a small magnifying glass used to look at diamonds.\n// These functions look at diamonds\ninterface IDiamondLoupe {\n /// These functions are expected to be called frequently\n /// by tools.\n\n struct Facet {\n address facetAddress;\n bytes4[] functionSelectors;\n }\n\n /// @notice Gets all facet addresses and their four byte function selectors.\n /// @return facets_ Facet\n function facets() external view returns (Facet[] memory facets_);\n\n /// @notice Gets all the function selectors supported by a specific facet.\n /// @param _facet The facet address.\n /// @return facetFunctionSelectors_\n function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\n\n /// @notice Get all the facet addresses used by a diamond.\n /// @return facetAddresses_\n function facetAddresses() external view returns (address[] memory facetAddresses_);\n\n /// @notice Gets the facet that supports the given selector.\n /// @dev If facet is not found return address(0).\n /// @param _functionSelector The function selector.\n /// @return facetAddress_ The facet address.\n function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\n}\n" + }, + "solc_0.7/diamond/interfaces/IERC173.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.7.6;\n\n/// @title ERC-173 Contract Ownership Standard\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\n/* is ERC165 */\ninterface IERC173 {\n /// @dev This emits when ownership of a contract changes.\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /// @notice Get the address of the owner\n /// @return owner_ The address of the owner.\n function owner() external view returns (address owner_);\n\n /// @notice Set the address of the new owner of the contract\n /// @dev Set _newOwner to address(0) to renounce any ownership.\n /// @param _newOwner The address of the new owner of the contract\n function transferOwnership(address _newOwner) external;\n}\n" + }, + "solc_0.7/diamond/interfaces/IERC165.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.7.6;\npragma experimental ABIEncoderV2;\n\ninterface IERC165 {\n /// @notice Query if a contract implements an interface\n /// @param interfaceId The interface identifier, as specified in ERC-165\n /// @dev Interface identification is specified in ERC-165. This function\n /// uses less than 30,000 gas.\n /// @return `true` if the contract implements `interfaceID` and\n /// `interfaceID` is not 0xffffffff, `false` otherwise\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n" + } + }, + "settings": { + "optimizer": { + "enabled": true, + "runs": 999999 + }, + "outputSelection": { + "*": { + "*": [ + "abi", + "evm.bytecode", + "evm.deployedBytecode", + "evm.methodIdentifiers", + "metadata", + "devdoc", + "userdoc", + "storageLayout", + "evm.gasEstimates" + ], + "": ["ast"] + } + }, + "metadata": { + "useLiteralContent": true + } + } +} diff --git a/deployments/polygon_mumbai/solcInputs/f7f185d0f2f1a27625ce9f4cd28bcad1.json b/deployments/polygon_mumbai/solcInputs/f7f185d0f2f1a27625ce9f4cd28bcad1.json new file mode 100644 index 000000000..4b397033d --- /dev/null +++ b/deployments/polygon_mumbai/solcInputs/f7f185d0f2f1a27625ce9f4cd28bcad1.json @@ -0,0 +1,573 @@ +{ + "language": "Solidity", + "sources": { + "contracts/contexts/access-control/context.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./internal/grant-role.sol\";\nimport \"./internal/revoke-role.sol\";\nimport \"./internal/renounce-role.sol\";\n\nabstract contract ctx_AccessControl_v1 is\n int_grantRole_AccessControl_v1,\n int_revokeRole_AccessControl_v1,\n int_renounceRole_AccessControl_v1\n{}\n" + }, + "contracts/contexts/access-control/internal/grant-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { AccessControlEvents } from \"../data.sol\";\nimport \"./has-role.sol\";\n\nabstract contract int_grantRole_AccessControl_v1 is\n int_hasRole_AccessControl_v1\n{\n /**\n * @dev Should only use when circumventing admin checking. See {../entry/grant-role.sol}\n */\n function _grantRole(bytes32 role, address account) internal {\n if (_hasRole(role, account)) return;\n accessControlRolesStore().roles[role].members[account] = true;\n emit AccessControlEvents.RoleGranted(role, account, msg.sender);\n }\n}\n" + }, + "contracts/contexts/access-control/internal/revoke-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { AccessControlEvents } from \"../data.sol\";\nimport \"./has-role.sol\";\n\nabstract contract int_revokeRole_AccessControl_v1 is\n int_hasRole_AccessControl_v1\n{\n function _revokeRole(bytes32 role, address account) internal {\n if (!_hasRole(role, account)) return;\n accessControlRolesStore().roles[role].members[account] = false;\n emit AccessControlEvents.RoleRevoked(role, account, msg.sender);\n }\n}\n" + }, + "contracts/contexts/access-control/internal/renounce-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlEvents } from \"../data.sol\";\nimport \"./has-role.sol\";\n\nabstract contract int_renounceRole_AccessControl_v1 is\n int_hasRole_AccessControl_v1\n{\n function _renounceRole(bytes32 role, address account) internal {\n require(_hasRole(role, msg.sender), \"CAN'T RENOUNCE\");\n accessControlRolesStore().roles[role].members[account] = false;\n emit AccessControlEvents.RoleRevoked(role, account, msg.sender);\n }\n}\n" + }, + "contracts/contexts/access-control/data.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nstruct RoleData {\n mapping(address => bool) members;\n bytes32 adminRole;\n}\n\nlibrary AccessControlEvents {\n event OwnerSet(address indexed owner);\n\n event OwnerTransferred(address indexed owner, address indexed prevOwner);\n\n /**\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n *\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n * {RoleAdminChanged} not being emitted signaling this.\n *\n * _Available since v3.1._\n */\n event RoleAdminChanged(\n bytes32 indexed role,\n bytes32 indexed previousAdminRole,\n bytes32 indexed newAdminRole\n );\n\n /**\n * @dev Emitted when `account` is granted `role`.\n *\n * `sender` is the account that originated the contract call, an admin role\n * bearer except when using {_setupRole}.\n */\n event RoleGranted(\n bytes32 indexed role,\n address indexed account,\n address indexed sender\n );\n\n /**\n * @dev Emitted when `account` is revoked `role`.\n *\n * `sender` is the account that originated the contract call:\n * - if using `revokeRole`, it is the admin role bearer\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\n */\n event RoleRevoked(\n bytes32 indexed role,\n address indexed account,\n address indexed sender\n );\n}\n" + }, + "contracts/contexts/access-control/internal/has-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"../storage/roles.sol\";\n\nabstract contract int_hasRole_AccessControl_v1 is sto_AccessControl_Roles {\n function _hasRole(bytes32 role, address account)\n internal\n view\n returns (bool hasRole_)\n {\n hasRole_ = accessControlRolesStore().roles[role].members[account];\n }\n}\n" + }, + "contracts/contexts/access-control/storage/roles.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { RoleData } from \"../data.sol\";\n\ncontract sto_AccessControl_Roles {\n bytes32 internal constant POS =\n keccak256(\"teller_protocol.storage.access_control.roles\");\n\n struct AccessControlRolesStorage {\n mapping(bytes32 => RoleData) roles;\n }\n\n function accessControlRolesStore()\n internal\n pure\n returns (AccessControlRolesStorage storage s)\n {\n bytes32 position = POS;\n\n assembly {\n s.slot := position\n }\n }\n}\n" + }, + "contracts/contexts/initializable/context.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"../access-control/internal/grant-role.sol\";\nimport \"../access-control/internal/revoke-role.sol\";\nimport \"../access-control/internal/renounce-role.sol\";\n\ncontract ctx_Initializable_v1 is\n int_grantRole_AccessControl_v1,\n int_revokeRole_AccessControl_v1,\n int_renounceRole_AccessControl_v1\n{}\n" + }, + "contracts/contexts/access-control/entry/revoke-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../data.sol\";\nimport \"../internal/revoke-role.sol\";\nimport \"../internal/is-admin-for-role.sol\";\n\ncontract ent_revokeRole_AccessControl_v1 is\n int_revokeRole_AccessControl_v1,\n int_isAdminForRole_AccessControl_v1\n{\n /**\n * @notice Removes a role from an address.\n *\n * Requirements:\n * - Sender must be role admin.\n */\n function revokeRole(bytes32 role, address account) external {\n require(_isAdminForRole(role, msg.sender), \"AccessControl: not admin\");\n _revokeRole(role, account);\n }\n}\n" + }, + "contracts/contexts/access-control/internal/is-admin-for-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"../storage/roles.sol\";\n\nabstract contract int_isAdminForRole_AccessControl_v1 is\n sto_AccessControl_Roles\n{\n function _isAdminForRole(bytes32 role, address account)\n internal\n view\n returns (bool isAdminForRole_)\n {\n isAdminForRole_ = accessControlRolesStore().roles[\n accessControlRolesStore().roles[role].adminRole\n ]\n .members[account];\n }\n}\n" + }, + "contracts/contexts/access-control/entry/renounce-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../data.sol\";\nimport \"../internal/revoke-role.sol\";\nimport \"../internal/is-admin-for-role.sol\";\n\ncontract ent_renounceRole_AccessControl_v1 is\n int_revokeRole_AccessControl_v1,\n int_isAdminForRole_AccessControl_v1\n{\n /**\n * @notice Grants an address a new role.\n * @param role the role to revoke for the account\n * @param account the address of the respective account to revoke\n * Requirements:\n * - Sender must be role admin.\n */\n function renounceRole(bytes32 role, address account) external {\n require(\n account == msg.sender,\n \"AccessControl: can only renounce roles for self\"\n );\n _revokeRole(role, account);\n }\n}\n" + }, + "contracts/contexts/access-control/storage.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./data.sol\";\n\ncontract sto_AccessControl {\n struct AccessControlLayout {\n mapping(bytes32 => RoleData) roles;\n bool notEntered;\n }\n\n function accessControl()\n internal\n pure\n returns (AccessControlLayout storage l_)\n {\n bytes32 position = keccak256(\"teller_protocol.storage.access_control\");\n\n assembly {\n l_.slot := position\n }\n }\n}\n" + }, + "contracts/contexts/access-control/modifiers/entry.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { sto_AccessControl } from \"../storage.sol\";\n\nabstract contract mod_entry_AccessControl_v1 is sto_AccessControl {\n modifier entry {\n AccessControlLayout storage layout = accessControl();\n require(layout.notEntered, \"RE_ENTRANCY\");\n layout.notEntered = false;\n _;\n layout.notEntered = true;\n }\n}\n" + }, + "contracts/contexts/access-control/internal/transfer-owner.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlEvents } from \"../data.sol\";\nimport \"../storage/owner.sol\";\n\nabstract contract int_transferOwner_AccessControl_v1 is\n sto_AccessControl_Owner\n{\n function _transferOwner(address owner) internal {\n require(\n accessControlOwnerStore().owner == msg.sender,\n \"AccessControl: cannot transfer; not owner\"\n );\n accessControlOwnerStore().owner = owner;\n emit AccessControlEvents.OwnerTransferred(owner, msg.sender);\n }\n}\n" + }, + "contracts/contexts/access-control/storage/owner.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract sto_AccessControl_Owner {\n bytes32 internal constant POS =\n keccak256(\"teller_protocol.storage.access_control.owner\");\n\n struct AccessControlOwnerStorage {\n address owner;\n }\n\n function accessControlOwnerStore()\n internal\n pure\n returns (AccessControlOwnerStorage storage s)\n {\n bytes32 position = POS;\n\n assembly {\n s.slot := position\n }\n }\n}\n" + }, + "contracts/contexts/access-control/modifiers/only-owner.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"../storage/owner.sol\";\n\nabstract contract mod_onlyOwner_AccessControl_v1 is sto_AccessControl_Owner {\n modifier onlyOwner() {\n require(\n accessControlOwnerStore().owner == msg.sender,\n \"AccessControl: not owner\"\n );\n _;\n }\n}\n\nabstract contract mod_onlyOwner_AccessControl is\n mod_onlyOwner_AccessControl_v1\n{}\n" + }, + "contracts/contexts/access-control/internal/set-owner.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlEvents } from \"../data.sol\";\nimport \"../storage/owner.sol\";\n\nabstract contract int_setOwner_AccessControl_v1 is sto_AccessControl_Owner {\n function _setOwner(address owner) internal {\n require(\n accessControlOwnerStore().owner == address(0),\n \"AccessControl: owner already set\"\n );\n accessControlOwnerStore().owner = owner;\n emit AccessControlEvents.OwnerSet(owner);\n }\n}\n" + }, + "contracts/contexts/access-control/internal/set-role-admin.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlEvents } from \"../data.sol\";\nimport \"./admin-role-for.sol\";\n\nabstract contract int_setRoleAdmin_AccessControl_v1 is\n int_adminRoleFor_AccessControl_v1\n{\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal {\n accessControlRolesStore().roles[role].adminRole = adminRole;\n emit AccessControlEvents.RoleAdminChanged(\n role,\n _adminRoleFor(role),\n adminRole\n );\n }\n}\n" + }, + "contracts/contexts/access-control/internal/admin-role-for.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../storage/roles.sol\";\n\nabstract contract int_adminRoleFor_AccessControl_v1 is sto_AccessControl_Roles {\n function _adminRoleFor(bytes32 role)\n internal\n view\n returns (bytes32 adminRoleFor_)\n {\n adminRoleFor_ = accessControlRolesStore().roles[role].adminRole;\n }\n}\n\nabstract contract int_adminRoleFor_AccessControl is\n int_adminRoleFor_AccessControl_v1\n{}\n" + }, + "contracts/contexts/access-control/internal/require-authorization.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./has-role.sol\";\n\nabstract contract int_requireAuthorization_AccessControl_v1 is\n int_hasRole_AccessControl_v1\n{\n function _requireAuthorization(bytes32 role, address account)\n internal\n view\n {\n require(_hasRole(role, account), \"AccessControl: unauthorized\");\n }\n}\n" + }, + "contracts/contexts/access-control/modifiers/authorized.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {\n int_requireAuthorization_AccessControl_v1\n} from \"../internal/require-authorization.sol\";\n\nabstract contract mod_authorized_AccessControl_v1 is\n int_requireAuthorization_AccessControl_v1\n{\n modifier authorized(bytes32 role, address account) {\n _requireAuthorization(role, account);\n _;\n }\n}\n\nabstract contract mod_authorized_AccessControl is\n mod_authorized_AccessControl_v1\n{}\n" + }, + "contracts/nft/distributor/entry/move-merkle.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../store.sol\";\nimport \"../../../contexts/access-control/modifiers/authorized.sol\";\n\n// Utils\nimport { DistributorEvents, ADMIN, MerkleRoot } from \"../data.sol\";\n\ncontract ent_moveMerkle_NFTDistributor_v1 is\n sto_NFTDistributor,\n mod_authorized_AccessControl_v1\n{\n /**\n * @notice Change a merkle to be for a different tier to be able to claim NFTs.\n * @param index Index of merkle to set.\n * @param tierIndex Index of NFT tier to assign merkle for.\n *\n * Requirements:\n * - Caller must be an admin\n */\n function moveMerkle(uint256 index, uint256 tierIndex)\n external\n authorized(ADMIN, msg.sender)\n {\n MerkleRoot storage merkle = distributorStore().merkleRoots[index];\n merkle.tierIndex = tierIndex;\n }\n}\n" + }, + "contracts/nft/distributor/store.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Interfaces\nimport \"../ITellerNFT.sol\";\nimport \"../TellerNFTDictionary.sol\";\n\n// Utils\nimport { MerkleRoot } from \"./data.sol\";\n\nabstract contract sto_NFTDistributor {\n struct DistributorStorage {\n ITellerNFT nft;\n MerkleRoot[] merkleRoots;\n mapping(uint256 => mapping(uint256 => uint256)) claimedBitMap;\n TellerNFTDictionary dictionary;\n }\n\n bytes32 constant POSITION = keccak256(\"teller_nft.distributor\");\n\n function distributorStore()\n internal\n pure\n returns (DistributorStorage storage s)\n {\n bytes32 P = POSITION;\n assembly {\n s.slot := P\n }\n }\n}\n" + }, + "contracts/nft/distributor/data.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nbytes32 constant ADMIN = keccak256(\"ADMIN\");\nbytes32 constant MINTER = keccak256(\"MINTER\");\n\nstruct MerkleRoot {\n bytes32 merkleRoot;\n uint256 tierIndex;\n}\n\nstruct ClaimNFTRequest {\n uint256 merkleIndex;\n uint256 nodeIndex;\n uint256 amount;\n bytes32[] merkleProof;\n}\n\nlibrary DistributorEvents {\n event Claimed(address indexed account);\n\n event MerkleAdded(uint256 index);\n}\n" + }, + "contracts/nft/ITellerNFT.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\npragma experimental ABIEncoderV2;\n\n// Interfaces\nimport \"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\";\n\ninterface ITellerNFT {\n struct Tier {\n uint256 baseLoanSize;\n string[] hashes;\n address contributionAsset;\n uint256 contributionSize;\n uint8 contributionMultiplier;\n }\n\n /**\n * @notice The contract metadata URI.\n * @return the contractURI in string\n */\n function contractURI() external view returns (string memory);\n\n /**\n * @notice It returns information about a Tier with from a tier index\n * @param index Tier index to get info.\n * @return tier_ the tier which belongs to the respective index\n */\n function getTier(uint256 index) external view returns (Tier memory tier_);\n\n /**\n * @notice It returns information about a Tier for a token ID.\n * @param tokenId ID of the token to get Tier info.\n * @return index_ the index of the tier the tokenID belongs in\n * @return tier_ the tier where the tokenID belongs in\n */\n function getTokenTier(uint256 tokenId)\n external\n view\n returns (uint256 index_, Tier memory tier_);\n\n /**\n * @notice It returns an array of hashes in a tier\n * @param tierIndex the tier index to get the tier hashes\n * @return hashes_ all the tokenID hashes\n */\n function getTierHashes(uint256 tierIndex)\n external\n view\n returns (string[] memory hashes_);\n\n /**\n * @notice It returns an array of token IDs owned by an address.\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\n * @dev Can be costly if calling within a contract for address with many tokens.\n * @return owned the array of tokenIDs owned by the address\n */\n function getOwnedTokens(address owner)\n external\n view\n returns (uint256[] memory owned);\n\n /**\n * @notice It mints a new token for a Tier index.\n * @param tierIndex the tier index to mint the token in\n * @param owner the owner of the new token\n * Requirements:\n * - Caller must be an authorized minter\n */\n function mint(uint256 tierIndex, address owner) external;\n\n /**\n * @notice Adds a new Tier to be minted with the given information.\n * @dev It auto increments the index of the next tier to add.\n * @param newTier Information about the new tier to add.\n *\n * Requirements:\n * - Caller must have the {MINTER} role\n */\n function addTier(Tier memory newTier) external;\n\n /**\n * @notice Sets the contract level metadata URI hash.\n * @param contractURIHash The hash to the initial contract level metadata.\n */\n function setContractURIHash(string memory contractURIHash) external;\n\n /**\n * @notice Initializes the TellerNFT.\n * @param minters The addresses that should allowed to mint tokens.\n */\n function initialize(address[] calldata minters) external;\n}\n" + }, + "contracts/nft/TellerNFTDictionary.sol": { + "content": "/**\n * @notice TellerNFTDictionary Version 1.02\n *\n * @notice This contract is used to gather data for TellerV1 NFTs more efficiently.\n * @notice This contract has data which must be continuously synchronized with the TellerV1 NFT data\n *\n * @author develop@teller.finance\n */\n\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\";\n\n// Interfaces\nimport \"./IStakeableNFT.sol\";\n\n/**\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\n *\n * @author develop@teller.finance\n */\ncontract TellerNFTDictionary is IStakeableNFT, AccessControlUpgradeable {\n struct Tier {\n uint256 baseLoanSize;\n string[] hashes;\n address contributionAsset;\n uint256 contributionSize;\n uint8 contributionMultiplier;\n }\n\n mapping(uint256 => uint256) public baseLoanSizes;\n mapping(uint256 => string[]) public hashes;\n mapping(uint256 => address) public contributionAssets;\n mapping(uint256 => uint256) public contributionSizes;\n mapping(uint256 => uint8) public contributionMultipliers;\n\n /* Constants */\n\n bytes32 public constant ADMIN = keccak256(\"ADMIN\");\n\n /* State Variables */\n\n mapping(uint256 => uint256) public _tokenTierMappingCompressed;\n bool public _tokenTierMappingCompressedSet;\n\n /* Modifiers */\n\n modifier onlyAdmin() {\n require(hasRole(ADMIN, _msgSender()), \"TellerNFTDictionary: not admin\");\n _;\n }\n\n function initialize(address initialAdmin) public {\n _setupRole(ADMIN, initialAdmin);\n _setRoleAdmin(ADMIN, ADMIN);\n\n __AccessControl_init();\n }\n\n /* External Functions */\n\n /**\n * @notice It returns information about a Tier for a token ID.\n * @param tokenId ID of the token to get Tier info.\n */\n function getTokenTierIndex(uint256 tokenId)\n public\n view\n returns (uint8 index_)\n {\n //32 * 8 = 256 - each uint256 holds the data of 32 tokens . 8 bits each.\n\n uint256 mappingIndex = tokenId / 32;\n\n uint256 compressedRegister = _tokenTierMappingCompressed[mappingIndex];\n\n //use 31 instead of 32 to account for the '0x' in the start.\n //the '31 -' reverses our bytes order which is necessary\n\n uint256 offset = ((31 - (tokenId % 32)) * 8);\n\n uint8 tierIndex = uint8((compressedRegister >> offset));\n\n return tierIndex;\n }\n\n function getTierHashes(uint256 tierIndex)\n external\n view\n returns (string[] memory)\n {\n return hashes[tierIndex];\n }\n\n /**\n * @notice Adds a new Tier to be minted with the given information.\n * @dev It auto increments the index of the next tier to add.\n * @param newTier Information about the new tier to add.\n *\n * Requirements:\n * - Caller must have the {Admin} role\n */\n function setTier(uint256 index, Tier memory newTier)\n external\n onlyAdmin\n returns (bool)\n {\n baseLoanSizes[index] = newTier.baseLoanSize;\n hashes[index] = newTier.hashes;\n contributionAssets[index] = newTier.contributionAsset;\n contributionSizes[index] = newTier.contributionSize;\n contributionMultipliers[index] = newTier.contributionMultiplier;\n\n return true;\n }\n\n /**\n * @notice Sets the tiers for each tokenId using compressed data.\n * @param tiersMapping Information about the new tiers to add.\n *\n * Requirements:\n * - Caller must have the {Admin} role\n */\n function setAllTokenTierMappings(uint256[] memory tiersMapping)\n public\n onlyAdmin\n returns (bool)\n {\n require(\n !_tokenTierMappingCompressedSet,\n \"TellerNFTDictionary: token tier mapping already set\"\n );\n for (uint256 i = 0; i < tiersMapping.length; i++) {\n _tokenTierMappingCompressed[i] = tiersMapping[i];\n }\n\n _tokenTierMappingCompressedSet = true;\n return true;\n }\n\n /**\n * @notice Sets the tiers for each tokenId using compressed data.\n * @param index the mapping row, each holds data for 32 tokens\n * @param tierMapping Information about the new tier to add.\n *\n * Requirements:\n * - Caller must have the {Admin} role\n */\n function setTokenTierMapping(uint256 index, uint256 tierMapping)\n public\n onlyAdmin\n returns (bool)\n {\n _tokenTierMappingCompressed[index] = tierMapping;\n\n return true;\n }\n\n /**\n * @notice Sets a specific tier for a specific tokenId using compressed data.\n * @param tokenIds the NFT token Ids for which to add data\n * @param tokenTier the index of the tier that these tokenIds should have\n *\n * Requirements:\n * - Caller must have the {Admin} role\n */\n function setTokenTierForTokenIds(\n uint256[] calldata tokenIds,\n uint256 tokenTier\n ) public onlyAdmin returns (bool) {\n for (uint256 i; i < tokenIds.length; i++) {\n setTokenTierForTokenId(tokenIds[i], tokenTier);\n }\n\n return true;\n }\n\n /**\n * @notice Sets a specific tier for a specific tokenId using compressed data.\n * @param tokenId the NFT token Id for which to add data\n * @param tokenTier the index of the tier that these tokenIds should have\n *\n * Requirements:\n * - Caller must have the {Admin} role\n */\n function setTokenTierForTokenId(uint256 tokenId, uint256 tokenTier)\n public\n onlyAdmin\n returns (bool)\n {\n uint256 mappingIndex = tokenId / 32;\n\n uint256 existingRegister = _tokenTierMappingCompressed[mappingIndex];\n\n uint256 offset = ((31 - (tokenId % 32)) * 8);\n\n uint256 updateMaskShifted =\n 0x00000000000000000000000000000000000000000000000000000000000000FF <<\n offset;\n\n uint256 updateMaskShiftedNegated = ~updateMaskShifted;\n\n uint256 tokenTierShifted =\n ((0x0000000000000000000000000000000000000000000000000000000000000000 |\n tokenTier) << offset);\n\n uint256 existingRegisterClearedWithMask =\n existingRegister & updateMaskShiftedNegated;\n\n uint256 updatedRegister =\n existingRegisterClearedWithMask | tokenTierShifted;\n\n _tokenTierMappingCompressed[mappingIndex] = updatedRegister;\n\n return true;\n }\n\n function supportsInterface(bytes4 interfaceId)\n public\n view\n override(AccessControlUpgradeable)\n returns (bool)\n {\n return\n interfaceId == type(IStakeableNFT).interfaceId ||\n AccessControlUpgradeable.supportsInterface(interfaceId);\n }\n\n /**\n New methods for the dictionary\n */\n\n /**\n * @notice It returns Base Loan Size for a token ID.\n * @param tokenId ID of the token to get info.\n */\n function tokenBaseLoanSize(uint256 tokenId)\n public\n view\n override\n returns (uint256)\n {\n uint8 tokenTier = getTokenTierIndex(tokenId);\n\n return baseLoanSizes[tokenTier];\n }\n\n /**\n * @notice It returns Token URI Hash for a token ID.\n * @param tokenId ID of the token to get info.\n */\n function tokenURIHash(uint256 tokenId)\n public\n view\n override\n returns (string memory)\n {\n uint8 tokenTier = getTokenTierIndex(tokenId);\n\n string[] memory tierImageHashes = hashes[tokenTier];\n return tierImageHashes[tokenId % (tierImageHashes.length)];\n }\n\n /**\n * @notice It returns Contribution Asset for a token ID.\n * @param tokenId ID of the token to get info.\n */\n function tokenContributionAsset(uint256 tokenId)\n public\n view\n override\n returns (address)\n {\n uint8 tokenTier = getTokenTierIndex(tokenId);\n\n return contributionAssets[tokenTier];\n }\n\n /**\n * @notice It returns Contribution Size for a token ID.\n * @param tokenId ID of the token to get info.\n */\n function tokenContributionSize(uint256 tokenId)\n public\n view\n override\n returns (uint256)\n {\n uint8 tokenTier = getTokenTierIndex(tokenId);\n\n return contributionSizes[tokenTier];\n }\n\n /**\n * @notice It returns Contribution Multiplier for a token ID.\n * @param tokenId ID of the token to get info.\n */\n function tokenContributionMultiplier(uint256 tokenId)\n public\n view\n override\n returns (uint8)\n {\n uint8 tokenTier = getTokenTierIndex(tokenId);\n\n return contributionMultipliers[tokenTier];\n }\n}\n" + }, + "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC721.sol\";\n\n/**\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\n * @dev See https://eips.ethereum.org/EIPS/eip-721\n */\ninterface IERC721Metadata is IERC721 {\n\n /**\n * @dev Returns the token collection name.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the token collection symbol.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\n */\n function tokenURI(uint256 tokenId) external view returns (string memory);\n}\n" + }, + "@openzeppelin/contracts/token/ERC721/IERC721.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev Required interface of an ERC721 compliant contract.\n */\ninterface IERC721 is IERC165 {\n /**\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\n */\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n\n /**\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\n */\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n\n /**\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\n */\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n /**\n * @dev Returns the number of tokens in ``owner``'s account.\n */\n function balanceOf(address owner) external view returns (uint256 balance);\n\n /**\n * @dev Returns the owner of the `tokenId` token.\n *\n * Requirements:\n *\n * - `tokenId` must exist.\n */\n function ownerOf(uint256 tokenId) external view returns (address owner);\n\n /**\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must exist and be owned by `from`.\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n *\n * Emits a {Transfer} event.\n */\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\n\n /**\n * @dev Transfers `tokenId` token from `from` to `to`.\n *\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must be owned by `from`.\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address from, address to, uint256 tokenId) external;\n\n /**\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\n * The approval is cleared when the token is transferred.\n *\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\n *\n * Requirements:\n *\n * - The caller must own the token or be an approved operator.\n * - `tokenId` must exist.\n *\n * Emits an {Approval} event.\n */\n function approve(address to, uint256 tokenId) external;\n\n /**\n * @dev Returns the account approved for `tokenId` token.\n *\n * Requirements:\n *\n * - `tokenId` must exist.\n */\n function getApproved(uint256 tokenId) external view returns (address operator);\n\n /**\n * @dev Approve or remove `operator` as an operator for the caller.\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\n *\n * Requirements:\n *\n * - The `operator` cannot be the caller.\n *\n * Emits an {ApprovalForAll} event.\n */\n function setApprovalForAll(address operator, bool _approved) external;\n\n /**\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\n *\n * See {setApprovalForAll}\n */\n function isApprovedForAll(address owner, address operator) external view returns (bool);\n\n /**\n * @dev Safely transfers `tokenId` token from `from` to `to`.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must exist and be owned by `from`.\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n *\n * Emits a {Transfer} event.\n */\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\n}\n" + }, + "@openzeppelin/contracts/utils/introspection/IERC165.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n /**\n * @dev Returns true if this contract implements the interface defined by\n * `interfaceId`. See the corresponding\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n * to learn more about how these ids are created.\n *\n * This function call must use less than 30 000 gas.\n */\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n" + }, + "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../utils/StringsUpgradeable.sol\";\nimport \"../utils/introspection/ERC165Upgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev External interface of AccessControl declared to support ERC165 detection.\n */\ninterface IAccessControlUpgradeable {\n function hasRole(bytes32 role, address account) external view returns (bool);\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\n function grantRole(bytes32 role, address account) external;\n function revokeRole(bytes32 role, address account) external;\n function renounceRole(bytes32 role, address account) external;\n}\n\n/**\n * @dev Contract module that allows children to implement role-based access\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\n * members except through off-chain means by accessing the contract event logs. Some\n * applications may benefit from on-chain enumerability, for those cases see\n * {AccessControlEnumerable}.\n *\n * Roles are referred to by their `bytes32` identifier. These should be exposed\n * in the external API and be unique. The best way to achieve this is by\n * using `public constant` hash digests:\n *\n * ```\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\n * ```\n *\n * Roles can be used to represent a set of permissions. To restrict access to a\n * function call, use {hasRole}:\n *\n * ```\n * function foo() public {\n * require(hasRole(MY_ROLE, msg.sender));\n * ...\n * }\n * ```\n *\n * Roles can be granted and revoked dynamically via the {grantRole} and\n * {revokeRole} functions. Each role has an associated admin role, and only\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\n *\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\n * that only accounts with this role will be able to grant or revoke other\n * roles. More complex role relationships can be created by using\n * {_setRoleAdmin}.\n *\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\n * grant and revoke this role. Extra precautions should be taken to secure\n * accounts that have been granted it.\n */\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\n function __AccessControl_init() internal initializer {\n __Context_init_unchained();\n __ERC165_init_unchained();\n __AccessControl_init_unchained();\n }\n\n function __AccessControl_init_unchained() internal initializer {\n }\n struct RoleData {\n mapping (address => bool) members;\n bytes32 adminRole;\n }\n\n mapping (bytes32 => RoleData) private _roles;\n\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n /**\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n *\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n * {RoleAdminChanged} not being emitted signaling this.\n *\n * _Available since v3.1._\n */\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n /**\n * @dev Emitted when `account` is granted `role`.\n *\n * `sender` is the account that originated the contract call, an admin role\n * bearer except when using {_setupRole}.\n */\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n /**\n * @dev Emitted when `account` is revoked `role`.\n *\n * `sender` is the account that originated the contract call:\n * - if using `revokeRole`, it is the admin role bearer\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\n */\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n /**\n * @dev Modifier that checks that an account has a specific role. Reverts\n * with a standardized message including the required role.\n *\n * The format of the revert reason is given by the following regular expression:\n *\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\n *\n * _Available since v4.1._\n */\n modifier onlyRole(bytes32 role) {\n _checkRole(role, _msgSender());\n _;\n }\n\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return interfaceId == type(IAccessControlUpgradeable).interfaceId\n || super.supportsInterface(interfaceId);\n }\n\n /**\n * @dev Returns `true` if `account` has been granted `role`.\n */\n function hasRole(bytes32 role, address account) public view override returns (bool) {\n return _roles[role].members[account];\n }\n\n /**\n * @dev Revert with a standard message if `account` is missing `role`.\n *\n * The format of the revert reason is given by the following regular expression:\n *\n * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/\n */\n function _checkRole(bytes32 role, address account) internal view {\n if(!hasRole(role, account)) {\n revert(string(abi.encodePacked(\n \"AccessControl: account \",\n StringsUpgradeable.toHexString(uint160(account), 20),\n \" is missing role \",\n StringsUpgradeable.toHexString(uint256(role), 32)\n )));\n }\n }\n\n /**\n * @dev Returns the admin role that controls `role`. See {grantRole} and\n * {revokeRole}.\n *\n * To change a role's admin, use {_setRoleAdmin}.\n */\n function getRoleAdmin(bytes32 role) public view override returns (bytes32) {\n return _roles[role].adminRole;\n }\n\n /**\n * @dev Grants `role` to `account`.\n *\n * If `account` had not been already granted `role`, emits a {RoleGranted}\n * event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n */\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\n _grantRole(role, account);\n }\n\n /**\n * @dev Revokes `role` from `account`.\n *\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n */\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\n _revokeRole(role, account);\n }\n\n /**\n * @dev Revokes `role` from the calling account.\n *\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\n * purpose is to provide a mechanism for accounts to lose their privileges\n * if they are compromised (such as when a trusted device is misplaced).\n *\n * If the calling account had been granted `role`, emits a {RoleRevoked}\n * event.\n *\n * Requirements:\n *\n * - the caller must be `account`.\n */\n function renounceRole(bytes32 role, address account) public virtual override {\n require(account == _msgSender(), \"AccessControl: can only renounce roles for self\");\n\n _revokeRole(role, account);\n }\n\n /**\n * @dev Grants `role` to `account`.\n *\n * If `account` had not been already granted `role`, emits a {RoleGranted}\n * event. Note that unlike {grantRole}, this function doesn't perform any\n * checks on the calling account.\n *\n * [WARNING]\n * ====\n * This function should only be called from the constructor when setting\n * up the initial roles for the system.\n *\n * Using this function in any other way is effectively circumventing the admin\n * system imposed by {AccessControl}.\n * ====\n */\n function _setupRole(bytes32 role, address account) internal virtual {\n _grantRole(role, account);\n }\n\n /**\n * @dev Sets `adminRole` as ``role``'s admin role.\n *\n * Emits a {RoleAdminChanged} event.\n */\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\n emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);\n _roles[role].adminRole = adminRole;\n }\n\n function _grantRole(bytes32 role, address account) private {\n if (!hasRole(role, account)) {\n _roles[role].members[account] = true;\n emit RoleGranted(role, account, _msgSender());\n }\n }\n\n function _revokeRole(bytes32 role, address account) private {\n if (hasRole(role, account)) {\n _roles[role].members[account] = false;\n emit RoleRevoked(role, account, _msgSender());\n }\n }\n uint256[49] private __gap;\n}\n" + }, + "contracts/nft/IStakeableNFT.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IStakeableNFT {\n function tokenBaseLoanSize(uint256 tokenId) external view returns (uint256);\n\n function tokenURIHash(uint256 tokenId)\n external\n view\n returns (string memory);\n\n function tokenContributionAsset(uint256 tokenId)\n external\n view\n returns (address);\n\n function tokenContributionSize(uint256 tokenId)\n external\n view\n returns (uint256);\n\n function tokenContributionMultiplier(uint256 tokenId)\n external\n view\n returns (uint8);\n}\n" + }, + "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\nimport \"../proxy/utils/Initializable.sol\";\n\n/*\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract ContextUpgradeable is Initializable {\n function __Context_init() internal initializer {\n __Context_init_unchained();\n }\n\n function __Context_init_unchained() internal initializer {\n }\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\n return msg.data;\n }\n uint256[50] private __gap;\n}\n" + }, + "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev String operations.\n */\nlibrary StringsUpgradeable {\n bytes16 private constant alphabet = \"0123456789abcdef\";\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n */\n function toString(uint256 value) internal pure returns (string memory) {\n // Inspired by OraclizeAPI's implementation - MIT licence\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\n\n if (value == 0) {\n return \"0\";\n }\n uint256 temp = value;\n uint256 digits;\n while (temp != 0) {\n digits++;\n temp /= 10;\n }\n bytes memory buffer = new bytes(digits);\n while (value != 0) {\n digits -= 1;\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\n value /= 10;\n }\n return string(buffer);\n }\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n */\n function toHexString(uint256 value) internal pure returns (string memory) {\n if (value == 0) {\n return \"0x00\";\n }\n uint256 temp = value;\n uint256 length = 0;\n while (temp != 0) {\n length++;\n temp >>= 8;\n }\n return toHexString(value, length);\n }\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n */\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n bytes memory buffer = new bytes(2 * length + 2);\n buffer[0] = \"0\";\n buffer[1] = \"x\";\n for (uint256 i = 2 * length + 1; i > 1; --i) {\n buffer[i] = alphabet[value & 0xf];\n value >>= 4;\n }\n require(value == 0, \"Strings: hex length insufficient\");\n return string(buffer);\n }\n\n}\n" + }, + "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165Upgradeable.sol\";\nimport \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n *\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\n */\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\n function __ERC165_init() internal initializer {\n __ERC165_init_unchained();\n }\n\n function __ERC165_init_unchained() internal initializer {\n }\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return interfaceId == type(IERC165Upgradeable).interfaceId;\n }\n uint256[50] private __gap;\n}\n" + }, + "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\n// solhint-disable-next-line compiler-version\npragma solidity ^0.8.0;\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n */\nabstract contract Initializable {\n\n /**\n * @dev Indicates that the contract has been initialized.\n */\n bool private _initialized;\n\n /**\n * @dev Indicates that the contract is in the process of being initialized.\n */\n bool private _initializing;\n\n /**\n * @dev Modifier to protect an initializer function from being invoked twice.\n */\n modifier initializer() {\n require(_initializing || !_initialized, \"Initializable: contract is already initialized\");\n\n bool isTopLevelCall = !_initializing;\n if (isTopLevelCall) {\n _initializing = true;\n _initialized = true;\n }\n\n _;\n\n if (isTopLevelCall) {\n _initializing = false;\n }\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165Upgradeable {\n /**\n * @dev Returns true if this contract implements the interface defined by\n * `interfaceId`. See the corresponding\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n * to learn more about how these ids are created.\n *\n * This function call must use less than 30 000 gas.\n */\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n" + }, + "contracts/nft/distributor/interfaces/ITellerNFTDistributor.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Interfaces\nimport \"../../ITellerNFT.sol\";\n\n// Utils\nimport { ClaimNFTRequest, MerkleRoot } from \"../data.sol\";\n\ninterface ITellerNFTDistributor {\n /**\n * @notice It gets the TellerNFT diamond instance used to mint.\n * @return _nft returns the TellerNFT diamond instance\n */\n function nft() external view returns (ITellerNFT _nft);\n\n /**\n * @notice It gets the merkle roots for NFTs it can distribute.\n * @return roots_ the returned merkle roots\n */\n function getMerkleRoots()\n external\n view\n returns (MerkleRoot[] memory roots_);\n\n /**\n * @notice It checks the merkle root for a tier if it has already been claimed.\n * @param merkleIndex Index of the tier.\n * @param nodeIndex Index of the node in the merkle root.\n * @return _claimed returns a boolean to check if the tier has already been claimed\n */\n function isClaimed(uint256 merkleIndex, uint256 nodeIndex)\n external\n view\n returns (bool _claimed);\n\n /**\n * @notice Claims TellerNFTs for a given verifiable merkle proofs for each tier.\n * @param account The address to claim NFTs on behalf.\n * @param requests An array requests data generated from the merkle tree.\n *\n * Requirements:\n * - Node in the merkle root must not be claimed already\n * - Proof of the node must match the merkle tree\n */\n function claim(address account, ClaimNFTRequest[] calldata requests)\n external;\n\n /**\n * @notice Adds a new merkle to be able to claim NFTs.\n * @param tierIndex Index of NFT tier to assign merkle for.\n * @param merkleRoot The merkle root to assign to the new tier.\n *\n * Requirements:\n * - Caller must be an admin\n */\n function addMerkle(uint256 tierIndex, bytes32 merkleRoot) external;\n\n /**\n * @notice Sets a merkle to be able to claim NFTs.\n * @param index Index of merkle to set.\n * @param tierIndex Index of NFT tier to assign merkle for.\n *\n * Requirements:\n * - Caller must be an admin\n */\n function moveMerkle(uint256 index, uint256 tierIndex) external;\n\n /**\n * @notice it grants either an ADMIN or a MINTER role into an account\n * @param role the role to be granted to an account\n * @param account the account address\n */\n function grantRole(bytes32 role, address account) external;\n\n /**\n * @notice it removes either an ADMIN or a MINTER role from an account\n * @param role the role to be granted to an account\n * @param account the account address\n */\n function revokeRole(bytes32 role, address account) external;\n\n /**\n * @notice Grants an address a new role.\n * @param role the role to revoke for the account\n * @param account the address of the respective account to revoke\n */\n function renounceRole(bytes32 role, address account) external;\n\n function setNFTDictionaryAddress(address dictionary) external;\n\n /**\n * @notice Initializes the Distributor contract with the TellerNFT\n * @param _nft The address of the TellerNFT.\n * @param admin The address of an admin.\n */\n function initialize(\n address _nft,\n address _dictionary,\n address admin\n ) external;\n}\n" + }, + "contracts/nft/distributor/entry/initialize.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../store.sol\";\nimport \"../../../contexts/initializable/modifiers/initializer.sol\";\nimport \"../../../contexts/access-control/entry/grant-role.sol\";\n\n// Utils\nimport { ADMIN } from \"../data.sol\";\n\n// Interfaces\nimport \"../../ITellerNFT.sol\";\nimport \"../../TellerNFTDictionary.sol\";\n\ncontract ent_initialize_NFTDistributor_v1 is\n sto_NFTDistributor,\n mod_initializer_Initializable_v1,\n ent_grantRole_AccessControl_v1\n{\n /**\n * @notice Initializes the Distributor contract with the TellerNFT\n * @param _nft The address of the TellerNFT.\n * @param admin The address of an admin.\n */\n function initialize(\n address _nft,\n address _dictionary,\n address admin\n ) external initializer {\n distributorStore().nft = ITellerNFT(_nft);\n distributorStore().dictionary = TellerNFTDictionary(_dictionary);\n\n _grantRole(ADMIN, admin);\n }\n}\n" + }, + "contracts/contexts/initializable/modifiers/initializer.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"../storage.sol\";\n\nabstract contract mod_initializer_Initializable_v1 is sto_Initializable {\n modifier initializer {\n require(\n !initializableStorage().initialized,\n \"Teller: already initialized\"\n );\n _;\n }\n}\n" + }, + "contracts/contexts/access-control/entry/grant-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../data.sol\";\nimport \"../internal/grant-role.sol\";\nimport \"../internal/is-admin-for-role.sol\";\n\ncontract ent_grantRole_AccessControl_v1 is\n int_grantRole_AccessControl_v1,\n int_isAdminForRole_AccessControl_v1\n{\n /**\n * @notice Grants an address a new role.\n *\n * Requirements:\n * - Sender must be role admin.\n */\n function grantRole(bytes32 role, address account) external {\n require(_isAdminForRole(role, msg.sender), \"AccessControl: not admin\");\n _grantRole(role, account);\n }\n}\n" + }, + "contracts/contexts/initializable/storage.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract sto_Initializable {\n struct InitializableLayout {\n bool initialized;\n }\n\n bytes32 internal constant INITIALIZABLE_STORAGE_POSITION =\n keccak256(abi.encode(\"teller_protocol.context.initializable.v1\"));\n\n function initializableStorage()\n internal\n pure\n returns (InitializableLayout storage l_)\n {\n bytes32 position = INITIALIZABLE_STORAGE_POSITION;\n\n assembly {\n l_.slot := position\n }\n }\n}\n" + }, + "contracts/settings/SettingsFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN, PAUSER, AUTHORIZED } from \"../shared/roles.sol\";\nimport {\n UpgradeableBeaconFactory\n} from \"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\";\nimport { TellerNFT } from \"../nft/TellerNFT.sol\";\nimport { TellerNFTDictionary } from \"../nft/TellerNFTDictionary.sol\";\n\n// Interfaces\nimport { IUniswapV2Router } from \"../shared/interfaces/IUniswapV2Router.sol\";\n\n// Libraries\nimport { RolesLib } from \"../contexts2/access-control/roles/RolesLib.sol\";\nimport { NFTLib } from \"../nft/libraries/NFTLib.sol\";\n\n// Storage\nimport { AppStorageLib, AppStorage } from \"../storage/app.sol\";\n\nstruct InitAssets {\n string sym;\n address addr;\n}\n\nstruct InitArgs {\n address admin;\n InitAssets[] assets;\n address[] cTokens;\n address tellerNFT;\n address loansEscrowBeacon;\n address collateralEscrowBeacon;\n address tTokenBeacon;\n address nftLiquidationController;\n address wrappedNativeToken;\n address nftDictionary;\n}\n\ncontract SettingsFacet is RolesMods {\n /**\n * @notice This event is emitted when the platform restriction is switched\n * @param restriction Boolean representing the state of the restriction\n * @param pauser address of the pauser flipping the switch\n */\n event PlatformRestricted(bool restriction, address indexed pauser);\n\n /**\n * @notice Restricts the use of the Teller protocol to authorized wallet addresses only\n * @param restriction Bool turning the resitriction on or off\n */\n function restrictPlatform(bool restriction)\n internal\n authorized(ADMIN, msg.sender)\n {\n AppStorageLib.store().platformRestricted = restriction;\n emit PlatformRestricted(restriction, msg.sender);\n }\n\n /**\n * @notice Adds a wallet address to the list of authorized wallets\n * @param account The wallet address of the user being authorized\n */\n function addAuthorizedAddress(address account)\n external\n authorized(ADMIN, msg.sender)\n {\n RolesLib.grantRole(AUTHORIZED, account);\n }\n\n /**\n * @notice Adds a list of wallet addresses to the list of authorized wallets\n * @param addressesToAdd The list of wallet addresses being authorized\n */\n function addAuthorizedAddressList(address[] calldata addressesToAdd)\n external\n authorized(ADMIN, msg.sender)\n {\n for (uint256 i; i < addressesToAdd.length; i++) {\n RolesLib.grantRole(AUTHORIZED, addressesToAdd[i]);\n }\n }\n\n /**\n * @notice Removes a wallet address from the list of authorized wallets\n * @param account The wallet address of the user being unauthorized\n */\n function removeAuthorizedAddress(address account)\n external\n authorized(ADMIN, msg.sender)\n {\n RolesLib.revokeRole(AUTHORIZED, account);\n }\n\n /**\n * @notice Tests whether an account has authorization\n * @param account The account address to check for\n * @return True if account has authorization, false if it does not\n */\n function hasAuthorization(address account) external view returns (bool) {\n return RolesLib.hasRole(AUTHORIZED, account);\n }\n\n /**\n * @notice Sets a new address to which NFTs should be sent when used for taking out a loan and gets liquidated.\n * @param newController The address where NFTs should be transferred.\n */\n function setNFTLiquidationController(address newController)\n external\n authorized(ADMIN, msg.sender)\n {\n AppStorageLib.store().nftLiquidationController = newController;\n }\n\n /**\n * @notice Gets the new address where NFTs are sent when used for taking out a loan and gets liquidated.\n * @return controller_ The address where NFTs are be transferred.\n */\n function getNFTLiquidationController()\n external\n returns (address controller_)\n {\n controller_ = AppStorageLib.store().nftLiquidationController;\n }\n\n /**\n * @notice it stores multiple parameters in the AppStorageLib\n * @param _args multiple arguments that are stored in the AppStorageLibrary\n */\n function init(InitArgs calldata _args) external {\n AppStorage storage s = AppStorageLib.store();\n\n if (s.initialized) return;\n s.initialized = true;\n\n RolesLib.grantRole(ADMIN, _args.admin);\n RolesLib.grantRole(PAUSER, _args.admin);\n\n for (uint256 i; i < _args.assets.length; i++) {\n s.assetAddresses[_args.assets[i].sym] = _args.assets[i].addr;\n }\n for (uint256 i; i < _args.cTokens.length; i++) {\n s.cTokenRegistry[_args.cTokens[i]] = true;\n }\n\n s.nft = TellerNFT(_args.tellerNFT);\n s.loansEscrowBeacon = UpgradeableBeaconFactory(_args.loansEscrowBeacon);\n s.collateralEscrowBeacon = UpgradeableBeaconFactory(\n _args.collateralEscrowBeacon\n );\n s.tTokenBeacon = UpgradeableBeaconFactory(_args.tTokenBeacon);\n s.nftLiquidationController = _args.nftLiquidationController;\n s.wrappedNativeToken = _args.wrappedNativeToken;\n\n NFTLib.s().nftDictionary = TellerNFTDictionary(_args.nftDictionary);\n }\n}\n" + }, + "contracts/contexts2/access-control/roles/RolesMods.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { RolesLib } from \"./RolesLib.sol\";\n\nabstract contract RolesMods {\n /**\n * @notice Requires that the {account} has {role}\n * @param role Encoding of the role to check.\n * @param account Address to check the {role} for.\n */\n modifier authorized(bytes32 role, address account) {\n require(\n RolesLib.hasRole(role, account),\n \"AccessControl: not authorized\"\n );\n _;\n }\n}\n" + }, + "contracts/shared/roles.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/**\n * @dev the roles for the user to assign, revoke and check in functions\n */\nbytes32 constant ADMIN = keccak256(\"ADMIN\");\nbytes32 constant PAUSER = keccak256(\"PAUSER\");\nbytes32 constant AUTHORIZED = keccak256(\"AUTHORIZED\");\n" + }, + "contracts/shared/proxy/beacon/UpgradeableBeaconFactory.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/proxy/Clones.sol\";\nimport \"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\";\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\nimport \"@openzeppelin/contracts/utils/Address.sol\";\nimport \"./InitializeableBeaconProxy.sol\";\n\n/**\n * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their\n * implementation contract, which is where they will delegate all function calls.\n *\n * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.\n */\ncontract UpgradeableBeaconFactory is IBeacon, Ownable {\n address private _implementation;\n InitializeableBeaconProxy public proxyAddress;\n\n /**\n * @dev Emitted when the implementation returned by the beacon is changed.\n */\n event Upgraded(address indexed implementation);\n\n /**\n * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the\n * beacon.\n */\n constructor(address payable proxyAddress_, address implementation_) {\n proxyAddress = InitializeableBeaconProxy(proxyAddress_);\n _setImplementation(implementation_);\n }\n\n /**\n * @dev Returns the current implementation address.\n */\n function implementation() public view virtual override returns (address) {\n return _implementation;\n }\n\n /**\n * @notice it clones the proxy contract at an address\n * @param initData the data to initialize after the proxy is cloned\n * @return proxy_ the cloned proxy\n */\n function cloneProxy(bytes memory initData)\n external\n returns (address payable proxy_)\n {\n proxy_ = payable(Clones.clone(address(proxyAddress)));\n InitializeableBeaconProxy(proxy_).initialize(address(this), initData);\n }\n\n /**\n * @dev Upgrades the beacon to a new implementation.\n *\n * Emits an {Upgraded} event.\n *\n * Requirements:\n *\n * - msg.sender must be the owner of the contract.\n * - `newImplementation` must be a contract.\n */\n function upgradeTo(address newImplementation) public virtual onlyOwner {\n _setImplementation(newImplementation);\n emit Upgraded(newImplementation);\n }\n\n /**\n * @dev Sets the implementation contract address for this beacon\n *\n * Requirements:\n *\n * - `newImplementation` must be a contract.\n */\n function _setImplementation(address newImplementation) private {\n require(\n Address.isContract(newImplementation),\n \"UpgradeableBeacon: implementation is not a contract\"\n );\n _implementation = newImplementation;\n }\n}\n" + }, + "contracts/nft/TellerNFT.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\npragma experimental ABIEncoderV2;\n\n// Contracts\nimport \"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\";\nimport \"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\";\n\n// Libraries\nimport \"@openzeppelin/contracts/utils/Counters.sol\";\nimport \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\nimport \"@openzeppelin/contracts/utils/math/SafeMath.sol\";\n\n// Interfaces\nimport \"./ITellerNFT.sol\";\n\n/*****************************************************************************************************/\n/** WARNING **/\n/** THIS CONTRACT IS UPGRADEABLE! **/\n/** --------------------------------------------------------------------------------------------- **/\n/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/\n/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/\n/** **/\n/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/\n/** more information. **/\n/*****************************************************************************************************/\n/**\n * @notice This contract is used by borrowers to call Dapp functions (using delegate calls).\n * @notice This contract should only be constructed using it's upgradeable Proxy contract.\n * @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.\n *\n * @author develop@teller.finance\n */\ncontract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {\n using Counters for Counters.Counter;\n using EnumerableSet for EnumerableSet.UintSet;\n using SafeMath for uint256;\n\n /* Constants */\n\n bytes32 public constant ADMIN = keccak256(\"ADMIN\");\n bytes32 public constant MINTER = keccak256(\"MINTER\");\n\n /* State Variables */\n\n // It holds the total number of tiers.\n Counters.Counter internal _tierCounter;\n\n // It holds the total number of tokens minted.\n Counters.Counter internal _tokenCounter;\n\n // It holds the information about a tier.\n mapping(uint256 => Tier) internal _tiers;\n\n // It holds which tier a token ID is in.\n mapping(uint256 => uint256) internal _tokenTier;\n\n // It holds a set of token IDs for an owner address.\n mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;\n\n // Link to the contract metadata\n string private _metadataBaseURI;\n\n // Hash to the contract metadata located on the {_metadataBaseURI}\n string private _contractURIHash;\n\n /* Modifiers */\n\n modifier onlyAdmin() {\n require(hasRole(ADMIN, _msgSender()), \"TellerNFT: not admin\");\n _;\n }\n\n modifier onlyMinter() {\n require(hasRole(MINTER, _msgSender()), \"TellerNFT: not minter\");\n _;\n }\n\n /* External Functions */\n\n /**\n * @notice It returns information about a Tier for a token ID.\n * @param index Tier index to get info.\n * @return tier_ the tier which belongs to the respective index\n */\n function getTier(uint256 index)\n external\n view\n override\n returns (Tier memory tier_)\n {\n tier_ = _tiers[index];\n }\n\n /**\n * @notice It returns information about a Tier for a token ID.\n * @param tokenId ID of the token to get Tier info.\n * @return index_ the index of the tier the tokenID belongs in\n * @return tier_ the tier where the tokenID belongs in\n */\n function getTokenTier(uint256 tokenId)\n external\n view\n override\n returns (uint256 index_, Tier memory tier_)\n {\n index_ = _tokenTier[tokenId];\n tier_ = _tiers[index_];\n }\n\n /**\n * @notice It returns an array of hashes in a tier\n * @param tierIndex the tier index to get the tier hashes\n * @return hashes_ all the tokenID hashes\n */\n function getTierHashes(uint256 tierIndex)\n external\n view\n override\n returns (string[] memory hashes_)\n {\n hashes_ = _tiers[tierIndex].hashes;\n }\n\n /**\n * @notice It returns an array of token IDs owned by an address.\n * @dev It uses a EnumerableSet to store values and loops over each element to add to the array.\n * @dev Can be costly if calling within a contract for address with many tokens.\n * @return owned_ the array of tokenIDs owned by the address\n */\n function getOwnedTokens(address owner)\n external\n view\n override\n returns (uint256[] memory owned_)\n {\n EnumerableSet.UintSet storage set = _ownerTokenIDs[owner];\n owned_ = new uint256[](set.length());\n for (uint256 i; i < owned_.length; i++) {\n owned_[i] = set.at(i);\n }\n }\n\n /**\n * @notice The contract metadata URI.\n * @return the contract URI hash\n */\n function contractURI() external view override returns (string memory) {\n return _contractURIHash;\n }\n\n /**\n * @notice The token URI is based on the token ID.\n * @param tokenId the token identifier that returns the hash of the baseURI and the tokenURI hash\n * @return the tokenURI\n */\n function tokenURI(uint256 tokenId)\n public\n view\n override\n returns (string memory)\n {\n require(_exists(tokenId), \"TellerNFT: URI query for nonexistent token\");\n\n string memory baseURI = _baseURI();\n return\n bytes(baseURI).length > 0\n ? string(abi.encodePacked(baseURI, _tokenURIHash(tokenId)))\n : \"\";\n }\n\n /**\n * @notice It mints a new token for a Tier index.\n * @param tierIndex Tier to mint token on.\n * @param owner The owner of the new token.\n *\n * Requirements:\n * - Caller must be an authorized minter\n */\n function mint(uint256 tierIndex, address owner)\n external\n override\n onlyMinter\n {\n // Get the new token ID\n uint256 tokenId = _tokenCounter.current();\n _tokenCounter.increment();\n\n // Mint and set the token to the tier index\n _safeMint(owner, tokenId);\n _tokenTier[tokenId] = tierIndex;\n\n // Set owner\n _setOwner(owner, tokenId);\n }\n\n /**\n * @notice Adds a new Tier to be minted with the given information.\n * @dev It auto increments the index of the next tier to add.\n * @param newTier Information about the new tier to add.\n *\n * Requirements:\n * - Caller must have the {MINTER} role\n */\n function addTier(Tier memory newTier) external override onlyMinter {\n Tier storage tier = _tiers[_tierCounter.current()];\n\n tier.baseLoanSize = newTier.baseLoanSize;\n tier.hashes = newTier.hashes;\n tier.contributionAsset = newTier.contributionAsset;\n tier.contributionSize = newTier.contributionSize;\n tier.contributionMultiplier = newTier.contributionMultiplier;\n\n _tierCounter.increment();\n }\n\n /**\n * @notice it removes the minter by revoking the role of the address assigned to MINTER\n * @param minter the address of the minter\n */\n function removeMinter(address minter) external onlyMinter {\n revokeRole(MINTER, minter);\n }\n\n /**\n * @notice it adds the minter to the rule\n * @param minter the address of the minter to add to the role of MINTER\n */\n function addMinter(address minter) public onlyMinter {\n _setupRole(MINTER, minter);\n }\n\n /**\n * @notice Sets the contract level metadata URI hash.\n * @param contractURIHash The hash to the initial contract level metadata.\n */\n function setContractURIHash(string memory contractURIHash)\n external\n override\n onlyAdmin\n {\n _contractURIHash = contractURIHash;\n }\n\n /**\n * @notice Initializes the TellerNFT.\n * @param minters The addresses that should allowed to mint tokens.\n */\n function initialize(address[] calldata minters)\n external\n override\n initializer\n {\n __ERC721_init(\"Teller NFT\", \"TNFT\");\n __AccessControl_init();\n\n for (uint256 i; i < minters.length; i++) {\n _setupRole(MINTER, minters[i]);\n }\n\n _metadataBaseURI = \"https://gateway.pinata.cloud/ipfs/\";\n _contractURIHash = \"QmWAfQFFwptzRUCdF2cBFJhcB2gfHJMd7TQt64dZUysk3R\";\n }\n\n /**\n * @notice checks if an interface is supported by ITellerNFT, ERC721Upgradeable or AccessControlUpgradeable\n * @param interfaceId the identifier of the interface\n * @return bool stating whether or not our interface is supported\n */\n function supportsInterface(bytes4 interfaceId)\n public\n view\n override(AccessControlUpgradeable, ERC721Upgradeable)\n returns (bool)\n {\n return\n interfaceId == type(ITellerNFT).interfaceId ||\n ERC721Upgradeable.supportsInterface(interfaceId) ||\n AccessControlUpgradeable.supportsInterface(interfaceId);\n }\n\n /**\n * @notice It returns the hash to use for the token URI.\n * @param tokenId the tokenId to get the tokenURI hash\n * @return the tokenURIHash of our NFT\n */\n function _tokenURIHash(uint256 tokenId)\n internal\n view\n returns (string memory)\n {\n string[] storage tierImageHashes = _tiers[_tokenTier[tokenId]].hashes;\n return tierImageHashes[tokenId.mod(tierImageHashes.length)];\n }\n\n /**\n * @notice The base URI path where the token media is hosted.\n * @dev Base URI for computing {tokenURI}\n * @return our metadata URI\n */\n function _baseURI() internal view override returns (string memory) {\n return _metadataBaseURI;\n }\n\n /**\n * @notice Moves token to new owner set and then transfers.\n * @param from address to transfer from\n * @param to address to transfer to\n * @param tokenId tokenID to transfer\n */\n function _transfer(\n address from,\n address to,\n uint256 tokenId\n ) internal override {\n _setOwner(to, tokenId);\n super._transfer(from, to, tokenId);\n }\n\n /**\n * @notice It removes the token from the current owner set and adds to new owner.\n * @param newOwner the new owner of the tokenID\n * @param tokenId the ID of the NFT\n */\n function _setOwner(address newOwner, uint256 tokenId) internal {\n address currentOwner = ownerOf(tokenId);\n if (currentOwner != address(0)) {\n _ownerTokenIDs[currentOwner].remove(tokenId);\n }\n _ownerTokenIDs[newOwner].add(tokenId);\n }\n\n function _msgData() internal pure override returns (bytes calldata) {\n return msg.data;\n }\n}\n" + }, + "contracts/shared/interfaces/IUniswapV2Router.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/**\n @notice This interface defines the different functions available for a UniswapV2Router.\n @author develop@teller.finance\n */\ninterface IUniswapV2Router {\n function factory() external pure returns (address);\n\n function addLiquidity(\n address tokenA,\n address tokenB,\n uint256 amountADesired,\n uint256 amountBDesired,\n uint256 amountAMin,\n uint256 amountBMin,\n address to,\n uint256 deadline\n )\n external\n returns (\n uint256 amountA,\n uint256 amountB,\n uint256 liquidity\n );\n\n function addLiquidityETH(\n address token,\n uint256 amountTokenDesired,\n uint256 amountTokenMin,\n uint256 amountETHMin,\n address to,\n uint256 deadline\n )\n external\n payable\n returns (\n uint256 amountToken,\n uint256 amountETH,\n uint256 liquidity\n );\n\n function removeLiquidity(\n address tokenA,\n address tokenB,\n uint256 liquidity,\n uint256 amountAMin,\n uint256 amountBMin,\n address to,\n uint256 deadline\n ) external returns (uint256 amountA, uint256 amountB);\n\n function removeLiquidityETH(\n address token,\n uint256 liquidity,\n uint256 amountTokenMin,\n uint256 amountETHMin,\n address to,\n uint256 deadline\n ) external returns (uint256 amountToken, uint256 amountETH);\n\n function removeLiquidityWithPermit(\n address tokenA,\n address tokenB,\n uint256 liquidity,\n uint256 amountAMin,\n uint256 amountBMin,\n address to,\n uint256 deadline,\n bool approveMax,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external returns (uint256 amountA, uint256 amountB);\n\n function removeLiquidityETHWithPermit(\n address token,\n uint256 liquidity,\n uint256 amountTokenMin,\n uint256 amountETHMin,\n address to,\n uint256 deadline,\n bool approveMax,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external returns (uint256 amountToken, uint256 amountETH);\n\n function quote(\n uint256 amountA,\n uint256 reserveA,\n uint256 reserveB\n ) external pure returns (uint256 amountB);\n\n function getAmountOut(\n uint256 amountIn,\n uint256 reserveIn,\n uint256 reserveOut\n ) external pure returns (uint256 amountOut);\n\n function getAmountIn(\n uint256 amountOut,\n uint256 reserveIn,\n uint256 reserveOut\n ) external pure returns (uint256 amountIn);\n\n function getAmountsOut(uint256 amountIn, address[] calldata path)\n external\n view\n returns (uint256[] memory amounts);\n\n function getAmountsIn(uint256 amountOut, address[] calldata path)\n external\n view\n returns (uint256[] memory amounts);\n\n /**\n @notice It returns the address of the canonical WETH address;\n */\n function WETH() external pure returns (address);\n\n /**\n @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\n @param amountIn The amount of input tokens to send.\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\n @param to Recipient of the output tokens.\n @param deadline Unix timestamp after which the transaction will revert.\n @return amounts The input token amount and all subsequent output token amounts.\n @dev msg.sender should have already given the router an allowance of at least amountIn on the input token.\n */\n function swapExactTokensForTokens(\n uint256 amountIn,\n uint256 amountOutMin,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external returns (uint256[] memory amounts);\n\n /**\n @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path. The first element of path is the input token, the last must be WETH, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\n @param amountIn The amount of input tokens to send.\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\n @param to Recipient of the ETH.\n @param deadline Unix timestamp after which the transaction will revert.\n @return amounts The input token amount and all subsequent output token amounts.\n @dev If the to address is a smart contract, it must have the ability to receive ETH.\n */\n function swapExactTokensForETH(\n uint256 amountIn,\n uint256 amountOutMin,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external returns (uint256[] memory amounts);\n\n /**\n @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the path. The first element of path must be WETH, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).\n @param amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.\n @param path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.\n @param to Recipient of the output tokens.\n @param deadline Unix timestamp after which the transaction will revert.\n @return amounts The input token amount and all subsequent output token amounts.\n */\n function swapExactETHForTokens(\n uint256 amountOutMin,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external payable returns (uint256[] memory amounts);\n\n function swapTokensForExactTokens(\n uint256 amountOut,\n uint256 amountInMax,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external returns (uint256[] memory amounts);\n\n function swapTokensForExactETH(\n uint256 amountOut,\n uint256 amountInMax,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external returns (uint256[] memory amounts);\n\n function swapETHForExactTokens(\n uint256 amountOut,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external payable returns (uint256[] memory amounts);\n}\n" + }, + "contracts/contexts2/access-control/roles/RolesLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlStorageLib, AccessControlStorage } from \"../storage.sol\";\n\nlibrary RolesLib {\n function s() private pure returns (AccessControlStorage storage) {\n return AccessControlStorageLib.store();\n }\n\n /**\n * @dev Emitted when `account` is granted `role`.\n */\n event RoleGranted(\n bytes32 indexed role,\n address indexed account,\n address indexed sender\n );\n\n /**\n * @dev Emitted when `account` is revoked `role`.\n */\n event RoleRevoked(\n bytes32 indexed role,\n address indexed account,\n address indexed sender\n );\n\n /**\n * @notice Checks if an account has a specific role.\n */\n function hasRole(bytes32 role, address account)\n internal\n view\n returns (bool)\n {\n return s().roles[role][account];\n }\n\n /**\n * @dev Gives an account a new role.\n * @dev Should only use when circumventing admin checking.\n * @dev If account already has the role, no event is emitted.\n * @param role Encoding of the role to give.\n * @param account Address to give the {role} to.\n */\n function grantRole(bytes32 role, address account) internal {\n if (hasRole(role, account)) return;\n s().roles[role][account] = true;\n emit RoleGranted(role, account, msg.sender);\n }\n\n /**\n * @dev Removes a role from an account.\n * @dev Should only use when circumventing admin checking.\n * @dev If account does not already have the role, no event is emitted.\n * @param role Encoding of the role to remove.\n * @param account Address to remove the {role} from.\n */\n function revokeRole(bytes32 role, address account) internal {\n if (!hasRole(role, account)) return;\n s().roles[role][account] = false;\n emit RoleRevoked(role, account, msg.sender);\n }\n}\n" + }, + "contracts/nft/libraries/NFTLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { TellerNFT } from \"../TellerNFT.sol\";\n\n// Libraries\nimport {\n MerkleProof\n} from \"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\n// Storage\nimport { AppStorageLib, AppStorage } from \"../../storage/app.sol\";\nimport { NFTStorageLib, NFTStorage } from \"../../storage/nft.sol\";\n\nlibrary NFTLib {\n function s() internal pure returns (NFTStorage storage s_) {\n s_ = NFTStorageLib.store();\n }\n\n function nft() internal view returns (TellerNFT nft_) {\n nft_ = AppStorageLib.store().nft;\n }\n\n /**s\n * @notice it transfers the NFT from the sender to the diamond to stake then adds the NFTID to the list of the owner's stakedNFTs\n * @param nftID the ID of the NFT to stake\n * @param owner the owner of the NFT who will stake the NFT\n */\n function stake(uint256 nftID, address owner) internal {\n // Transfer to diamond\n NFTLib.nft().transferFrom(msg.sender, address(this), nftID);\n // Add NFT ID to user set\n EnumerableSet.add(s().stakedNFTs[owner], nftID);\n }\n\n /**\n * @notice it unstakes the NFT by removing the NFT ID from the list of the user's staked NFTs\n * @param nftID the ID of the NFT to remove from the list of the user's staked NFTs\n * @return success_ the boolean value telling us if the user has unsuccessfully unstaked the NFT\n */\n function unstake(uint256 nftID) internal returns (bool success_) {\n success_ = EnumerableSet.remove(s().stakedNFTs[msg.sender], nftID);\n }\n\n /**\n * @notice it gets the list of staked NFTs from the owner\n * @param nftOwner the owner of the staked NFTs to pull from\n * @return staked_ the array of the staked NFTs owned by the user\n */\n function stakedNFTs(address nftOwner)\n internal\n view\n returns (uint256[] memory staked_)\n {\n EnumerableSet.UintSet storage nfts = s().stakedNFTs[nftOwner];\n staked_ = new uint256[](EnumerableSet.length(nfts));\n for (uint256 i; i < staked_.length; i++) {\n staked_[i] = EnumerableSet.at(nfts, i);\n }\n }\n\n /**\n * @notice if the user fails to pay his loan, then we liquidate the all the NFTs associated with the loan\n * @param loanID the identifier of the loan to liquidate the NFTs from\n */\n function liquidateNFT(uint256 loanID) internal {\n // Check if NFTs are linked\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\n NFTLib.nft().transferFrom(\n address(this),\n AppStorageLib.store().nftLiquidationController,\n EnumerableSet.at(nfts, i)\n );\n }\n }\n\n /**\n * @notice it unstakes an NFT and verifies the proof in order to apply the proof to a loan\n * @param loanID the identifier of the loan\n * @param nftID the NFT ID to apply to the loan\n */\n function applyToLoan(uint256 loanID, uint256 nftID) internal {\n // NFT must be currently staked\n // Remove NFT from being staked - returns bool\n require(unstake(nftID), \"Teller: borrower nft not staked\");\n\n // Apply NFT to loan\n EnumerableSet.add(s().loanNFTs[loanID], nftID);\n }\n\n /**\n * @notice it finds the loan's NFTs and adds them back to the owner's list of staked NFTs\n * @param loanID the identifier of the respective loan to add the NFTs back to the user's staked NFTs\n * @param owner the owner to add the unstaked NFTs back to the staked pile\n */\n function restakeLinked(uint256 loanID, address owner) internal {\n // Get linked NFT\n EnumerableSet.UintSet storage nfts = s().loanNFTs[loanID];\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\n // Restake the NFT\n EnumerableSet.add(s().stakedNFTs[owner], EnumerableSet.at(nfts, i));\n }\n }\n}\n" + }, + "contracts/storage/app.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { TellerNFT } from \"../nft/TellerNFT.sol\";\n\n// Interfaces\n\n// Libraries\nimport {\n PlatformSetting\n} from \"../settings/platform/libraries/PlatformSettingsLib.sol\";\nimport { Cache } from \"../shared/libraries/CacheLib.sol\";\nimport {\n UpgradeableBeaconFactory\n} from \"../shared/proxy/beacon/UpgradeableBeaconFactory.sol\";\n\nstruct AppStorage {\n // is it initialized\n bool initialized;\n // is it platform restricted\n bool platformRestricted;\n // mapping between contract IDs and if they're paused\n mapping(bytes32 => bool) paused;\n //p\n mapping(bytes32 => PlatformSetting) platformSettings;\n mapping(address => Cache) assetSettings;\n mapping(string => address) assetAddresses;\n mapping(address => bool) cTokenRegistry;\n TellerNFT nft;\n UpgradeableBeaconFactory loansEscrowBeacon;\n UpgradeableBeaconFactory collateralEscrowBeacon;\n address nftLiquidationController;\n UpgradeableBeaconFactory tTokenBeacon;\n address wrappedNativeToken;\n}\n\nlibrary AppStorageLib {\n function store() internal pure returns (AppStorage storage s) {\n assembly {\n s.slot := 0\n }\n }\n}\n" + }, + "contracts/contexts2/access-control/storage.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nstruct AccessControlStorage {\n mapping(bytes32 => mapping(address => bool)) roles;\n mapping(address => address) owners;\n mapping(bytes32 => bool) entered;\n}\n\nbytes32 constant ACCESS_CONTROL_POS = keccak256(\n \"teller.access_control.storage\"\n);\n\nlibrary AccessControlStorageLib {\n function store() internal pure returns (AccessControlStorage storage s) {\n bytes32 pos = ACCESS_CONTROL_POS;\n assembly {\n s.slot := pos\n }\n }\n}\n" + }, + "@openzeppelin/contracts/proxy/Clones.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\n * deploying minimal proxy contracts, also known as \"clones\".\n *\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\n *\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\n * deterministic method.\n *\n * _Available since v3.4._\n */\nlibrary Clones {\n /**\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\n *\n * This function uses the create opcode, which should never revert.\n */\n function clone(address implementation) internal returns (address instance) {\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let ptr := mload(0x40)\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\n mstore(add(ptr, 0x14), shl(0x60, implementation))\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\n instance := create(0, ptr, 0x37)\n }\n require(instance != address(0), \"ERC1167: create failed\");\n }\n\n /**\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\n *\n * This function uses the create2 opcode and a `salt` to deterministically deploy\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\n * the clones cannot be deployed twice at the same address.\n */\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let ptr := mload(0x40)\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\n mstore(add(ptr, 0x14), shl(0x60, implementation))\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\n instance := create2(0, ptr, 0x37, salt)\n }\n require(instance != address(0), \"ERC1167: create2 failed\");\n }\n\n /**\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\n */\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let ptr := mload(0x40)\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\n mstore(add(ptr, 0x14), shl(0x60, implementation))\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\n mstore(add(ptr, 0x38), shl(0x60, deployer))\n mstore(add(ptr, 0x4c), salt)\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\n predicted := keccak256(add(ptr, 0x37), 0x55)\n }\n }\n\n /**\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\n */\n function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {\n return predictDeterministicAddress(implementation, salt, address(this));\n }\n}\n" + }, + "@openzeppelin/contracts/proxy/beacon/IBeacon.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\n */\ninterface IBeacon {\n /**\n * @dev Must return an address that can be used as a delegate call target.\n *\n * {BeaconProxy} will check that this address is a contract.\n */\n function implementation() external view returns (address);\n}\n" + }, + "@openzeppelin/contracts/access/Ownable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n address private _owner;\n\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Initializes the contract setting the deployer as the initial owner.\n */\n constructor () {\n address msgSender = _msgSender();\n _owner = msgSender;\n emit OwnershipTransferred(address(0), msgSender);\n }\n\n /**\n * @dev Returns the address of the current owner.\n */\n function owner() public view virtual returns (address) {\n return _owner;\n }\n\n /**\n * @dev Throws if called by any account other than the owner.\n */\n modifier onlyOwner() {\n require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n _;\n }\n\n /**\n * @dev Leaves the contract without owner. It will not be possible to call\n * `onlyOwner` functions anymore. Can only be called by the current owner.\n *\n * NOTE: Renouncing ownership will leave the contract without an owner,\n * thereby removing any functionality that is only available to the owner.\n */\n function renounceOwnership() public virtual onlyOwner {\n emit OwnershipTransferred(_owner, address(0));\n _owner = address(0);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) public virtual onlyOwner {\n require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n emit OwnershipTransferred(_owner, newOwner);\n _owner = newOwner;\n }\n}\n" + }, + "@openzeppelin/contracts/utils/Address.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize, which returns 0 for contracts in\n // construction, since the code is only stored at the end of the\n // constructor execution.\n\n uint256 size;\n // solhint-disable-next-line no-inline-assembly\n assembly { size := extcodesize(account) }\n return size > 0;\n }\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\n (bool success, ) = recipient.call{ value: amount }(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain`call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCall(target, data, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n require(isContract(target), \"Address: call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\n return _verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\n require(isContract(target), \"Address: static call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.staticcall(data);\n return _verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\n require(isContract(target), \"Address: delegate call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return _verifyCallResult(success, returndata, errorMessage);\n }\n\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\n if (success) {\n return returndata;\n } else {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n }\n}\n" + }, + "contracts/shared/proxy/beacon/InitializeableBeaconProxy.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\";\nimport \"@openzeppelin/contracts/proxy/Proxy.sol\";\nimport \"@openzeppelin/contracts/utils/Address.sol\";\n\n/**\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\n *\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\n * conflict with the storage layout of the implementation behind the proxy.\n *\n * _Available since v3.4._\n */\ncontract InitializeableBeaconProxy is Proxy {\n /**\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\n */\n bytes32 private constant _BEACON_SLOT =\n 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\n\n /**\n * @dev Initializes the proxy with `beacon`.\n *\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\n * constructor.\n *\n * Requirements:\n *\n * - `beacon` must be a contract with the interface {IBeacon}.\n */\n function initialize(address beacon, bytes memory data) external payable {\n assert(\n _BEACON_SLOT ==\n bytes32(uint256(keccak256(\"eip1967.proxy.beacon\")) - 1)\n );\n require(_beacon() == address(0), \"Beacon: already initialized\");\n\n _setBeacon(beacon, data);\n }\n\n /**\n * @dev Returns the current beacon address.\n */\n function _beacon() internal view virtual returns (address beacon) {\n bytes32 slot = _BEACON_SLOT;\n // solhint-disable-next-line no-inline-assembly\n assembly {\n beacon := sload(slot)\n }\n }\n\n /**\n * @dev Returns the current implementation address of the associated beacon.\n */\n function _implementation()\n internal\n view\n virtual\n override\n returns (address)\n {\n return IBeacon(_beacon()).implementation();\n }\n\n /**\n * @dev Changes the proxy to use a new beacon.\n *\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\n *\n * Requirements:\n *\n * - `beacon` must be a contract.\n * - The implementation returned by `beacon` must be a contract.\n */\n function _setBeacon(address beacon, bytes memory data) internal virtual {\n bytes32 slot = _BEACON_SLOT;\n\n // solhint-disable-next-line no-inline-assembly\n assembly {\n sstore(slot, beacon)\n }\n\n if (data.length > 0) {\n Address.functionDelegateCall(\n _implementation(),\n data,\n \"BeaconProxy: function call failed\"\n );\n }\n }\n\n receive() external payable override {\n // Needed to receive ETH without data\n // OZ Proxy contract calls the _fallback() on receive and tries to delegatecall which fails\n }\n}\n" + }, + "@openzeppelin/contracts/utils/Context.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/*\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\n return msg.data;\n }\n}\n" + }, + "@openzeppelin/contracts/proxy/Proxy.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\n * be specified by overriding the virtual {_implementation} function.\n *\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\n * different contract through the {_delegate} function.\n *\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\n */\nabstract contract Proxy {\n /**\n * @dev Delegates the current call to `implementation`.\n *\n * This function does not return to its internall call site, it will return directly to the external caller.\n */\n function _delegate(address implementation) internal virtual {\n // solhint-disable-next-line no-inline-assembly\n assembly {\n // Copy msg.data. We take full control of memory in this inline assembly\n // block because it will not return to Solidity code. We overwrite the\n // Solidity scratch pad at memory position 0.\n calldatacopy(0, 0, calldatasize())\n\n // Call the implementation.\n // out and outsize are 0 because we don't know the size yet.\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\n\n // Copy the returned data.\n returndatacopy(0, 0, returndatasize())\n\n switch result\n // delegatecall returns 0 on error.\n case 0 { revert(0, returndatasize()) }\n default { return(0, returndatasize()) }\n }\n }\n\n /**\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\n * and {_fallback} should delegate.\n */\n function _implementation() internal view virtual returns (address);\n\n /**\n * @dev Delegates the current call to the address returned by `_implementation()`.\n *\n * This function does not return to its internall call site, it will return directly to the external caller.\n */\n function _fallback() internal virtual {\n _beforeFallback();\n _delegate(_implementation());\n }\n\n /**\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\n * function in the contract matches the call data.\n */\n fallback () external payable virtual {\n _fallback();\n }\n\n /**\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\n * is empty.\n */\n receive () external payable virtual {\n _fallback();\n }\n\n /**\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\n * call, or as part of the Solidity `fallback` or `receive` functions.\n *\n * If overriden should call `super._beforeFallback()`.\n */\n function _beforeFallback() internal virtual {\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IERC721Upgradeable.sol\";\nimport \"./IERC721ReceiverUpgradeable.sol\";\nimport \"./extensions/IERC721MetadataUpgradeable.sol\";\nimport \"../../utils/AddressUpgradeable.sol\";\nimport \"../../utils/ContextUpgradeable.sol\";\nimport \"../../utils/StringsUpgradeable.sol\";\nimport \"../../utils/introspection/ERC165Upgradeable.sol\";\nimport \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\n * {ERC721Enumerable}.\n */\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\n using AddressUpgradeable for address;\n using StringsUpgradeable for uint256;\n\n // Token name\n string private _name;\n\n // Token symbol\n string private _symbol;\n\n // Mapping from token ID to owner address\n mapping (uint256 => address) private _owners;\n\n // Mapping owner address to token count\n mapping (address => uint256) private _balances;\n\n // Mapping from token ID to approved address\n mapping (uint256 => address) private _tokenApprovals;\n\n // Mapping from owner to operator approvals\n mapping (address => mapping (address => bool)) private _operatorApprovals;\n\n /**\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\n */\n function __ERC721_init(string memory name_, string memory symbol_) internal initializer {\n __Context_init_unchained();\n __ERC165_init_unchained();\n __ERC721_init_unchained(name_, symbol_);\n }\n\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {\n _name = name_;\n _symbol = symbol_;\n }\n\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\n return interfaceId == type(IERC721Upgradeable).interfaceId\n || interfaceId == type(IERC721MetadataUpgradeable).interfaceId\n || super.supportsInterface(interfaceId);\n }\n\n /**\n * @dev See {IERC721-balanceOf}.\n */\n function balanceOf(address owner) public view virtual override returns (uint256) {\n require(owner != address(0), \"ERC721: balance query for the zero address\");\n return _balances[owner];\n }\n\n /**\n * @dev See {IERC721-ownerOf}.\n */\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\n address owner = _owners[tokenId];\n require(owner != address(0), \"ERC721: owner query for nonexistent token\");\n return owner;\n }\n\n /**\n * @dev See {IERC721Metadata-name}.\n */\n function name() public view virtual override returns (string memory) {\n return _name;\n }\n\n /**\n * @dev See {IERC721Metadata-symbol}.\n */\n function symbol() public view virtual override returns (string memory) {\n return _symbol;\n }\n\n /**\n * @dev See {IERC721Metadata-tokenURI}.\n */\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\n require(_exists(tokenId), \"ERC721Metadata: URI query for nonexistent token\");\n\n string memory baseURI = _baseURI();\n return bytes(baseURI).length > 0\n ? string(abi.encodePacked(baseURI, tokenId.toString()))\n : '';\n }\n\n /**\n * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden\n * in child contracts.\n */\n function _baseURI() internal view virtual returns (string memory) {\n return \"\";\n }\n\n /**\n * @dev See {IERC721-approve}.\n */\n function approve(address to, uint256 tokenId) public virtual override {\n address owner = ERC721Upgradeable.ownerOf(tokenId);\n require(to != owner, \"ERC721: approval to current owner\");\n\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\n \"ERC721: approve caller is not owner nor approved for all\"\n );\n\n _approve(to, tokenId);\n }\n\n /**\n * @dev See {IERC721-getApproved}.\n */\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\n require(_exists(tokenId), \"ERC721: approved query for nonexistent token\");\n\n return _tokenApprovals[tokenId];\n }\n\n /**\n * @dev See {IERC721-setApprovalForAll}.\n */\n function setApprovalForAll(address operator, bool approved) public virtual override {\n require(operator != _msgSender(), \"ERC721: approve to caller\");\n\n _operatorApprovals[_msgSender()][operator] = approved;\n emit ApprovalForAll(_msgSender(), operator, approved);\n }\n\n /**\n * @dev See {IERC721-isApprovedForAll}.\n */\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\n return _operatorApprovals[owner][operator];\n }\n\n /**\n * @dev See {IERC721-transferFrom}.\n */\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\n //solhint-disable-next-line max-line-length\n require(_isApprovedOrOwner(_msgSender(), tokenId), \"ERC721: transfer caller is not owner nor approved\");\n\n _transfer(from, to, tokenId);\n }\n\n /**\n * @dev See {IERC721-safeTransferFrom}.\n */\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\n safeTransferFrom(from, to, tokenId, \"\");\n }\n\n /**\n * @dev See {IERC721-safeTransferFrom}.\n */\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\n require(_isApprovedOrOwner(_msgSender(), tokenId), \"ERC721: transfer caller is not owner nor approved\");\n _safeTransfer(from, to, tokenId, _data);\n }\n\n /**\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\n *\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\n *\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\n * implement alternative mechanisms to perform token transfer, such as signature-based.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must exist and be owned by `from`.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n *\n * Emits a {Transfer} event.\n */\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\n _transfer(from, to, tokenId);\n require(_checkOnERC721Received(from, to, tokenId, _data), \"ERC721: transfer to non ERC721Receiver implementer\");\n }\n\n /**\n * @dev Returns whether `tokenId` exists.\n *\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\n *\n * Tokens start existing when they are minted (`_mint`),\n * and stop existing when they are burned (`_burn`).\n */\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\n return _owners[tokenId] != address(0);\n }\n\n /**\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\n *\n * Requirements:\n *\n * - `tokenId` must exist.\n */\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\n require(_exists(tokenId), \"ERC721: operator query for nonexistent token\");\n address owner = ERC721Upgradeable.ownerOf(tokenId);\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\n }\n\n /**\n * @dev Safely mints `tokenId` and transfers it to `to`.\n *\n * Requirements:\n *\n * - `tokenId` must not exist.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n *\n * Emits a {Transfer} event.\n */\n function _safeMint(address to, uint256 tokenId) internal virtual {\n _safeMint(to, tokenId, \"\");\n }\n\n /**\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\n */\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\n _mint(to, tokenId);\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \"ERC721: transfer to non ERC721Receiver implementer\");\n }\n\n /**\n * @dev Mints `tokenId` and transfers it to `to`.\n *\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\n *\n * Requirements:\n *\n * - `tokenId` must not exist.\n * - `to` cannot be the zero address.\n *\n * Emits a {Transfer} event.\n */\n function _mint(address to, uint256 tokenId) internal virtual {\n require(to != address(0), \"ERC721: mint to the zero address\");\n require(!_exists(tokenId), \"ERC721: token already minted\");\n\n _beforeTokenTransfer(address(0), to, tokenId);\n\n _balances[to] += 1;\n _owners[tokenId] = to;\n\n emit Transfer(address(0), to, tokenId);\n }\n\n /**\n * @dev Destroys `tokenId`.\n * The approval is cleared when the token is burned.\n *\n * Requirements:\n *\n * - `tokenId` must exist.\n *\n * Emits a {Transfer} event.\n */\n function _burn(uint256 tokenId) internal virtual {\n address owner = ERC721Upgradeable.ownerOf(tokenId);\n\n _beforeTokenTransfer(owner, address(0), tokenId);\n\n // Clear approvals\n _approve(address(0), tokenId);\n\n _balances[owner] -= 1;\n delete _owners[tokenId];\n\n emit Transfer(owner, address(0), tokenId);\n }\n\n /**\n * @dev Transfers `tokenId` from `from` to `to`.\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\n *\n * Requirements:\n *\n * - `to` cannot be the zero address.\n * - `tokenId` token must be owned by `from`.\n *\n * Emits a {Transfer} event.\n */\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \"ERC721: transfer of token that is not own\");\n require(to != address(0), \"ERC721: transfer to the zero address\");\n\n _beforeTokenTransfer(from, to, tokenId);\n\n // Clear approvals from the previous owner\n _approve(address(0), tokenId);\n\n _balances[from] -= 1;\n _balances[to] += 1;\n _owners[tokenId] = to;\n\n emit Transfer(from, to, tokenId);\n }\n\n /**\n * @dev Approve `to` to operate on `tokenId`\n *\n * Emits a {Approval} event.\n */\n function _approve(address to, uint256 tokenId) internal virtual {\n _tokenApprovals[tokenId] = to;\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\n }\n\n /**\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\n * The call is not executed if the target address is not a contract.\n *\n * @param from address representing the previous owner of the given token ID\n * @param to target address that will receive the tokens\n * @param tokenId uint256 ID of the token to be transferred\n * @param _data bytes optional data to send along with the call\n * @return bool whether the call correctly returned the expected magic value\n */\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\n private returns (bool)\n {\n if (to.isContract()) {\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\n } catch (bytes memory reason) {\n if (reason.length == 0) {\n revert(\"ERC721: transfer to non ERC721Receiver implementer\");\n } else {\n // solhint-disable-next-line no-inline-assembly\n assembly {\n revert(add(32, reason), mload(reason))\n }\n }\n }\n } else {\n return true;\n }\n }\n\n /**\n * @dev Hook that is called before any token transfer. This includes minting\n * and burning.\n *\n * Calling conditions:\n *\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\n * transferred to `to`.\n * - When `from` is zero, `tokenId` will be minted for `to`.\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n *\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n */\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\n uint256[44] private __gap;\n}\n" + }, + "@openzeppelin/contracts/utils/Counters.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @title Counters\n * @author Matt Condon (@shrugs)\n * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\n *\n * Include with `using Counters for Counters.Counter;`\n */\nlibrary Counters {\n struct Counter {\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\n // this feature: see https://github.com/ethereum/solidity/issues/4637\n uint256 _value; // default: 0\n }\n\n function current(Counter storage counter) internal view returns (uint256) {\n return counter._value;\n }\n\n function increment(Counter storage counter) internal {\n unchecked {\n counter._value += 1;\n }\n }\n\n function decrement(Counter storage counter) internal {\n uint256 value = counter._value;\n require(value > 0, \"Counter: decrement overflow\");\n unchecked {\n counter._value = value - 1;\n }\n }\n}\n" + }, + "@openzeppelin/contracts/utils/structs/EnumerableSet.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for managing\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\n * types.\n *\n * Sets have the following properties:\n *\n * - Elements are added, removed, and checked for existence in constant time\n * (O(1)).\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\n *\n * ```\n * contract Example {\n * // Add the library methods\n * using EnumerableSet for EnumerableSet.AddressSet;\n *\n * // Declare a set state variable\n * EnumerableSet.AddressSet private mySet;\n * }\n * ```\n *\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\n * and `uint256` (`UintSet`) are supported.\n */\nlibrary EnumerableSet {\n // To implement this library for multiple types with as little code\n // repetition as possible, we write it in terms of a generic Set type with\n // bytes32 values.\n // The Set implementation uses private functions, and user-facing\n // implementations (such as AddressSet) are just wrappers around the\n // underlying Set.\n // This means that we can only create new EnumerableSets for types that fit\n // in bytes32.\n\n struct Set {\n // Storage of set values\n bytes32[] _values;\n\n // Position of the value in the `values` array, plus 1 because index 0\n // means a value is not in the set.\n mapping (bytes32 => uint256) _indexes;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function _add(Set storage set, bytes32 value) private returns (bool) {\n if (!_contains(set, value)) {\n set._values.push(value);\n // The value is stored at length-1, but we add 1 to all indexes\n // and use 0 as a sentinel value\n set._indexes[value] = set._values.length;\n return true;\n } else {\n return false;\n }\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function _remove(Set storage set, bytes32 value) private returns (bool) {\n // We read and store the value's index to prevent multiple reads from the same storage slot\n uint256 valueIndex = set._indexes[value];\n\n if (valueIndex != 0) { // Equivalent to contains(set, value)\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\n // the array, and then remove the last element (sometimes called as 'swap and pop').\n // This modifies the order of the array, as noted in {at}.\n\n uint256 toDeleteIndex = valueIndex - 1;\n uint256 lastIndex = set._values.length - 1;\n\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\n\n bytes32 lastvalue = set._values[lastIndex];\n\n // Move the last value to the index where the value to delete is\n set._values[toDeleteIndex] = lastvalue;\n // Update the index for the moved value\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\n\n // Delete the slot where the moved value was stored\n set._values.pop();\n\n // Delete the index for the deleted slot\n delete set._indexes[value];\n\n return true;\n } else {\n return false;\n }\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\n return set._indexes[value] != 0;\n }\n\n /**\n * @dev Returns the number of values on the set. O(1).\n */\n function _length(Set storage set) private view returns (uint256) {\n return set._values.length;\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\n require(set._values.length > index, \"EnumerableSet: index out of bounds\");\n return set._values[index];\n }\n\n // Bytes32Set\n\n struct Bytes32Set {\n Set _inner;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\n return _add(set._inner, value);\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\n return _remove(set._inner, value);\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\n return _contains(set._inner, value);\n }\n\n /**\n * @dev Returns the number of values in the set. O(1).\n */\n function length(Bytes32Set storage set) internal view returns (uint256) {\n return _length(set._inner);\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\n return _at(set._inner, index);\n }\n\n // AddressSet\n\n struct AddressSet {\n Set _inner;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function add(AddressSet storage set, address value) internal returns (bool) {\n return _add(set._inner, bytes32(uint256(uint160(value))));\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function remove(AddressSet storage set, address value) internal returns (bool) {\n return _remove(set._inner, bytes32(uint256(uint160(value))));\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function contains(AddressSet storage set, address value) internal view returns (bool) {\n return _contains(set._inner, bytes32(uint256(uint160(value))));\n }\n\n /**\n * @dev Returns the number of values in the set. O(1).\n */\n function length(AddressSet storage set) internal view returns (uint256) {\n return _length(set._inner);\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\n return address(uint160(uint256(_at(set._inner, index))));\n }\n\n\n // UintSet\n\n struct UintSet {\n Set _inner;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function add(UintSet storage set, uint256 value) internal returns (bool) {\n return _add(set._inner, bytes32(value));\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\n return _remove(set._inner, bytes32(value));\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\n return _contains(set._inner, bytes32(value));\n }\n\n /**\n * @dev Returns the number of values on the set. O(1).\n */\n function length(UintSet storage set) internal view returns (uint256) {\n return _length(set._inner);\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\n return uint256(_at(set._inner, index));\n }\n}\n" + }, + "@openzeppelin/contracts/utils/math/SafeMath.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n// CAUTION\n// This version of SafeMath should only be used with Solidity 0.8 or later,\n// because it relies on the compiler's built in overflow checks.\n\n/**\n * @dev Wrappers over Solidity's arithmetic operations.\n *\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\n * now has built in overflow checking.\n */\nlibrary SafeMath {\n /**\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\n *\n * _Available since v3.4._\n */\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n uint256 c = a + b;\n if (c < a) return (false, 0);\n return (true, c);\n }\n }\n\n /**\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\n *\n * _Available since v3.4._\n */\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b > a) return (false, 0);\n return (true, a - b);\n }\n }\n\n /**\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\n *\n * _Available since v3.4._\n */\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n // benefit is lost if 'b' is also tested.\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n if (a == 0) return (true, 0);\n uint256 c = a * b;\n if (c / a != b) return (false, 0);\n return (true, c);\n }\n }\n\n /**\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\n *\n * _Available since v3.4._\n */\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b == 0) return (false, 0);\n return (true, a / b);\n }\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\n *\n * _Available since v3.4._\n */\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b == 0) return (false, 0);\n return (true, a % b);\n }\n }\n\n /**\n * @dev Returns the addition of two unsigned integers, reverting on\n * overflow.\n *\n * Counterpart to Solidity's `+` operator.\n *\n * Requirements:\n *\n * - Addition cannot overflow.\n */\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\n return a + b;\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, reverting on\n * overflow (when the result is negative).\n *\n * Counterpart to Solidity's `-` operator.\n *\n * Requirements:\n *\n * - Subtraction cannot overflow.\n */\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n return a - b;\n }\n\n /**\n * @dev Returns the multiplication of two unsigned integers, reverting on\n * overflow.\n *\n * Counterpart to Solidity's `*` operator.\n *\n * Requirements:\n *\n * - Multiplication cannot overflow.\n */\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n return a * b;\n }\n\n /**\n * @dev Returns the integer division of two unsigned integers, reverting on\n * division by zero. The result is rounded towards zero.\n *\n * Counterpart to Solidity's `/` operator.\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\n return a / b;\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n * reverting when dividing by zero.\n *\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n return a % b;\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n * overflow (when the result is negative).\n *\n * CAUTION: This function is deprecated because it requires allocating memory for the error\n * message unnecessarily. For custom revert reasons use {trySub}.\n *\n * Counterpart to Solidity's `-` operator.\n *\n * Requirements:\n *\n * - Subtraction cannot overflow.\n */\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n unchecked {\n require(b <= a, errorMessage);\n return a - b;\n }\n }\n\n /**\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\n * division by zero. The result is rounded towards zero.\n *\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Counterpart to Solidity's `/` operator. Note: this function uses a\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\n * uses an invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n unchecked {\n require(b > 0, errorMessage);\n return a / b;\n }\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n * reverting with custom message when dividing by zero.\n *\n * CAUTION: This function is deprecated because it requires allocating memory for the error\n * message unnecessarily. For custom revert reasons use {tryMod}.\n *\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n unchecked {\n require(b > 0, errorMessage);\n return a % b;\n }\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../../utils/introspection/IERC165Upgradeable.sol\";\n\n/**\n * @dev Required interface of an ERC721 compliant contract.\n */\ninterface IERC721Upgradeable is IERC165Upgradeable {\n /**\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\n */\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n\n /**\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\n */\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n\n /**\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\n */\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n /**\n * @dev Returns the number of tokens in ``owner``'s account.\n */\n function balanceOf(address owner) external view returns (uint256 balance);\n\n /**\n * @dev Returns the owner of the `tokenId` token.\n *\n * Requirements:\n *\n * - `tokenId` must exist.\n */\n function ownerOf(uint256 tokenId) external view returns (address owner);\n\n /**\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must exist and be owned by `from`.\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n *\n * Emits a {Transfer} event.\n */\n function safeTransferFrom(address from, address to, uint256 tokenId) external;\n\n /**\n * @dev Transfers `tokenId` token from `from` to `to`.\n *\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must be owned by `from`.\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address from, address to, uint256 tokenId) external;\n\n /**\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\n * The approval is cleared when the token is transferred.\n *\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\n *\n * Requirements:\n *\n * - The caller must own the token or be an approved operator.\n * - `tokenId` must exist.\n *\n * Emits an {Approval} event.\n */\n function approve(address to, uint256 tokenId) external;\n\n /**\n * @dev Returns the account approved for `tokenId` token.\n *\n * Requirements:\n *\n * - `tokenId` must exist.\n */\n function getApproved(uint256 tokenId) external view returns (address operator);\n\n /**\n * @dev Approve or remove `operator` as an operator for the caller.\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\n *\n * Requirements:\n *\n * - The `operator` cannot be the caller.\n *\n * Emits an {ApprovalForAll} event.\n */\n function setApprovalForAll(address operator, bool _approved) external;\n\n /**\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\n *\n * See {setApprovalForAll}\n */\n function isApprovedForAll(address owner, address operator) external view returns (bool);\n\n /**\n * @dev Safely transfers `tokenId` token from `from` to `to`.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must exist and be owned by `from`.\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n *\n * Emits a {Transfer} event.\n */\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @title ERC721 token receiver interface\n * @dev Interface for any contract that wants to support safeTransfers\n * from ERC721 asset contracts.\n */\ninterface IERC721ReceiverUpgradeable {\n /**\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\n * by `operator` from `from`, this function is called.\n *\n * It must return its Solidity selector to confirm the token transfer.\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\n *\n * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\n */\n function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC721Upgradeable.sol\";\n\n/**\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\n * @dev See https://eips.ethereum.org/EIPS/eip-721\n */\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\n\n /**\n * @dev Returns the token collection name.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the token collection symbol.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\n */\n function tokenURI(uint256 tokenId) external view returns (string memory);\n}\n" + }, + "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary AddressUpgradeable {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize, which returns 0 for contracts in\n // construction, since the code is only stored at the end of the\n // constructor execution.\n\n uint256 size;\n // solhint-disable-next-line no-inline-assembly\n assembly { size := extcodesize(account) }\n return size > 0;\n }\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\n (bool success, ) = recipient.call{ value: amount }(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain`call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCall(target, data, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n require(isContract(target), \"Address: call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\n return _verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\n require(isContract(target), \"Address: static call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.staticcall(data);\n return _verifyCallResult(success, returndata, errorMessage);\n }\n\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\n if (success) {\n return returndata;\n } else {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n }\n}\n" + }, + "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev These functions deal with verification of Merkle Trees proofs.\n *\n * The proofs can be generated using the JavaScript library\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\n *\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\n */\nlibrary MerkleProof {\n /**\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\n * defined by `root`. For this, a `proof` must be provided, containing\n * sibling hashes on the branch from the leaf to the root of the tree. Each\n * pair of leaves and each pair of pre-images are assumed to be sorted.\n */\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\n bytes32 computedHash = leaf;\n\n for (uint256 i = 0; i < proof.length; i++) {\n bytes32 proofElement = proof[i];\n\n if (computedHash <= proofElement) {\n // Hash(current computed hash + current element of the proof)\n computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\n } else {\n // Hash(current element of the proof + current computed hash)\n computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\n }\n }\n\n // Check if the computed hash (root) is equal to the provided root\n return computedHash == root;\n }\n}\n" + }, + "contracts/storage/nft.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../nft/TellerNFTDictionary.sol\";\n\n// Utils\nimport \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\nstruct NFTStorage {\n // Maps NFT owner to set of token IDs owned\n mapping(address => EnumerableSet.UintSet) stakedNFTs;\n // Maps loanID to NFT IDs indicating NFT being used for the loan\n mapping(uint256 => EnumerableSet.UintSet) loanNFTs;\n // Merkle root used for verifying nft IDs to base loan size\n TellerNFTDictionary nftDictionary;\n}\n\nbytes32 constant NFT_STORAGE_POS = keccak256(\"teller.staking.storage\");\n\nlibrary NFTStorageLib {\n function store() internal pure returns (NFTStorage storage s) {\n bytes32 pos = NFT_STORAGE_POS;\n assembly {\n s.slot := pos\n }\n }\n}\n" + }, + "contracts/settings/platform/libraries/PlatformSettingsLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AppStorageLib } from \"../../../storage/app.sol\";\nimport \"../names.sol\" as NAMES;\nimport {\n RolesMods\n} from \"../../../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN, AUTHORIZED } from \"../../../shared/roles.sol\";\nimport { RolesLib } from \"../../../contexts2/access-control/roles/RolesLib.sol\";\n\n// It defines a platform settings. It includes: value, min, and max values.\nstruct PlatformSetting {\n uint256 value;\n uint256 min;\n uint256 max;\n bool exists;\n}\n\n/**\n * @notice Utility library of inline functions on the PlatformSetting struct.\n *\n * @author develop@teller.finance\n */\nlibrary PlatformSettingsLib {\n function s(bytes32 name) internal view returns (PlatformSetting storage) {\n return AppStorageLib.store().platformSettings[name];\n }\n\n /**\n * @notice It gets the current \"NFTInterestRate\" setting's value\n * @return value_ the current value.\n */\n function getNFTInterestRate() internal view returns (uint16 value_) {\n value_ = uint16(s(NAMES.NFT_INTEREST_RATE).value);\n }\n\n /**\n * @notice It gets the current \"RequiredSubmissionsPercentage\" setting's value\n * @return value_ the current value.\n */\n function getRequiredSubmissionsPercentageValue()\n internal\n view\n returns (uint256 value_)\n {\n value_ = s(NAMES.REQUIRED_SUBMISSIONS_PERCENTAGE).value;\n }\n\n /**\n * @notice It gets the current \"MaximumTolerance\" setting's value\n * @return value_ the current value.\n */\n function getMaximumToleranceValue() internal view returns (uint256 value_) {\n value_ = s(NAMES.MAXIMUM_TOLERANCE).value;\n }\n\n /**\n * @notice It gets the current \"ResponseExpiryLength\" setting's value\n * @return value_ the current value.\n */\n function getResponseExpiryLengthValue()\n internal\n view\n returns (uint256 value_)\n {\n value_ = s(NAMES.RESPONSE_EXPIRY_LENGTH).value;\n }\n\n /**\n * @notice It gets the current \"SafetyInterval\" setting's value\n * @return value_ the current value.\n */\n function getSafetyIntervalValue() internal view returns (uint256 value_) {\n value_ = s(NAMES.SAFETY_INTERVAL).value;\n }\n\n /**\n * @notice It gets the current \"TermsExpiryTime\" setting's value\n * @return value_ the current value.\n */\n function getTermsExpiryTimeValue() internal view returns (uint256 value_) {\n value_ = s(NAMES.TERMS_EXPIRY_TIME).value;\n }\n\n /**\n * @notice It gets the current \"LiquidateRewardPercent\" setting's value\n * @return value_ the current value.\n */\n function getLiquidateRewardPercent()\n internal\n view\n returns (uint256 value_)\n {\n value_ = s(NAMES.LIQUIDATE_REWARD_PERCENT).value;\n }\n\n /**\n * @notice It gets the current \"MaximumLoanDuration\" setting's value\n * @return value_ the current value.\n */\n function getMaximumLoanDurationValue()\n internal\n view\n returns (uint256 value_)\n {\n value_ = s(NAMES.MAXIMUM_LOAN_DURATION).value;\n }\n\n /**\n * @notice It gets the current \"RequestLoanTermsRateLimit\" setting's value\n * @return value_ the current value.\n */\n function getRequestLoanTermsRateLimitValue()\n internal\n view\n returns (uint256 value_)\n {\n value_ = s(NAMES.REQUEST_LOAN_TERMS_RATE_LIMIT).value;\n }\n\n /**\n * @notice It gets the current \"CollateralBuffer\" setting's value\n * @return value_ the current value.\n */\n function getCollateralBufferValue() internal view returns (uint256 value_) {\n value_ = s(NAMES.COLLATERAL_BUFFER).value;\n }\n\n /**\n * @notice It gets the current \"OverCollateralizedBuffer\" setting's value\n * @return value_ the current value.\n */\n function getOverCollateralizedBufferValue()\n internal\n view\n returns (uint256 value_)\n {\n value_ = s(NAMES.OVER_COLLATERALIZED_BUFFER).value;\n }\n}\n" + }, + "contracts/shared/libraries/CacheLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nenum CacheType { Address, Uint, Int, Byte, Bool }\n\n/**\n * @notice This struct manages the cache of the library instance.\n * @param addresses A mapping of address values mapped to cache keys in bytes.\n * @param uints A mapping of uint values mapped to cache keys names in bytes.\n * @param ints A mapping of int values mapped to cache keys names in bytes.\n * @param bites A mapping of bytes values mapped to cache keys names in bytes.\n * @param bools A mapping of bool values mapped to cache keys names in bytes.\n */\nstruct Cache {\n // Mapping of cache keys names to address values.\n mapping(bytes32 => address) addresses;\n // Mapping of cache keys names to uint256 values.\n mapping(bytes32 => uint256) uints;\n // Mapping of cache keys names to int256 values.\n mapping(bytes32 => int256) ints;\n // Mapping of cache keys names to bytes32 values.\n mapping(bytes32 => bytes32) bites;\n // Mapping of cache keys names to bool values.\n mapping(bytes32 => bool) bools;\n}\n\nlibrary CacheLib {\n // The constant for the initialization check\n bytes32 private constant INITIALIZED = keccak256(\"Initialized\");\n\n /**\n * @notice Initializes the cache instance.\n * @param cache The current cache\n */\n function initialize(Cache storage cache) internal {\n requireNotExists(cache);\n cache.bools[INITIALIZED] = true;\n }\n\n /**\n * @notice Checks whether the current cache does not, throwing an error if it does.\n * @param cache The current cache\n */\n function requireNotExists(Cache storage cache) internal view {\n require(!exists(cache), \"CACHE_ALREADY_EXISTS\");\n }\n\n /**\n * @notice Checks whether the current cache exists, throwing an error if the cache does not.\n * @param cache The current cache\n */\n function requireExists(Cache storage cache) internal view {\n require(exists(cache), \"CACHE_DOES_NOT_EXIST\");\n }\n\n /**\n * @notice Tests whether the current cache exists or not.\n * @param cache The current cache.\n * @return bool True if the cache exists.\n */\n function exists(Cache storage cache) internal view returns (bool) {\n return cache.bools[INITIALIZED];\n }\n\n /**\n * @notice it updates the cache with a key, value and cache type\n * @param cache cache to update\n * @param key the memory reference to the value in bytes32\n * @param value the value to update at the key\n * @param cacheType the enum type of cache to update\n */\n function update(\n Cache storage cache,\n bytes32 key,\n bytes32 value,\n CacheType cacheType\n ) internal {\n requireExists(cache);\n\n assembly {\n mstore(0, value)\n }\n if (cacheType == CacheType.Address) {\n address addr;\n assembly {\n addr := mload(0)\n }\n cache.addresses[key] = addr;\n } else if (cacheType == CacheType.Uint) {\n uint256 ui;\n assembly {\n ui := mload(0)\n }\n cache.uints[key] = ui;\n } else if (cacheType == CacheType.Int) {\n int256 i;\n assembly {\n i := mload(0)\n }\n cache.ints[key] = i;\n } else if (cacheType == CacheType.Byte) {\n cache.bites[key] = value;\n } else if (cacheType == CacheType.Bool) {\n bool b;\n assembly {\n b := mload(0)\n }\n cache.bools[key] = b;\n }\n }\n\n /**\n * @notice it deletes the cache values at the specified key\n * @param cache the cache to delete keys from\n * @param keysToClear the keys to delete\n * @param keyTypes the types of keys to target different parts of the cache\n */\n function clearCache(\n Cache storage cache,\n bytes32[5] memory keysToClear,\n CacheType[5] memory keyTypes\n ) internal {\n requireExists(cache);\n require(\n keysToClear.length == keyTypes.length,\n \"ARRAY_LENGTHS_MISMATCH\"\n );\n for (uint256 i; i <= keysToClear.length; i++) {\n if (keyTypes[i] == CacheType.Address) {\n delete cache.addresses[keysToClear[i]];\n } else if (keyTypes[i] == CacheType.Uint) {\n delete cache.uints[keysToClear[i]];\n } else if (keyTypes[i] == CacheType.Int) {\n delete cache.ints[keysToClear[i]];\n } else if (keyTypes[i] == CacheType.Byte) {\n delete cache.bites[keysToClear[i]];\n } else if (keyTypes[i] == CacheType.Bool) {\n delete cache.bools[keysToClear[i]];\n }\n }\n }\n}\n" + }, + "contracts/settings/platform/names.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/**\n @dev The setting name for loans taken out with an NFT.\n @dev This is the interest rate value that will be applied to loans taken out with an NFT.\n */\nbytes32 constant NFT_INTEREST_RATE = keccak256(\"NFTInterestRate\");\n\n/**\n @dev The setting name for the required subsmission settings.\n @dev This is the minimum percentage of node responses that will be required by the platform to either take out a loan, and to claim accrued interest. If the number of node responses are less than the ones specified here, the loan or accrued interest claim request will be rejected by the platform\n */\nbytes32 constant REQUIRED_SUBMISSIONS_PERCENTAGE = keccak256(\n \"RequiredSubmissionsPercentage\"\n);\n\n/**\n @dev The setting name for the maximum tolerance settings.\n @dev This is the maximum tolerance for the values submitted (by nodes) when they are aggregated (average). It is used in the consensus mechanisms.\n @dev This is a percentage value with 2 decimal places.\n i.e. maximumTolerance of 325 => tolerance of 3.25% => 0.0325 of value\n i.e. maximumTolerance of 0 => It means all the values submitted must be equals.\n @dev The max value is 100% => 10000\n */\nbytes32 constant MAXIMUM_TOLERANCE = keccak256(\"MaximumTolerance\");\n/**\n @dev The setting name for the response expiry length settings.\n @dev This is the maximum time (in seconds) a node has to submit a response. After that time, the response is considered expired and will not be accepted by the protocol.\n */\n\nbytes32 constant RESPONSE_EXPIRY_LENGTH = keccak256(\"ResponseExpiryLength\");\n\n/**\n @dev The setting name for the safety interval settings.\n @dev This is the minimum time you need to wait (in seconds) between the last time you deposit collateral and you take out the loan.\n @dev It is used to avoid potential attacks using Flash Loans (AAVE) or Flash Swaps (Uniswap V2).\n */\nbytes32 constant SAFETY_INTERVAL = keccak256(\"SafetyInterval\");\n\n/**\n @dev The setting name for the term expiry time settings.\n @dev This represents the time (in seconds) that loan terms will be available after requesting them.\n @dev After this time, the loan terms will expire and the borrower will need to request it again.\n */\nbytes32 constant TERMS_EXPIRY_TIME = keccak256(\"TermsExpiryTime\");\n\n/**\n @dev The setting name for the liquidation reward percent setting.\n @dev It represents the percentage value (with 2 decimal places) for the MAX liquidation reward.\n i.e. an ETH liquidation price at 5% is stored as 500\n */\nbytes32 constant LIQUIDATE_REWARD_PERCENT = keccak256(\"LiquidateRewardPercent\");\n\n/**\n @dev The setting name for the maximum loan duration settings.\n @dev The maximum loan duration setting is defined in seconds. Loans will not be given for timespans larger than the one specified here.\n */\nbytes32 constant MAXIMUM_LOAN_DURATION = keccak256(\"MaximumLoanDuration\");\n\n/**\n @dev The setting name for the request loan terms rate limit settings.\n @dev The request loan terms rate limit setting is defined in seconds.\n */\nbytes32 constant REQUEST_LOAN_TERMS_RATE_LIMIT = keccak256(\n \"RequestLoanTermsRateLimit\"\n);\n\n/**\n @dev The setting name for the collateral buffer.\n @dev The collateral buffer is a safety buffer above the required collateral amount to liquidate a loan. It is required to ensure the loan does not get liquidated immediately after the loan is taken out if the value of the collateral asset deposited drops drastically.\n @dev It represents the percentage value (with 2 decimal places) of a collateral buffer.\n e.g.: collateral buffer at 100% is stored as 10000.\n */\nbytes32 constant COLLATERAL_BUFFER = keccak256(\"CollateralBuffer\");\n\n/**\n @dev The setting name for the over collateralized buffer.\n @dev The over collateralized buffer is the minimum required collateral ratio in order for a loan to be taken out without an Escrow contract and for the funds to go to the borrower's EOA (external overridely owned account).\n @dev It represents the percentage value (with 2 decimal places) of a over collateralized buffer.\n e.g.: over collateralized buffer at 130% is stored as 13000.\n */\nbytes32 constant OVER_COLLATERALIZED_BUFFER = keccak256(\n \"OverCollateralizedBuffer\"\n);\n" + }, + "contracts/shared/interfaces/ITellerDiamond.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { IDiamondCut } from \"./IDiamondCut.sol\";\nimport { IDiamondLoupe } from \"./IDiamondLoupe.sol\";\n\nimport { SettingsFacet } from \"../../settings/SettingsFacet.sol\";\nimport {\n PlatformSettingsFacet\n} from \"../../settings/platform/PlatformSettingsFacet.sol\";\nimport {\n AssetSettingsDataFacet\n} from \"../../settings/asset/AssetSettingsDataFacet.sol\";\nimport {\n AssetSettingsFacet\n} from \"../../settings/asset/AssetSettingsFacet.sol\";\nimport { PausableFacet } from \"../../settings/pausable/PausableFacet.sol\";\nimport { PriceAggFacet } from \"../../price-aggregator/PriceAggFacet.sol\";\nimport {\n ChainlinkAggFacet\n} from \"../../price-aggregator/chainlink/ChainlinkAggFacet.sol\";\nimport { LendingFacet } from \"../../lending/LendingFacet.sol\";\nimport { CreateLoanFacet } from \"../../market/CreateLoanFacet.sol\";\nimport { LoanDataFacet } from \"../../market/LoanDataFacet.sol\";\nimport { RepayFacet } from \"../../market/RepayFacet.sol\";\nimport { SignersFacet } from \"../../market/SignersFacet.sol\";\nimport { NFTFacet } from \"../../nft/NFTFacet.sol\";\nimport { CollateralFacet } from \"../../market/CollateralFacet.sol\";\nimport { CompoundFacet } from \"../../escrow/dapps/CompoundFacet.sol\";\nimport { UniswapFacet } from \"../../escrow/dapps/UniswapFacet.sol\";\nimport { AaveFacet } from \"../../escrow/dapps/AaveFacet.sol\";\nimport { SushiswapFacet } from \"../../escrow/dapps/SushiswapFacet.sol\";\nimport { PoolTogetherFacet } from \"../../escrow/dapps/PoolTogetherFacet.sol\";\n\nabstract contract ITellerDiamond is\n SettingsFacet,\n PlatformSettingsFacet,\n AssetSettingsDataFacet,\n AssetSettingsFacet,\n PausableFacet,\n PriceAggFacet,\n ChainlinkAggFacet,\n LendingFacet,\n CollateralFacet,\n CreateLoanFacet,\n LoanDataFacet,\n RepayFacet,\n SignersFacet,\n NFTFacet,\n CompoundFacet,\n UniswapFacet,\n AaveFacet,\n SushiswapFacet,\n PoolTogetherFacet,\n IDiamondCut,\n IDiamondLoupe\n{}\n" + }, + "contracts/shared/interfaces/IDiamondCut.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/******************************************************************************\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\n/******************************************************************************/\n\ninterface IDiamondCut {\n enum FacetCutAction { Add, Replace, Remove }\n\n struct FacetCut {\n address facetAddress;\n FacetCutAction action;\n bytes4[] functionSelectors;\n }\n\n /// @notice Add/replace/remove any number of functions and optionally execute\n /// a function with delegatecall\n /// @param _diamondCut Contains the facet addresses and function selectors\n /// @param _init The address of the contract or facet to execute _calldata\n /// @param _calldata A function call, including function selector and arguments\n /// _calldata is executed with delegatecall on _init\n function diamondCut(\n FacetCut[] calldata _diamondCut,\n address _init,\n bytes calldata _calldata\n ) external;\n\n event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\n}\n" + }, + "contracts/shared/interfaces/IDiamondLoupe.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// A loupe is a small magnifying glass used to look at diamonds.\n// These functions look at diamonds\ninterface IDiamondLoupe {\n /// These functions are expected to be called frequently\n /// by tools.\n\n struct Facet {\n address facetAddress;\n bytes4[] functionSelectors;\n }\n\n /// @notice Gets all facet addresses and their four byte function selectors.\n /// @return facets_ Facet\n function facets() external view returns (Facet[] memory facets_);\n\n /// @notice Gets all the function selectors supported by a specific facet.\n /// @param _facet The facet address.\n /// @return facetFunctionSelectors_\n function facetFunctionSelectors(address _facet)\n external\n view\n returns (bytes4[] memory facetFunctionSelectors_);\n\n /// @notice Get all the facet addresses used by a diamond.\n /// @return facetAddresses_\n function facetAddresses()\n external\n view\n returns (address[] memory facetAddresses_);\n\n /// @notice Gets the facet that supports the given selector.\n /// @dev If facet is not found return address(0).\n /// @param _functionSelector The function selector.\n /// @return facetAddress_ The facet address.\n function facetAddress(bytes4 _functionSelector)\n external\n view\n returns (address facetAddress_);\n}\n" + }, + "contracts/settings/platform/PlatformSettingsFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN, AUTHORIZED } from \"../../shared/roles.sol\";\n\n// Libraries\nimport {\n PlatformSettingsLib,\n PlatformSetting\n} from \"./libraries/PlatformSettingsLib.sol\";\nimport { AppStorageLib } from \"../../storage/app.sol\";\n\n// Storage\nimport { AppStorageLib, AppStorage } from \"../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions on the PlatformSetting struct.\n *\n * @author develop@teller.finance\n */\ncontract PlatformSettingsFacet is RolesMods {\n /**\n * @notice This event is emitted when a new platform setting is created.\n * @param settingName New setting name.\n * @param sender Address that created it.\n * @param value Value for the new setting.\n * @param minValue Minimum boundary for the new setting.\n * @param maxValue Maximum boundary for the new setting.\n */\n event PlatformSettingCreated(\n bytes32 indexed settingName,\n address indexed sender,\n uint256 value,\n uint256 minValue,\n uint256 maxValue\n );\n\n /**\n * @notice This event is emitted when a platform setting is updated.\n * @param settingName Keccak'ed settings name.\n * @param sender Address that updated it.\n * @param oldValue Previous value for the setting.\n * @param newValue New value for the setting.\n */\n event PlatformSettingUpdated(\n bytes32 indexed settingName,\n address indexed sender,\n uint256 oldValue,\n uint256 newValue\n );\n\n /**\n * @notice This event is emitted when a current platform setting is removed.\n * @param settingName setting name removed.\n * @param sender address that removed it.\n * @param oldMin Previous minimum boundary.\n * @param oldMax Previous minimum boundary.\n * @param newMin New minimum boundary.\n * @param newMax New maximum boundary.\n */\n event PlatformSettingBoundariesUpdated(\n bytes32 indexed settingName,\n address indexed sender,\n uint256 oldMin,\n uint256 oldMax,\n uint256 newMin,\n uint256 newMax\n );\n\n /**\n * @notice Gets the values for a platform setting name.\n * @param name The keccak'ed name for a setting.\n * @return setting_ Values for the setting {name}\n */\n function getPlatformSetting(bytes32 name)\n external\n view\n returns (PlatformSetting memory setting_)\n {\n setting_ = PlatformSettingsLib.s(name);\n }\n\n /**\n * @notice It creates a new platform setting given a name, min and max values.\n * @param name Keccak'ed name for the setting.\n * @param value Initial value for the setting.\n * @param min Minimum value allowed for the setting.\n * @param max Maximum value allowed for the setting.\n */\n function createPlatformSetting(\n bytes32 name,\n uint256 value,\n uint256 min,\n uint256 max\n ) external authorized(ADMIN, msg.sender) {\n require(\n !PlatformSettingsLib.s(name).exists,\n \"Teller: platform setting already exists\"\n );\n require(value >= min, \"Teller: platform setting value less than min\");\n require(\n value <= max,\n \"Teller: platform setting value greater than max\"\n );\n\n PlatformSettingsLib.s(name).value = value;\n PlatformSettingsLib.s(name).min = min;\n PlatformSettingsLib.s(name).max = max;\n PlatformSettingsLib.s(name).exists = true;\n\n emit PlatformSettingCreated(name, msg.sender, value, min, max);\n }\n\n /**\n * @notice It updates a current platform setting.\n * @param name Keccak'ed name for the setting.\n * @param newValue the new value to set in the platform setting.\n *\n * Requirements:\n * - New value is equal to the current value.\n * - New value is grater than the max value.\n * - New value is less than the min value\n */\n function updatePlatformSetting(bytes32 name, uint256 newValue)\n external\n authorized(ADMIN, msg.sender)\n returns (uint256 oldValue)\n {\n require(\n PlatformSettingsLib.s(name).exists,\n \"Teller: platform setting not exists\"\n );\n require(\n PlatformSettingsLib.s(name).value != newValue,\n \"Teller: new platform setting not different\"\n );\n require(\n newValue >= PlatformSettingsLib.s(name).min,\n \"Teller: new platform setting less than min\"\n );\n require(\n newValue <= PlatformSettingsLib.s(name).max,\n \"Teller: new platform setting greater than max\"\n );\n\n oldValue = PlatformSettingsLib.s(name).value;\n PlatformSettingsLib.s(name).value = newValue;\n\n emit PlatformSettingUpdated(name, msg.sender, oldValue, newValue);\n }\n\n /**\n * @notice Updates the boundary (min & max) values for a platform setting.\n * @param name Keccak'ed name for the setting.\n * @param min New minimum boundary for the setting.\n * @param max New maximum boundary for the setting.\n */\n function updatePlatformSettingBoundaries(\n bytes32 name,\n uint256 min,\n uint256 max\n ) external authorized(ADMIN, msg.sender) {\n require(\n PlatformSettingsLib.s(name).exists,\n \"Teller: platform setting not exists\"\n );\n\n emit PlatformSettingBoundariesUpdated(\n name,\n msg.sender,\n PlatformSettingsLib.s(name).min,\n PlatformSettingsLib.s(name).max,\n min,\n max\n );\n\n PlatformSettingsLib.s(name).min = min;\n PlatformSettingsLib.s(name).max = max;\n }\n}\n" + }, + "contracts/settings/asset/AssetSettingsDataFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN, AUTHORIZED } from \"../../shared/roles.sol\";\n\n// Interfaces\nimport { ICErc20 } from \"../../shared/interfaces/ICErc20.sol\";\nimport { IAToken } from \"../../shared/interfaces/IAToken.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../shared/libraries/CacheLib.sol\";\nimport { AssetCTokenLib } from \"./libraries/AssetCTokenLib.sol\";\nimport { AssetATokenLib } from \"./libraries/AssetATokenLib.sol\";\nimport { AssetPPoolLib } from \"./libraries/AssetPPoolLib.sol\";\nimport {\n PoolTogetherLib\n} from \"../../escrow/dapps/libraries/PoolTogetherLib.sol\";\nimport { MaxLoanAmountLib } from \"./libraries/MaxLoanAmountLib.sol\";\nimport { MaxTVLLib } from \"./libraries/MaxTVLLib.sol\";\n\n// Storage\nimport { AppStorageLib, AppStorage } from \"../../storage/app.sol\";\nimport {\n PrizePoolInterface\n} from \"../../escrow/dapps/interfaces/PrizePoolInterface.sol\";\n\n/**\n * @notice View function to get asset setting values.\n *\n * @author develop@teller.finance\n */\ncontract AssetSettingsDataFacet {\n /**\n * @notice it gets the asset's max loan amount\n * @param asset the address of the asset\n * @return the max loan amount\n */\n function getAssetMaxLoanAmount(address asset)\n external\n view\n returns (uint256)\n {\n return MaxLoanAmountLib.get(asset);\n }\n\n /**\n * @notice it gets the maxTVL of an asset\n * @param asset the address of the asset\n * @return it returns the maxTVL\n */\n function getAssetMaxTVL(address asset) external view returns (uint256) {\n return MaxTVLLib.get(asset);\n }\n\n /**\n * @notice it returns the asset's cToken\n * @param asset the address of the asset\n * @return the cToken of an asset\n */\n function getAssetCToken(address asset) external view returns (ICErc20) {\n return AssetCTokenLib.get(asset);\n }\n\n function getAssetAToken(address asset) external view returns (IAToken) {\n return AssetATokenLib.get(asset);\n }\n\n function getAssetPPool(address asset)\n external\n view\n returns (PrizePoolInterface)\n {\n return AssetPPoolLib.get(asset);\n }\n\n function getAssetPPoolTicket(address asset) external view returns (IERC20) {\n return IERC20(PoolTogetherLib.getTicketAddress(asset));\n }\n}\n" + }, + "contracts/settings/asset/AssetSettingsFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN, AUTHORIZED } from \"../../shared/roles.sol\";\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../shared/libraries/CacheLib.sol\";\nimport { MaxTVLLib } from \"./libraries/MaxTVLLib.sol\";\n\n// Storage\nimport { AppStorageLib, AppStorage } from \"../../storage/app.sol\";\n\nstruct AssetSettingRequest {\n bytes32 key;\n bytes32 value;\n CacheType cacheType;\n}\n\ncontract AssetSettingsFacet is RolesMods {\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n event AssetSettingsCreated(\n address indexed asset,\n bytes32 indexed key,\n bytes32 value,\n CacheType cacheType\n );\n\n event AssetSettingsUpdated(\n address indexed asset,\n bytes32 indexed key,\n bytes32 value,\n CacheType cacheType\n );\n\n /**\n * @notice it checks if the settings of an asset is initialized\n * @param asset the address of the asset\n * @return bool to check if settings of an asset exists\n */\n function isAssetSettingInitialized(address asset)\n external\n view\n returns (bool)\n {\n return CacheLib.exists(s(asset));\n }\n\n /**\n * @notice it gets the MaxTVL amount of an asset\n * @param asset the address of the asset\n * @return the max TVL amount\n */\n function getMaxTVLAmount(address asset) external view returns (uint256) {\n return MaxTVLLib.get(asset);\n }\n\n /**\n * @notice It creates an asset settings with the given parameters.\n * @param asset the address to create settings for\n * @param requests the multiple settings to update the asset with \n */\n function createAssetSetting(\n address asset,\n AssetSettingRequest[] calldata requests\n ) external authorized(ADMIN, msg.sender) {\n require(asset != address(0), \"Teller: asset address required\");\n\n CacheLib.initialize(s(asset));\n\n for (uint256 i; i < requests.length; i++) {\n CacheLib.update(\n s(asset),\n requests[i].key,\n requests[i].value,\n requests[i].cacheType\n );\n\n emit AssetSettingsCreated(\n asset,\n requests[i].key,\n requests[i].value,\n requests[i].cacheType\n );\n }\n }\n\n /**\n * @notice It updates an asset with the given parameter\n * @param asset the address of the asset to update\n * @param request the setting to update the asset with\n */\n function updateAssetSetting(\n address asset,\n AssetSettingRequest calldata request\n ) external authorized(ADMIN, msg.sender) {\n require(\n CacheLib.exists(s(asset)),\n \"Teller: asset setting does not exists\"\n );\n\n CacheLib.update(\n s(asset),\n request.key,\n request.value,\n request.cacheType\n );\n\n emit AssetSettingsUpdated(\n asset,\n request.key,\n request.value,\n request.cacheType\n );\n }\n}\n" + }, + "contracts/settings/pausable/PausableFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../../contexts2/access-control/roles/RolesMods.sol\";\nimport { PAUSER } from \"../../shared/roles.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../storage/app.sol\";\n\ncontract PausableFacet is RolesMods {\n /**\n * @dev Emitted when an {id} is paused by {sender}.\n */\n event Paused(bytes32 indexed id, address sender);\n\n /**\n * @dev Emitted when an {id} is unpaused by {sender}.\n */\n event UnPaused(bytes32 indexed id, address sender);\n\n /**\n * @notice Puts an id in the given state.\n * @dev A blank id (\"\") is equivalent to the whole protocol. If a specific facet should be paused, pass its encoded id.\n * @param id Encoded id of a facet to {pause}.\n * @param state The new state that {id} should be in.\n *\n * Requirements:\n * - Sender must have the PAUSER role.\n */\n function pause(bytes32 id, bool state)\n external\n authorized(PAUSER, msg.sender)\n {\n if (isPaused(id) == state) return;\n AppStorageLib.store().paused[id] = state;\n if (state) {\n emit Paused(id, msg.sender);\n } else {\n emit UnPaused(id, msg.sender);\n }\n }\n\n /**\n * @notice Checks if an id is paused.\n * @dev A blank id (\"\") is equivalent to the whole protocol. If a specific facet should be paused, pass its encoded id.\n * @param id Encoded id of a facet to {pause}.\n * @return The state that {id} is in.\n */\n function isPaused(bytes32 id) public view returns (bool) {\n return AppStorageLib.store().paused[id];\n }\n}\n" + }, + "contracts/price-aggregator/PriceAggFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport { SafeCast } from \"@openzeppelin/contracts/utils/math/SafeCast.sol\";\nimport { ChainlinkLib } from \"./chainlink/ChainlinkLib.sol\";\nimport { CompoundLib } from \"../shared/libraries/CompoundLib.sol\";\n\n// Interfaces\nimport {\n AggregatorV2V3Interface\n} from \"@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol\";\nimport { ERC20 } from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../storage/app.sol\";\n\ncontract PriceAggFacet {\n uint256 internal constant TEN = 10;\n\n /**\n * @notice It returns the price of the token pair as given from the Chainlink Aggregator.\n * @dev It tries to use ETH as a pass through asset if the direct pair is not supported.\n * @param src Source token address.\n * @param dst Destination token address.\n * @return int256 The latest answer as given from Chainlink.\n */\n function getPriceFor(address src, address dst)\n external\n view\n returns (int256)\n {\n return _priceFor(src, dst);\n }\n\n /**\n * @notice It calculates the value of a token amount into another.\n * @param src Source token address.\n * @param dst Destination token address.\n * @param srcAmount Amount of the source token to convert into the destination token.\n * @return uint256 Value of the source token amount in destination tokens.\n */\n function getValueFor(\n address src,\n address dst,\n uint256 srcAmount\n ) external view returns (uint256) {\n return _valueFor(src, srcAmount, uint256(_priceFor(src, dst)));\n }\n\n /**\n * @notice It calculates the value of a token amount into another.\n * @param src Source token address.\n * @param amount Amount of the source token to convert into the destination token.\n * @param exchangeRate The calculated exchange rate between the tokens.\n * @return uint256 Value of the source token amount given an exchange rate peg.\n */\n function _valueFor(\n address src,\n uint256 amount,\n uint256 exchangeRate\n ) internal view returns (uint256) {\n return (amount * exchangeRate) / _oneToken(src);\n }\n\n /**\n * @notice it returns 10^{numberOfDecimals} for a token\n * @param token the address to calculate the decimals for\n * @return 10^number of decimals used to calculate the price and value of different token pairs\n */\n function _oneToken(address token) internal view returns (uint256) {\n return TEN**_decimalsFor(token);\n }\n\n /**\n * @notice It gets the number of decimals for a given token.\n * @param addr Token address to get decimals for.\n * @return uint8 Number of decimals the given token.\n */\n function _decimalsFor(address addr) internal view returns (uint8) {\n return ERC20(addr).decimals();\n }\n\n /**\n * @notice it tries to calculate a price from Compound and Chainlink.\n * @dev if no price is found on compound, then calculate it on chainlink\n * @param src the token address to calculate the price for in dst\n * @param dst the token address to retrieve the price of src\n * @return price_ the price of src in dst\n */\n function _priceFor(address src, address dst)\n private\n view\n returns (int256 price_)\n {\n // If no Compound route, try Chainlink directly.\n price_ = int256(_compoundPriceFor(src, dst));\n if (price_ == 0) {\n price_ = _chainlinkPriceFor(src, dst);\n if (price_ == 0) {\n revert(\"Teller: cannot calc price\");\n }\n }\n }\n\n /**\n * @notice Tries to get a price from {src} to {dst} by checking if either tokens are from Compound.\n * @param src the address of the src token\n * @param dst the address of the dst token\n * @return the price of the src token in dst token\n\n */\n function _compoundPriceFor(address src, address dst)\n private\n view\n returns (uint256)\n {\n (bool isSrcCompound, address srcUnderlying) = _isCToken(src);\n if (isSrcCompound) {\n uint256 cRate = CompoundLib.valueInUnderlying(src, _oneToken(src));\n if (srcUnderlying == dst) {\n return cRate;\n } else {\n return _calcPriceFromCompoundRate(srcUnderlying, dst, cRate);\n }\n } else {\n (bool isDstCompound, address dstUnderlying) = _isCToken(dst);\n if (isDstCompound) {\n uint256 cRate =\n CompoundLib.valueOfUnderlying(dst, _oneToken(src));\n if (dstUnderlying == src) {\n return cRate;\n } else {\n return\n _calcPriceFromCompoundRate(src, dstUnderlying, cRate);\n }\n }\n }\n\n return 0;\n }\n\n /**\n * @notice Tries to get a price from {src} to {dst} and then converts using a rate from Compound.\n * @param src the source token to calculate price for with chainlink\n * @param dst the destination token to calculate price for with chainlink\n * @param cRate the compound rate to multiply with the price of the dst token\n * @return the price of src in dst after scaling the difference in decimal values\n */\n function _calcPriceFromCompoundRate(\n address src,\n address dst,\n uint256 cRate\n ) private view returns (uint256) {\n uint256 rate = uint256(_chainlinkPriceFor(src, dst));\n uint256 value = (cRate * _oneToken(dst)) / rate;\n return _scale(value, _decimalsFor(src), _decimalsFor(dst));\n }\n\n /**\n * @notice Scales the {value} by the difference in decimal values.\n * @param value the the value of the src in dst\n * @param srcDecimals src token decimals\n * @param dstDecimals dst token decimals\n * @return the price of src in dst after scaling the difference in decimal values\n */\n function _scale(\n uint256 value,\n uint256 srcDecimals,\n uint256 dstDecimals\n ) internal pure returns (uint256) {\n if (dstDecimals > srcDecimals) {\n return value * (TEN**(dstDecimals - srcDecimals));\n } else {\n return value / (TEN**(srcDecimals - dstDecimals));\n }\n }\n\n /**\n * @notice it tries to calculate the price of {src} in {dst}\n * @param src address of source token\n * @param dst address of destination token\n * @return the price of src token in dst\n */\n function _chainlinkPriceFor(address src, address dst)\n private\n view\n returns (int256)\n {\n (address agg, bool foundAgg, bool inverse) =\n ChainlinkLib.aggregatorFor(src, dst);\n if (foundAgg) {\n uint256 price =\n SafeCast.toUint256(AggregatorV2V3Interface(agg).latestAnswer());\n uint8 resDecimals = AggregatorV2V3Interface(agg).decimals();\n if (inverse) {\n price = (TEN**(resDecimals + resDecimals)) / price;\n }\n return\n SafeCast.toInt256(\n (_scale(price, resDecimals, _decimalsFor(dst)))\n );\n } else {\n address wrappedNativeToken =\n AppStorageLib.store().wrappedNativeToken;\n if (dst != wrappedNativeToken) {\n int256 price1 = _priceFor(src, wrappedNativeToken);\n if (price1 > 0) {\n int256 price2 = _priceFor(dst, wrappedNativeToken);\n if (price2 > 0) {\n uint256 dstFactor = TEN**_decimalsFor(dst);\n return (price1 * int256(dstFactor)) / price2;\n }\n }\n }\n }\n\n return 0;\n }\n\n /**\n * @notice it checks if a token is a cToken. If it is, then get the underlying address\n * @param token address of the token\n * @return isCToken boolean whether it's a cToken\n * @return underlying the address of the cToken\n */\n function _isCToken(address token)\n private\n view\n returns (bool isCToken, address underlying)\n {\n isCToken = CompoundLib.isCompoundToken(token);\n if (isCToken) {\n underlying = CompoundLib.getUnderlying(token);\n }\n }\n}\n" + }, + "contracts/price-aggregator/chainlink/ChainlinkAggFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN } from \"../../shared/roles.sol\";\n\n// Libraries\nimport { Address } from \"@openzeppelin/contracts/utils/Address.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\nimport { ChainlinkLib } from \"./ChainlinkLib.sol\";\n\n// Storage\nimport {\n PriceAggStorageLib,\n PriceAggStorage\n} from \"../../storage/price-aggregator.sol\";\n\ncontract ChainlinkAggFacet is RolesMods {\n /**\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\n * @param src Source token address.\n * @param dst Destination token address.\n * @return agg The Chainlink Aggregator address.\n * @return found whether or not the ChainlinkAggregator exists.\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\n */\n function getChainlinkAggregatorFor(address src, address dst)\n external\n view\n returns (\n address agg,\n bool found,\n bool inverse\n )\n {\n (agg, found, inverse) = ChainlinkLib.aggregatorFor(src, dst);\n }\n\n /**\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\n * @param token Token address to check if is supported.\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\n */\n function isChainlinkTokenSupported(address token)\n external\n view\n returns (bool)\n {\n return ChainlinkLib.isTokenSupported(token);\n }\n\n /**\n * @notice It allows for additional Chainlink Aggregators to be supported.\n * @param src Source token address.\n * @param dst Destination token address.\n * @param aggregator Price aggregator address.\n */\n function addChainlinkAggregator(\n address src,\n address dst,\n address aggregator\n ) external authorized(ADMIN, msg.sender) {\n (, bool found, ) = ChainlinkLib.aggregatorFor(src, dst);\n require(!found, \"Teller: chainlink aggregator already exists\");\n require(Address.isContract(src), \"Teller: source token not contract\");\n require(\n Address.isContract(dst),\n \"Teller: destination token not contract\"\n );\n require(\n Address.isContract(aggregator),\n \"Teller: chainlink aggregator not contract\"\n );\n\n // Store now aggregator\n ChainlinkLib.s().aggregators[src][dst] = aggregator;\n // Make sure token addresses are known to be supported\n EnumerableSet.add(ChainlinkLib.s().supportedTokens, src);\n EnumerableSet.add(ChainlinkLib.s().supportedTokens, dst);\n // Increment token pair counts\n ChainlinkLib.s().pairCount[src]++;\n ChainlinkLib.s().pairCount[dst]++;\n }\n\n /**\n * @notice It removes support for a Chainlink Aggregator pair.\n * @param src Source token address.\n * @param dst Destination token address.\n */\n function removeChainlinkAggregator(address src, address dst)\n external\n authorized(ADMIN, msg.sender)\n {\n (, bool found, ) = ChainlinkLib.aggregatorFor(src, dst);\n if (!found) {\n return;\n }\n\n // Delete aggregator storage\n delete ChainlinkLib.s().aggregators[src][dst];\n // Decrement token pair counts\n ChainlinkLib.s().pairCount[src]--;\n ChainlinkLib.s().pairCount[dst]--;\n // Remove token support if token pair length is 0\n if (ChainlinkLib.s().pairCount[src] == 0) {\n EnumerableSet.remove(ChainlinkLib.s().supportedTokens, src);\n }\n if (ChainlinkLib.s().pairCount[dst] == 0) {\n EnumerableSet.remove(ChainlinkLib.s().supportedTokens, dst);\n }\n }\n}\n" + }, + "contracts/lending/LendingFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { PausableMods } from \"../settings/pausable/PausableMods.sol\";\nimport {\n ReentryMods\n} from \"../contexts2/access-control/reentry/ReentryMods.sol\";\nimport { RolesMods } from \"../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN, AUTHORIZED } from \"../shared/roles.sol\";\n\n// Interfaces\nimport { ITToken } from \"./ttoken/ITToken.sol\";\n\n// Libraries\nimport {\n IERC20,\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport {\n SafeERC20Upgradeable\n} from \"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\";\nimport { MaxTVLLib } from \"../settings/asset/libraries/MaxTVLLib.sol\";\nimport { LendingLib } from \"./libraries/LendingLib.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../storage/app.sol\";\n\ncontract LendingFacet is RolesMods, ReentryMods, PausableMods {\n /**\n * @notice This event is emitted when a new lending pool is initialized.\n * @param sender address.\n * @param asset Token address the pool was initialized for.\n */\n event LendingPoolInitialized(address indexed sender, address asset);\n\n /**\n * @notice Get the Teller Token address for an underlying asset.\n * @param asset Address to get a Teller Token for.\n */\n function getTTokenFor(address asset)\n external\n view\n returns (address tToken_)\n {\n tToken_ = address(LendingLib.tToken(asset));\n }\n\n /**\n * @notice It allows users to deposit tokens into the pool.\n * @dev the user must call ERC20.approve function previously.\n * @dev If the cToken is available (not 0x0), it deposits the lending asset amount into Compound directly.\n * @param asset Token address to deposit into the lending pool.\n * @param amount Amount of {asset} to deposit in the pool.\n */\n function lendingPoolDeposit(address asset, uint256 amount)\n external\n paused(LendingLib.ID, false)\n authorized(AUTHORIZED, msg.sender)\n nonReentry(LendingLib.ID)\n {\n ITToken tToken = LendingLib.tToken(asset);\n require(\n address(tToken) != address(0),\n \"Teller: lending pool not initialized\"\n );\n\n require(\n tToken.currentTVL() + amount <= MaxTVLLib.get(asset),\n \"Teller: deposit TVL exceeded\"\n );\n\n // Transfer tokens from lender\n SafeERC20.safeTransferFrom(\n IERC20(asset),\n msg.sender,\n address(this),\n amount\n );\n // Set allowance for Teller token to pull funds to mint\n SafeERC20.safeIncreaseAllowance(IERC20(asset), address(tToken), amount);\n // Mint Teller tokens, then transfer to lender\n SafeERC20Upgradeable.safeTransfer(\n tToken,\n msg.sender,\n // Minting returns the amount of Teller tokens minted\n tToken.mint(amount)\n );\n }\n\n /**\n * @notice It initializes a new lending pool for the respective token\n * @param asset Token address to initialize the lending pool for.\n */\n function initLendingPool(address asset)\n external\n authorized(ADMIN, msg.sender)\n {\n require(\n address(LendingLib.tToken(asset)) == address(0),\n \"Teller: lending pool already initialized\"\n );\n\n // Create a new Teller Token\n address tToken = AppStorageLib.store().tTokenBeacon.cloneProxy(\"\");\n // Set the Teller Token to the asset mapping\n LendingLib.s().tTokens[asset] = ITToken(tToken);\n // Initialize the Teller Token\n LendingLib.s().tTokens[asset].initialize(msg.sender, asset);\n\n // Emit event\n emit LendingPoolInitialized(msg.sender, asset);\n }\n}\n" + }, + "contracts/market/CreateLoanFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { PausableMods } from \"../settings/pausable/PausableMods.sol\";\nimport {\n ReentryMods\n} from \"../contexts2/access-control/reentry/ReentryMods.sol\";\nimport { RolesMods } from \"../contexts2/access-control/roles/RolesMods.sol\";\nimport { AUTHORIZED } from \"../shared/roles.sol\";\nimport { ERC20 } from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\n\n// Libraries\nimport { LibLoans } from \"./libraries/LibLoans.sol\";\nimport { LibEscrow } from \"../escrow/libraries/LibEscrow.sol\";\nimport { LibCollateral } from \"./libraries/LibCollateral.sol\";\nimport { LibConsensus } from \"./libraries/LibConsensus.sol\";\nimport { LendingLib } from \"../lending/libraries/LendingLib.sol\";\nimport {\n PlatformSettingsLib\n} from \"../settings/platform/libraries/PlatformSettingsLib.sol\";\nimport {\n MaxDebtRatioLib\n} from \"../settings/asset/libraries/MaxDebtRatioLib.sol\";\nimport {\n MaxLoanAmountLib\n} from \"../settings/asset/libraries/MaxLoanAmountLib.sol\";\nimport { Counters } from \"@openzeppelin/contracts/utils/Counters.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\nimport { NumbersLib } from \"../shared/libraries/NumbersLib.sol\";\nimport { NFTLib } from \"../nft/libraries/NFTLib.sol\";\n\n// Interfaces\nimport { ILoansEscrow } from \"../escrow/escrow/ILoansEscrow.sol\";\nimport { ITToken } from \"../lending/ttoken/ITToken.sol\";\n\n// Proxy\nimport {\n BeaconProxy\n} from \"@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol\";\nimport { Clones } from \"@openzeppelin/contracts/proxy/Clones.sol\";\n\n// Storage\nimport {\n LoanRequest,\n LoanStatus,\n LoanTerms,\n Loan,\n MarketStorageLib\n} from \"../storage/market.sol\";\nimport { AppStorageLib } from \"../storage/app.sol\";\n\ncontract CreateLoanFacet is RolesMods, ReentryMods, PausableMods {\n /**\n * @notice This event is emitted when a loan has been successfully taken out\n * @param loanID ID of loan from which collateral was withdrawn\n * @param borrower Account address of the borrower\n * @param amountBorrowed Total amount taken out in the loan\n * @param withNFT Boolean indicating if the loan was taken out using NFTs\n */\n event LoanTakenOut(\n uint256 indexed loanID,\n address indexed borrower,\n uint256 amountBorrowed,\n bool withNFT\n );\n\n /**\n * @notice Creates the loan from requests and validator responses then calling the main function.\n * @param request Struct of the protocol loan request\n */\n modifier __createLoan(LoanRequest calldata request, bool withNFT) {\n Loan storage loan = CreateLoanLib.createLoan(request, withNFT);\n\n _;\n\n loan.status = LoanStatus.Active;\n loan.loanStartTime = uint32(block.timestamp);\n loan.duration = request.request.duration;\n }\n\n /**\n * @notice Creates a loan with the loan request and NFTs without any collateral\n * @param request Struct of the protocol loan request\n * @param nftIDs IDs of TellerNFTs to use for the loan\n */\n function takeOutLoanWithNFTs(\n LoanRequest calldata request,\n uint16[] calldata nftIDs\n ) external paused(LibLoans.ID, false) __createLoan(request, true) {\n // Get the ID of the newly created loan\n uint256 loanID = CreateLoanLib.currentID() - 1;\n uint256 amount = LibLoans.loan(loanID).borrowedAmount;\n uint8 lendingDecimals = ERC20(request.request.assetAddress).decimals();\n\n uint256 allowedBaseLoanSize;\n for (uint256 i; i < nftIDs.length; i++) {\n NFTLib.applyToLoan(loanID, nftIDs[i]);\n\n allowedBaseLoanSize += NFTLib.s().nftDictionary.tokenBaseLoanSize(\n nftIDs[i]\n );\n }\n require(\n amount <= allowedBaseLoanSize * (10**lendingDecimals),\n \"Teller: insufficient NFT loan size\"\n );\n\n // Pull funds from Teller Token LP and transfer to the new loan escrow\n LendingLib.tToken(LibLoans.loan(loanID).lendingToken).fundLoan(\n CreateLoanLib.createEscrow(loanID),\n amount\n );\n\n emit LoanTakenOut(\n loanID,\n msg.sender,\n LibLoans.loan(loanID).borrowedAmount,\n true\n );\n }\n\n /**\n * @notice Take out a loan\n *\n * @dev collateral ratio is a percentage of the loan amount that's required in collateral\n * @dev the percentage will be *(10**2). I.e. collateralRatio of 5244 means 52.44% collateral\n * @dev is required in the loan. Interest rate is also a percentage with 2 decimal points.\n *\n * @param request Struct of the protocol loan request\n * @param collateralToken Token address to use as collateral for the new loan\n * @param collateralAmount Amount of collateral required for the loan\n */\n function takeOutLoan(\n LoanRequest calldata request,\n address collateralToken,\n uint256 collateralAmount\n )\n external\n payable\n paused(LibLoans.ID, false)\n nonReentry(\"\")\n authorized(AUTHORIZED, msg.sender)\n __createLoan(request, false)\n {\n // Check if collateral token is zero\n require(\n collateralToken != address(0x0),\n \"Teller: token addr can't be 0\"\n );\n\n // Verify collateral token is acceptable\n require(\n EnumerableSet.contains(\n MarketStorageLib.store().collateralTokens[\n request.request.assetAddress\n ],\n collateralToken\n ),\n \"Teller: collateral token not allowed\"\n );\n\n // Get the ID of the newly created loan\n Loan storage loan = LibLoans.loan(CreateLoanLib.currentID() - 1);\n\n // Save collateral token to loan\n loan.collateralToken = collateralToken;\n\n // Pay in collateral\n if (collateralAmount > 0) {\n LibCollateral.deposit(loan.id, collateralAmount);\n }\n\n // Check that enough collateral has been provided for this loan\n require(\n LibLoans.getCollateralNeeded(loan.id) <=\n LibCollateral.e(loan.id).loanSupply(loan.id),\n \"Teller: more collateral required\"\n );\n // Pull funds from Teller token LP and and transfer to the recipient\n ITToken tToken = LendingLib.tToken(request.request.assetAddress);\n\n tToken.fundLoan(\n LibLoans.canGoToEOAWithCollateralRatio(loan.collateralRatio)\n ? loan.borrower\n : CreateLoanLib.createEscrow(loan.id),\n loan.borrowedAmount\n );\n\n emit LoanTakenOut(loan.id, msg.sender, loan.borrowedAmount, false);\n }\n}\n\nlibrary CreateLoanLib {\n function createLoan(LoanRequest calldata request, bool withNFT)\n internal\n returns (Loan storage loan)\n {\n // Perform loan request checks\n require(\n msg.sender == request.request.borrower,\n \"Teller: not loan requester\"\n );\n require(\n PlatformSettingsLib.getMaximumLoanDurationValue() >=\n request.request.duration,\n \"Teller: max loan duration exceeded\"\n );\n\n // Get consensus values from request\n (uint16 interestRate, uint16 collateralRatio, uint256 maxLoanAmount) =\n LibConsensus.processLoanTerms(request);\n\n // Perform loan value checks\n require(\n MaxLoanAmountLib.get(request.request.assetAddress) > maxLoanAmount,\n \"Teller: asset max loan amount exceeded\"\n );\n require(\n LendingLib.tToken(request.request.assetAddress).debtRatioFor(\n maxLoanAmount\n ) <= MaxDebtRatioLib.get(request.request.assetAddress),\n \"Teller: max supply-to-debt ratio exceeded\"\n );\n\n // Get and increment new loan ID\n uint256 loanID = CreateLoanLib.newID();\n // Set loan data based on terms\n loan = LibLoans.loan(loanID);\n loan.id = uint128(loanID);\n loan.status = LoanStatus.TermsSet;\n loan.lendingToken = request.request.assetAddress;\n loan.borrower = request.request.borrower;\n loan.borrowedAmount = maxLoanAmount;\n if (withNFT) {\n loan.interestRate = PlatformSettingsLib.getNFTInterestRate();\n } else {\n loan.interestRate = interestRate;\n loan.collateralRatio = collateralRatio;\n }\n\n // Set loan debt\n LibLoans.debt(loanID).principalOwed = maxLoanAmount;\n LibLoans.debt(loanID).interestOwed = LibLoans.getInterestOwedFor(\n uint256(loanID),\n maxLoanAmount\n );\n\n // Add loanID to borrower list\n MarketStorageLib.store().borrowerLoans[loan.borrower].push(\n uint128(loanID)\n );\n }\n\n /**\n * @notice increments the loanIDCounter\n * @return id_ the new ID requested, which stores it in the loan data\n */\n function newID() internal returns (uint256 id_) {\n Counters.Counter storage counter =\n MarketStorageLib.store().loanIDCounter;\n id_ = Counters.current(counter);\n Counters.increment(counter);\n }\n\n function currentID() internal view returns (uint256 id_) {\n Counters.Counter storage counter =\n MarketStorageLib.store().loanIDCounter;\n id_ = Counters.current(counter);\n }\n\n /**\n * @notice it creates a new loan escrow contract\n * @param loanID the ID that identifies the loan\n * @return escrow_ the loanEscrow that gets created\n */\n function createEscrow(uint256 loanID) internal returns (address escrow_) {\n // Create escrow\n escrow_ = AppStorageLib.store().loansEscrowBeacon.cloneProxy(\"\");\n ILoansEscrow(escrow_).init();\n // Save escrow address for loan\n MarketStorageLib.store().loanEscrows[loanID] = ILoansEscrow(escrow_);\n }\n}\n" + }, + "contracts/market/LoanDataFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport { LibLoans } from \"./libraries/LibLoans.sol\";\nimport { LibEscrow } from \"../escrow/libraries/LibEscrow.sol\";\n\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\n// Storage\nimport { Loan, LoanDebt, LoanTerms } from \"../storage/market.sol\";\n\ncontract LoanDataFacet {\n /**\n * @notice Returns the information about the given {loanID}.\n * @param loanID The loan ID to get information for.\n * @return loan_ The loan data.\n */\n function getLoan(uint256 loanID) external view returns (Loan memory loan_) {\n loan_ = LibLoans.s().loans[loanID];\n }\n\n /**\n * @notice DEPRECATED\n * @notice Returns the terms for a specified loan.\n * @param loanID The loan ID to get the total amount owed.\n * @return LoanTerms The terms that the loan weer created with.\n */\n function getLoanTerms(uint256 loanID)\n external\n view\n returns (LoanTerms memory)\n {\n return LibLoans.terms(loanID);\n }\n\n /**\n * @notice Returns the loan IDs created by the {borrower} account.\n * @param borrower The account to get loan IDs for.\n * @return loanIDs The IDs for loans created by the {borrower}\n */\n function getBorrowerLoans(address borrower)\n external\n view\n returns (uint128[] memory loanIDs)\n {\n return LibLoans.s().borrowerLoans[borrower];\n }\n\n /**\n * @notice Returns the debt owed for a specified loan.\n * @param loanID The loan ID to get the total amount owed.\n * @return LoanDebt The principal and interest owed amount.\n */\n function getDebtOwed(uint256 loanID)\n external\n view\n returns (LoanDebt memory)\n {\n return LibLoans.debt(loanID);\n }\n\n /**\n * @notice Returns the total amount owed for a specified loan.\n * @param loanID The loan ID to get the total amount owed.\n * @return uint256 The total owed amount.\n */\n function getTotalOwed(uint256 loanID) external view returns (uint256) {\n return LibLoans.getTotalOwed(loanID);\n }\n\n /**\n * @notice Returns the amount of interest owed for a given loan and loan amount.\n * @param loanID The loan ID to get the owed interest.\n * @param amountBorrow The principal of the loan to take out.\n * @return uint256 The interest owed.\n */\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\n external\n view\n returns (uint256)\n {\n return LibLoans.getInterestOwedFor(loanID, amountBorrow);\n }\n\n /**\n * @notice it returns the collateral needed for a loan\n * @param loanID the identifier of the loan ID to retrieve collateral from\n * @return neededInLendingTokens total collateral needed in lending tokens\n * @return neededInCollateralTokens total collateral needed in collateral tokens\n * @return escrowLoanValue total collateral needed in loan value\n */\n function getCollateralNeededInfo(uint256 loanID)\n external\n view\n returns (\n uint256 neededInLendingTokens,\n uint256 neededInCollateralTokens,\n uint256 escrowLoanValue\n )\n {\n return LibLoans.getCollateralNeededInfo(loanID);\n }\n\n /**\n * @notice it returns the typed address of a loan escrow\n * @param loanID the identifier of the respective escrow's loan\n * @return escrow_ the typed address of the returned ILoanEscrow\n */\n function getLoanEscrow(uint256 loanID)\n external\n view\n returns (address escrow_)\n {\n escrow_ = address(LibLoans.s().loanEscrows[loanID]);\n }\n\n /**\n * @notice it returns the escrow's total value by calculating the value all the escrow tokens\n * @param loanID the identifier of the respective escrow's loan\n * @return the total value of the loan escrow\n */\n function getLoanEscrowValue(uint256 loanID)\n external\n view\n returns (uint256)\n {\n return LibEscrow.calculateTotalValue(loanID);\n }\n\n /**\n * @notice it returns the total escrow tokens held by an escrow\n * @param loanID the identifier of the respective escrow's loan\n * @return tokens_ the tokens held at the escrow loan\n */\n function getEscrowTokens(uint256 loanID)\n external\n view\n returns (address[] memory tokens_)\n {\n EnumerableSet.AddressSet storage escrowTokens =\n LibEscrow.getEscrowTokens(loanID);\n tokens_ = new address[](EnumerableSet.length(escrowTokens));\n for (uint256 i; i < tokens_.length; i++) {\n tokens_[i] = EnumerableSet.at(escrowTokens, i);\n }\n }\n}\n" + }, + "contracts/market/RepayFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../contexts2/access-control/roles/RolesMods.sol\";\nimport { PausableMods } from \"../settings/pausable/PausableMods.sol\";\nimport {\n ReentryMods\n} from \"../contexts2/access-control/reentry/ReentryMods.sol\";\nimport { AUTHORIZED } from \"../shared/roles.sol\";\nimport { LoanDataFacet } from \"./LoanDataFacet.sol\";\nimport { EscrowClaimTokens } from \"../escrow/EscrowClaimTokens.sol\";\n\n// Libraries\nimport {\n IERC20,\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\nimport { LibLoans } from \"./libraries/LibLoans.sol\";\nimport { LibCollateral } from \"./libraries/LibCollateral.sol\";\nimport { LibDapps } from \"../escrow/dapps/libraries/LibDapps.sol\";\nimport { LibEscrow } from \"../escrow/libraries/LibEscrow.sol\";\nimport {\n PlatformSettingsLib\n} from \"../settings/platform/libraries/PlatformSettingsLib.sol\";\nimport { NumbersLib } from \"../shared/libraries/NumbersLib.sol\";\nimport { PriceAggLib } from \"../price-aggregator/PriceAggLib.sol\";\nimport { NFTLib } from \"../nft/libraries/NFTLib.sol\";\n\n// Interfaces\nimport { ITToken } from \"../lending/ttoken/ITToken.sol\";\nimport { ILoansEscrow } from \"../escrow/escrow/ILoansEscrow.sol\";\n\n// Storage\nimport {\n MarketStorageLib,\n MarketStorage,\n Loan,\n LoanStatus\n} from \"../storage/market.sol\";\n\ncontract RepayFacet is RolesMods, ReentryMods, PausableMods, EscrowClaimTokens {\n /**\n @notice This event is emitted when a loan has been successfully repaid\n @param loanID ID of loan from which collateral was withdrawn\n @param borrower Account address of the borrower\n @param amountPaid Amount of the loan paid back\n @param payer Account address of the payer\n @param totalOwed Total amount of the loan to be repaid\n */\n event LoanRepaid(\n uint256 indexed loanID,\n address indexed borrower,\n uint256 amountPaid,\n address payer,\n uint256 totalOwed\n );\n\n /**\n * @notice This event is emitted when a loan has been successfully liquidated\n * @param loanID ID of loan from which collateral was withdrawn\n * @param borrower Account address of the borrower\n * @param liquidator Account address of the liquidator\n * @param reward Value in lending token paid out to liquidator\n * @param tokensIn Percentage of the collateral price paid by the liquidator to the lending pool\n */\n event LoanLiquidated(\n uint256 indexed loanID,\n address indexed borrower,\n address liquidator,\n uint256 reward,\n uint256 tokensIn\n );\n\n /**\n * @notice Repay this Escrow's loan.\n * @dev If the Escrow's balance of the borrowed token is less than the amount to repay, transfer tokens from the sender's wallet.\n * @dev Only the owner of the Escrow can call this. If someone else wants to make a payment, they should call the loan manager directly.\n * @param loanID The id of the loan being used.\n * @param amount The amount being repaid.\n */\n function escrowRepay(uint256 loanID, uint256 amount)\n external\n paused(\"\", false)\n authorized(AUTHORIZED, msg.sender)\n nonReentry(\"\")\n {\n uint256 balance =\n LibEscrow.balanceOf(loanID, LibLoans.loan(loanID).lendingToken);\n uint256 totalOwed = LibLoans.getTotalOwed(loanID);\n // if there isn't enough balance in the escrow, then transfer amount needed to the escrow\n if (balance < totalOwed && amount > balance) {\n uint256 amountNeeded =\n amount > totalOwed ? totalOwed - (balance) : amount - (balance);\n\n SafeERC20.safeTransferFrom(\n IERC20(LibLoans.loan(loanID).lendingToken),\n msg.sender,\n address(LibEscrow.e(loanID)),\n amountNeeded\n );\n }\n\n __repayLoan(loanID, amount, address(LibEscrow.e(loanID)), false);\n }\n\n /**\n * @notice Make a payment to a loan\n * @param loanID The ID of the loan the payment is for\n * @param amount The amount of tokens to pay back to the loan\n */\n function repayLoan(uint256 loanID, uint256 amount)\n external\n nonReentry(\"\")\n paused(\"\", false)\n authorized(AUTHORIZED, msg.sender)\n {\n __repayLoan(loanID, amount, msg.sender, false);\n }\n\n /**\n * @notice it repays the loan, either from an escrow or from a regular address\n * @param loanID the identifier of the loan to repay\n * @param amount the amount to repay the loan\n * @param sender the address of the sender that wants to pay, can also be a loan escrow\n * @param isLiquidation is this loan being liquidated?\n * @return leftToPay_ the amount left to pay for the loan\n */\n function __repayLoan(\n uint256 loanID,\n uint256 amount,\n address sender,\n bool isLiquidation\n ) private returns (uint256 leftToPay_) {\n require(amount > 0, \"Teller: zero repay\");\n\n // calculate the actual amount to repay\n leftToPay_ =\n LibLoans.debt(loanID).principalOwed +\n LibLoans.debt(loanID).interestOwed;\n if (leftToPay_ < amount) {\n amount = leftToPay_;\n leftToPay_ = 0;\n } else {\n leftToPay_ -= amount;\n }\n\n // Get the Teller token for the loan\n ITToken tToken =\n MarketStorageLib.store().tTokens[\n LibLoans.loan(loanID).lendingToken\n ];\n // Transfer funds from an escrow if an escrow is calling it\n // Otherwise, transfer funds from an account\n if (address(LibEscrow.e(loanID)) == sender) {\n LibEscrow.e(loanID).claimToken(\n LibLoans.loan(loanID).lendingToken,\n address(tToken),\n amount\n );\n } else {\n SafeERC20.safeTransferFrom(\n IERC20(LibLoans.loan(loanID).lendingToken),\n sender,\n address(tToken),\n amount\n );\n }\n\n // Deduct the interest and principal owed\n uint256 principalPaid;\n uint256 interestPaid;\n if (amount < LibLoans.debt(loanID).interestOwed) {\n interestPaid = amount;\n LibLoans.debt(loanID).interestOwed -= amount;\n } else {\n if (LibLoans.debt(loanID).interestOwed > 0) {\n interestPaid = LibLoans.debt(loanID).interestOwed;\n amount -= interestPaid;\n LibLoans.debt(loanID).interestOwed = 0;\n }\n\n if (amount > 0) {\n principalPaid = amount;\n LibLoans.debt(loanID).principalOwed -= amount;\n }\n }\n\n // Tell the Teller Token value has been deposited back into the pool.\n tToken.repayLoan(principalPaid, interestPaid);\n\n if (isLiquidation) {\n // Make sure there is nothing left to repay on the loan\n require(leftToPay_ == 0, \"Teller: liquidate partial repay\");\n\n // Set loan status\n LibLoans.loan(loanID).status = LoanStatus.Liquidated;\n\n // Transfer NFT if linked\n NFTLib.liquidateNFT(loanID);\n } else {\n // if the loan is now fully paid, close it and withdraw borrower collateral\n if (leftToPay_ == 0) {\n LibLoans.loan(loanID).status = LoanStatus.Closed;\n\n // Check if the loan has a collateral token\n if (LibLoans.loan(loanID).collateralToken != address(0)) {\n LibCollateral.withdrawAll(\n loanID,\n LibLoans.loan(loanID).borrower\n );\n }\n\n // Claim tokens in the escrow for the loan if any\n __claimEscrowTokens(loanID);\n\n // Restake any NFTs linked to loan for borrower\n NFTLib.restakeLinked(loanID, LibLoans.loan(loanID).borrower);\n }\n\n emit LoanRepaid(\n loanID,\n LibLoans.loan(loanID).borrower,\n amount,\n msg.sender,\n leftToPay_\n );\n }\n }\n\n /**\n * @notice Liquidate a loan if it is expired or under collateralized\n * @param loanID The ID of the loan to be liquidated\n */\n function liquidateLoan(uint256 loanID)\n external\n nonReentry(\"\")\n paused(\"\", false)\n authorized(AUTHORIZED, msg.sender)\n {\n Loan storage loan = LibLoans.loan(loanID);\n uint256 collateralAmount = LibCollateral.e(loanID).loanSupply(loanID);\n require(\n RepayLib.isLiquidable(loanID, collateralAmount),\n \"Teller: does not need liquidation\"\n );\n\n // Calculate the reward before repaying the loan\n (uint256 rewardInLending, uint256 collateralInLending) =\n RepayLib.getLiquidationReward(loanID, collateralAmount);\n\n // The liquidator pays the amount still owed on the loan\n uint256 amountToLiquidate =\n LibLoans.debt(loanID).principalOwed +\n LibLoans.debt(loanID).interestOwed;\n\n __repayLoan(loanID, amountToLiquidate, msg.sender, true);\n\n // Payout the liquidator reward owed\n if (rewardInLending > 0) {\n RepayLib.payOutLiquidator(\n loanID,\n rewardInLending,\n collateralInLending,\n collateralAmount,\n payable(msg.sender)\n );\n }\n\n emit LoanLiquidated(\n loanID,\n loan.borrower,\n msg.sender,\n rewardInLending,\n amountToLiquidate\n );\n }\n\n /**\n * @notice It gets the current liquidation reward for a given loan.\n * @param loanID The loan ID to get the info.\n * @return inLending_ The value the liquidator will receive denoted in lending tokens.\n * @return inCollateral_ The value the liquidator will receive denoted in collateral tokens.\n */\n function getLiquidationReward(uint256 loanID)\n external\n view\n returns (uint256 inLending_, uint256 inCollateral_)\n {\n (inLending_, ) = RepayLib.getLiquidationReward(\n loanID,\n LibCollateral.e(loanID).loanSupply(loanID)\n );\n inCollateral_ = PriceAggLib.valueFor(\n LibLoans.loan(loanID).lendingToken,\n LibLoans.loan(loanID).collateralToken,\n inLending_\n );\n }\n}\n\nlibrary RepayLib {\n /**\n * @notice It checks if a loan can be liquidated.\n * @param loanID The loan ID to check.\n * @return true if the loan is liquidable.\n */\n function isLiquidable(uint256 loanID, uint256 collateralAmount)\n internal\n view\n returns (bool)\n {\n Loan storage loan = LibLoans.loan(loanID);\n // Check if loan can be liquidated\n if (loan.status != LoanStatus.Active) {\n return false;\n }\n\n if (loan.collateralRatio > 0) {\n // If loan has a collateral ratio, check how much is needed\n (, uint256 neededInCollateral, ) =\n LoanDataFacet(address(this)).getCollateralNeededInfo(loanID);\n if (neededInCollateral > collateralAmount) {\n return true;\n }\n }\n\n // Otherwise, check if the loan has expired\n return block.timestamp >= loan.loanStartTime + loan.duration;\n }\n\n /**\n * @notice It gets the current liquidation reward for a given loan.\n * @param loanID The loan ID to get the info.\n * @param collateralAmount The amount of collateral for the {loanID}. Passed in to save gas calling the collateral escrow multiple times.\n * @return reward_ The value the liquidator will receive denoted in lending tokens.\n */\n function getLiquidationReward(uint256 loanID, uint256 collateralAmount)\n internal\n view\n returns (uint256 reward_, uint256 collateralValue_)\n {\n uint256 amountToLiquidate =\n LibLoans.debt(loanID).principalOwed +\n LibLoans.debt(loanID).interestOwed;\n\n // Max reward is amount repaid on loan plus extra percentage\n uint256 maxReward =\n amountToLiquidate +\n NumbersLib.percent(\n amountToLiquidate,\n uint16(PlatformSettingsLib.getLiquidateRewardPercent())\n );\n\n // Calculate available collateral for reward\n if (collateralAmount > 0) {\n collateralValue_ = PriceAggLib.valueFor(\n LibLoans.loan(loanID).collateralToken,\n LibLoans.loan(loanID).lendingToken,\n collateralAmount\n );\n reward_ += collateralValue_;\n }\n\n // Calculate loan escrow value if collateral not enough to cover reward\n if (reward_ < maxReward) {\n reward_ += LibEscrow.calculateTotalValue(loanID);\n }\n\n // Cap the reward to max\n if (reward_ > maxReward) {\n reward_ = maxReward;\n }\n }\n\n /**\n * @notice Checks if the loan has an Escrow and claims any tokens then pays out the loan collateral.\n * @dev See Escrow.claimTokens for more info.\n * @param loanID The loan ID which is being liquidated\n * @param rewardInLending The total amount of reward based in the lending token to pay the liquidator\n * @param collateralInLending The amount of collateral that is available for the loan denoted in lending tokens\n * @param collateralAmount The amount of collateral that is available for the loan\n * @param liquidator The address of the liquidator where the liquidation reward will be sent to\n */\n function payOutLiquidator(\n uint256 loanID,\n uint256 rewardInLending,\n uint256 collateralInLending,\n uint256 collateralAmount,\n address payable liquidator\n ) internal {\n // check if loan is liquidated\n require(\n LibLoans.loan(loanID).status == LoanStatus.Liquidated,\n \"Teller: loan not liquidated\"\n );\n\n // if the lending reward is less than the collateral lending tokens, then aggregate\n // the value for the lending token with the collateral token and send it to the liquidator\n if (rewardInLending <= collateralInLending) {\n uint256 rewardInCollateral =\n PriceAggLib.valueFor(\n LibLoans.loan(loanID).lendingToken,\n LibLoans.loan(loanID).collateralToken,\n rewardInLending\n );\n\n LibCollateral.withdraw(loanID, rewardInCollateral, liquidator);\n } else {\n // Payout whats available in the collateral token\n LibCollateral.withdraw(loanID, collateralAmount, liquidator);\n\n // Claim remaining reward value from the loan escrow\n claimEscrowTokensByValue(\n loanID,\n liquidator,\n rewardInLending - collateralInLending\n );\n }\n }\n\n /**\n * @dev Send the equivalent of tokens owned by the loan escrow (in lending value) to the recipient,\n * @param loanID The loan ID to clam tokens from\n * @param recipient address to send the tokens to\n * @param value The value of escrow held tokens to be claimed based in lending value\n */\n function claimEscrowTokensByValue(\n uint256 loanID,\n address recipient,\n uint256 value\n ) private {\n EnumerableSet.AddressSet storage tokens =\n MarketStorageLib.store().escrowTokens[loanID];\n uint256 valueLeftToTransfer = value;\n\n // Start with the lending token\n valueLeftToTransfer = claimEscrowToken(\n loanID,\n LibLoans.loan(loanID).lendingToken,\n recipient,\n valueLeftToTransfer\n );\n\n // Cycle through remaining tokens\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\n if (valueLeftToTransfer == 0) {\n return;\n }\n\n valueLeftToTransfer = claimEscrowToken(\n loanID,\n EnumerableSet.at(tokens, i),\n recipient,\n valueLeftToTransfer\n );\n }\n }\n\n /**\n * @notice it claims the escrow tokens for the liquidator\n * @notice it keeps claiming escrow tokens until there aren't anymore tokens or the valueLeftToTransfer is zero\n * @param loanID the identifier of the escrow loan to claim tokens from\n * @param token the address of the token asset to claim\n * @param recipient the address of the recipient to transfer the tokens to\n * @param valueLeftToTransfer the value left to transfer to the liquidator that is returned back\n * @return the value left to transfer\n */\n function claimEscrowToken(\n uint256 loanID,\n address token,\n address recipient,\n uint256 valueLeftToTransfer\n ) private returns (uint256) {\n uint256 balance = LibEscrow.balanceOf(loanID, token);\n // get value of token balance in lending value\n if (balance > 0) {\n // If token not the lending token, get value of token\n uint256 balanceInLending;\n if (token == LibLoans.loan(loanID).lendingToken) {\n balanceInLending = balance;\n } else {\n balanceInLending = PriceAggLib.valueFor(\n token,\n LibLoans.loan(loanID).lendingToken,\n balance\n );\n }\n\n if (balanceInLending <= valueLeftToTransfer) {\n LibEscrow.e(loanID).claimToken(token, recipient, balance);\n valueLeftToTransfer -= balanceInLending;\n } else {\n // Token balance is more than enough so calculate ratio of balance to transfer\n uint256 valueToTransfer;\n if (token == LibLoans.loan(loanID).lendingToken) {\n valueToTransfer = valueLeftToTransfer;\n } else {\n valueToTransfer = NumbersLib.percent(\n balance,\n NumbersLib.ratioOf(\n valueLeftToTransfer,\n balanceInLending\n )\n );\n }\n\n LibEscrow.e(loanID).claimToken(\n token,\n recipient,\n valueToTransfer\n );\n valueLeftToTransfer = 0;\n }\n }\n return valueLeftToTransfer;\n }\n}\n" + }, + "contracts/market/SignersFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Storage\nimport { MarketStorageLib } from \"../storage/market.sol\";\n\n// Libraries\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\ncontract SignersFacet {\n /**\n * @notice It adds a new account as a signer.\n * @param asset Token address to add signers for.\n * @param account address to add.\n * @dev The sender must be the owner.\n * @dev It throws a require error if the sender is not the owner.\n */\n function addSigner(address asset, address account) external {\n _addSigner(asset, account);\n }\n\n /**\n * @notice It adds a list of account as signers.\n * @param asset Token address to add signers for.\n * @param accounts addresses to add.\n * @dev The sender must be the owner.\n * @dev It throws a require error if the sender is not the owner.\n */\n function addSigners(address asset, address[] calldata accounts) external {\n for (uint256 i; i < accounts.length; i++) {\n _addSigner(asset, accounts[i]);\n }\n }\n\n /**\n * @notice it adds an account to a list of signers for an asset\n * @param asset is the token address to check for signers\n * @param account is the account address of the signer\n */\n function _addSigner(address asset, address account) internal {\n if (!isSigner(asset, account)) {\n EnumerableSet.add(MarketStorageLib.store().signers[asset], account);\n }\n }\n\n /**\n * @notice it checks if an account is already in the list of the asset's signers\n * @param asset the asset to check for if the signer exists\n * @param account the account to check in the list of the asset's signers\n */\n function isSigner(address asset, address account)\n public\n view\n returns (bool isSigner_)\n {\n isSigner_ = EnumerableSet.contains(\n MarketStorageLib.store().signers[asset],\n account\n );\n }\n}\n" + }, + "contracts/nft/NFTFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { TellerNFT } from \"../nft/TellerNFT.sol\";\nimport { RolesMods } from \"../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN, AUTHORIZED } from \"../shared/roles.sol\";\n\n// Libraries\nimport \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\nimport { NFTLib } from \"./libraries/NFTLib.sol\";\nimport { RolesLib } from \"../contexts2/access-control/roles/RolesLib.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\ncontract NFTFacet is RolesMods {\n /**\n * @notice it gets the staked NFTs mapped to an owner's address\n * @return staked_ the returned staked NFTs mapped to an owner's address\n */\n function getStakedNFTs(address nftOwner)\n public\n view\n returns (uint256[] memory staked_)\n {\n staked_ = NFTLib.stakedNFTs(nftOwner);\n }\n\n /**\n * @notice it returns the NFTs mapped to a loan\n * @param loanID the identifier of the respective loan to get the loan NFTs from\n * @return loanNFTs the loan NFTs mapped to a loan ID\n */\n function getLoanNFTs(uint256 loanID)\n external\n view\n returns (uint256[] memory loanNFTs)\n {\n EnumerableSet.UintSet storage nfts = NFTLib.s().loanNFTs[loanID];\n loanNFTs = new uint256[](EnumerableSet.length(nfts));\n for (uint256 i; i < EnumerableSet.length(nfts); i++) {\n loanNFTs[i] = EnumerableSet.at(nfts, i);\n }\n }\n\n /**\n * @notice Transfers multiple Teller NFTs to Diamond and applies user stake.\n * @param nftIDs IDs of Teller NFTs to stake.\n */\n function stakeNFTs(uint256[] calldata nftIDs) external {\n for (uint256 i; i < nftIDs.length; i++) {\n // Stake NFT and transfer into diamond\n NFTLib.stake(nftIDs[i], msg.sender);\n }\n // Give the caller authorization to protocol\n RolesLib.grantRole(AUTHORIZED, msg.sender);\n }\n}\n" + }, + "contracts/market/CollateralFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { RolesMods } from \"../contexts2/access-control/roles/RolesMods.sol\";\nimport {\n ReentryMods\n} from \"../contexts2/access-control/reentry/ReentryMods.sol\";\nimport { PausableMods } from \"../settings/pausable/PausableMods.sol\";\nimport { ADMIN, AUTHORIZED } from \"../shared/roles.sol\";\n\n// Libraries\nimport { LibLoans } from \"./libraries/LibLoans.sol\";\nimport { LibCollateral } from \"./libraries/LibCollateral.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\n// Storage\nimport {\n MarketStorageLib,\n MarketStorage,\n LoanStatus,\n Loan\n} from \"../storage/market.sol\";\n\ncontract CollateralFacet is RolesMods, ReentryMods, PausableMods {\n /**\n * @notice Deposit collateral tokens into a loan.\n * @param loanID The ID of the loan the collateral is for\n * @param amount The amount to deposit as collateral.\n */\n function depositCollateral(uint256 loanID, uint256 amount)\n external\n payable\n paused(\"\", false)\n nonReentry(\"\")\n authorized(AUTHORIZED, msg.sender)\n {\n uint256 status = uint256(LibLoans.loan(loanID).status);\n require(\n status ==\n (uint256(LoanStatus.TermsSet) ^ uint256(LoanStatus.Active)) &\n status,\n \"Teller: loan not active or set\"\n );\n\n // Transfer tokens to the collateral escrow\n LibCollateral.deposit(loanID, amount);\n }\n\n /**\n * @notice it withdraws collateral tokens from a loan\n * @param amount to wtihdraw from the loan\n * @param loanID identifier of our loan\n */\n function withdrawCollateral(uint256 amount, uint256 loanID)\n external\n paused(\"\", false)\n nonReentry(\"\")\n authorized(AUTHORIZED, msg.sender)\n {\n // check if caller is borrower\n require(\n msg.sender == LibLoans.loan(loanID).borrower,\n \"Teller: not borrower\"\n );\n\n // check if amount required to withdraw is more than zero\n require(amount > 0, \"Teller: zero withdraw\");\n\n // here, we check if the loan supply minus the needed collateral tokens is still\n // greater than the amount we want to withdraw\n if (LibLoans.loan(loanID).status == LoanStatus.Active) {\n (, uint256 needed, ) = LibLoans.getCollateralNeededInfo(loanID);\n if (needed > 0) {\n require(\n LibCollateral.e(loanID).loanSupply(loanID) - needed >=\n amount,\n \"Teller: collateral withdraw amount over limit\"\n );\n }\n }\n\n // Withdraw collateral and send to loan borrower\n LibCollateral.withdraw(loanID, amount, LibLoans.loan(loanID).borrower);\n }\n\n /**\n * @notice Adds tokens allowed to be used as collateral for {asset} loans.\n * @notice it creates an escrow for each collateral token address\n * @param asset Token address to add allowed collateral tokens.\n * @param collateralTokens List of allowed collateral token addresses.\n *\n * Requirements:\n * - Sender must be admin\n */\n function addCollateralTokens(\n address asset,\n address[] calldata collateralTokens\n ) external authorized(ADMIN, msg.sender) {\n for (uint256 i; i < collateralTokens.length; i++) {\n EnumerableSet.add(\n MarketStorageLib.store().collateralTokens[asset],\n collateralTokens[i]\n );\n LibCollateral.createEscrow(collateralTokens[i]);\n }\n }\n\n /**\n * @notice get list of collateral tokens that is allowed to be used on an {asset} loan\n * @param asset token address to get allowed collateral tokens\n * @return tokens_ collateral tokens that are accepted\n */\n function getCollateralTokens(address asset)\n external\n view\n returns (address[] memory tokens_)\n {\n EnumerableSet.AddressSet storage collateralTokens =\n MarketStorageLib.store().collateralTokens[asset];\n tokens_ = new address[](EnumerableSet.length(collateralTokens));\n for (uint256 i; i < EnumerableSet.length(collateralTokens); i++) {\n tokens_[i] = EnumerableSet.at(collateralTokens, i);\n }\n }\n\n /**\n * @notice get the total collateral tokens in a respective loan\n * @param loanID the identifier of the respective loan\n * @return supply_ the total amount of supply in collateral of the loan\n */\n function getLoanCollateral(uint256 loanID)\n external\n view\n returns (uint256 supply_)\n {\n supply_ = LibCollateral.e(loanID).loanSupply(loanID);\n }\n}\n" + }, + "contracts/escrow/dapps/CompoundFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { DappMods } from \"./DappMods.sol\";\nimport { PausableMods } from \"../../settings/pausable/PausableMods.sol\";\n\n// Libraries\nimport { LibCompound } from \"./libraries/LibCompound.sol\";\nimport { LibDapps } from \"./libraries/LibDapps.sol\";\nimport { LibEscrow } from \"../libraries/LibEscrow.sol\";\nimport {\n AssetCTokenLib\n} from \"../../settings/asset/libraries/AssetCTokenLib.sol\";\n\n// Interfaces\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { ICErc20 } from \"../../shared/interfaces/ICErc20.sol\";\n\ncontract CompoundFacet is PausableMods, DappMods {\n /**\n * @notice This event is emitted every time Compound lend is invoked successfully.\n * @param tokenAddress address of the underlying token.\n * @param cTokenAddress compound token address.\n * @param amount amount of tokens to Lend.\n */\n event CompoundLended(\n address indexed tokenAddress,\n address indexed cTokenAddress,\n uint256 amount\n );\n\n /**\n * @notice This event is emitted every time Compound redeem is invoked successfully.\n * @param tokenAddress address of the underlying token.\n * @param cTokenAddress compound token address.\n * @param amount amount of tokens to Redeem.\n */\n event CompoundRedeemed(\n address indexed tokenAddress,\n address indexed cTokenAddress,\n uint256 amount\n );\n\n /**\n * @notice To lend we first have to approve the cToken to access the token balance then mint.\n * @param loanID id of the loan being used in the dapp\n * @param tokenAddress address of the token.\n * @param amount amount of tokens to mint.\n */\n function compoundLend(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n ICErc20 cToken = AssetCTokenLib.get(tokenAddress);\n\n LibEscrow.e(loanID).setTokenAllowance(tokenAddress, address(cToken));\n\n bytes memory result =\n LibEscrow.e(loanID).callDapp(\n address(cToken),\n abi.encodeWithSelector(ICErc20.mint.selector, amount)\n );\n\n require(\n abi.decode(result, (uint256)) == LibCompound.NO_ERROR,\n \"Teller: compound deposit error\"\n );\n\n LibEscrow.tokenUpdated(loanID, address(cToken));\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n\n emit CompoundLended(tokenAddress, address(cToken), amount);\n }\n\n /**\n * @notice This function redeems the user's cTokens for a specific amount of the underlying token.\n * @param loanID id of the loan being used in the dapp\n * @param tokenAddress address of the token.\n * @param amount amount of underlying tokens to redeem.\n */\n function compoundRedeem(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n ICErc20 cToken = AssetCTokenLib.get(tokenAddress);\n __compoundRedeem(\n loanID,\n address(cToken),\n tokenAddress,\n abi.encodeWithSelector(ICErc20.redeemUnderlying.selector, amount)\n );\n\n emit CompoundRedeemed(tokenAddress, address(cToken), amount);\n }\n\n /**\n * @notice This function redeems the complete cToken balance.\n * @param loanID id of the loan being used in the dapp\n * @param tokenAddress address of the token.\n */\n function compoundRedeemAll(uint256 loanID, address tokenAddress)\n public\n paused(\"\", false)\n onlyBorrower(loanID)\n {\n ICErc20 cToken = AssetCTokenLib.get(tokenAddress);\n __compoundRedeem(\n loanID,\n address(cToken),\n tokenAddress,\n abi.encodeWithSelector(\n ICErc20.redeem.selector,\n cToken.balanceOf(address(LibEscrow.e(loanID)))\n )\n );\n\n emit CompoundRedeemed(\n tokenAddress,\n address(cToken),\n IERC20(tokenAddress).balanceOf(address(LibEscrow.e(loanID)))\n );\n }\n\n /**\n * @notice This function calls on Compound cToken to redeem an amount of the underlying token.\n * @param loanID ID of the loan being used for the dapp.\n * @param cTokenAddress Compound token address.\n * @param tokenAddress Underlying Compound token address.\n * @param callData Encoded data to send to the escrow to call.\n */\n function __compoundRedeem(\n uint256 loanID,\n address cTokenAddress,\n address tokenAddress,\n bytes memory callData\n ) private {\n bytes memory result =\n LibEscrow.e(loanID).callDapp(cTokenAddress, callData);\n\n require(\n abi.decode(result, (uint256)) !=\n LibCompound.TOKEN_INSUFFICIENT_BALANCE,\n \"Teller: compound dapp insufficient balance\"\n );\n require(\n abi.decode(result, (uint256)) == LibCompound.NO_ERROR,\n \"Teller: compound dapp withdrawal error\"\n );\n\n LibEscrow.tokenUpdated(loanID, cTokenAddress);\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n }\n}\n" + }, + "contracts/escrow/dapps/UniswapFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { DappMods } from \"./DappMods.sol\";\nimport { PausableMods } from \"../../settings/pausable/PausableMods.sol\";\n\n// Libraries\nimport { LibEscrow } from \"../libraries/LibEscrow.sol\";\nimport { LibUniswap } from \"./libraries/LibUniswap.sol\";\nimport {\n ChainlinkLib\n} from \"../../price-aggregator/chainlink/ChainlinkLib.sol\";\n\n// Interfaces\nimport { IUniswapV2Router } from \"../../shared/interfaces/IUniswapV2Router.sol\";\n\ncontract UniswapFacet is PausableMods, DappMods {\n /**\n * @notice Event emitted every time a successful swap has taken place.\n * @param sourceToken source token address.\n * @param destinationToken destination address.\n * @param sourceAmount source amount sent.\n * @param destinationAmount destination amount received.\n */\n event UniswapSwapped(\n address indexed sourceToken,\n address indexed destinationToken,\n uint256 sourceAmount,\n uint256 destinationAmount\n );\n\n /**\n * @notice Swaps tokens for tokens on Uniswap.\n * @dev {path} must have at least 2 token addresses\n * @param path An array of token addresses.\n * @param sourceAmount amount of source token to swap.\n * @param minDestination The minimum amount of output tokens that must be received for the transaction not to revert.\n */\n function uniswapSwap(\n uint256 loanID,\n address[] memory path,\n uint256 sourceAmount,\n uint256 minDestination\n ) external paused(\"\", false) onlySecured(loanID) onlyBorrower(loanID) {\n address src = path[0];\n address dst = path[path.length - 1];\n require(\n ChainlinkLib.isTokenSupported(src),\n \"Teller: uniswap src not supported\"\n );\n require(\n ChainlinkLib.isTokenSupported(dst),\n \"Teller: uniswap dst not supported\"\n );\n\n // Set allowance on source token to Uniswap Router\n LibEscrow.e(loanID).setTokenAllowance(src, address(LibUniswap.ROUTER));\n\n // Encode data for LoansEscrow to call\n bytes memory callData =\n abi.encodeWithSelector(\n IUniswapV2Router.swapExactTokensForTokens.selector,\n sourceAmount,\n minDestination,\n path,\n address(LibEscrow.e(loanID)),\n block.timestamp\n );\n // Call Escrow to do swap get the response amounts\n uint256[] memory amounts =\n abi.decode(\n LibEscrow.e(loanID).callDapp(\n address(LibUniswap.ROUTER),\n callData\n ),\n (uint256[])\n );\n uint256 destinationAmount = amounts[amounts.length - 1];\n\n LibEscrow.tokenUpdated(loanID, src);\n LibEscrow.tokenUpdated(loanID, dst);\n\n emit UniswapSwapped(src, dst, sourceAmount, destinationAmount);\n }\n}\n" + }, + "contracts/escrow/dapps/AaveFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Storage\nimport { DappMods } from \"./DappMods.sol\";\nimport { PausableMods } from \"../../settings/pausable/PausableMods.sol\";\nimport { LibDapps } from \"./libraries/LibDapps.sol\";\nimport { LibEscrow, ILoansEscrow } from \"../libraries/LibEscrow.sol\";\nimport { IAToken } from \"../../shared/interfaces/IAToken.sol\";\nimport { IAaveLendingPool } from \"../../shared/interfaces/IAaveLendingPool.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\n\ncontract AaveFacet is PausableMods, DappMods {\n using SafeERC20 for IERC20;\n /**\n @notice This event is emitted every time Aave deposit is invoked successfully.\n @param tokenAddress address of the underlying token.\n @param aTokenAddress aave token address.\n @param amount amount of tokens to Deposit.\n @param aTokenBalanceBeforeDeposit aTokens balance after Deposit.\n @param aTokenBalanceAfterDeposit aTokens balance after Deposit.\n */\n event AaveDeposited(\n address indexed tokenAddress,\n address indexed aTokenAddress,\n uint256 amount,\n uint256 aTokenBalanceBeforeDeposit,\n uint256 aTokenBalanceAfterDeposit\n );\n\n /**\n @notice This event is emitted every time Aave redeem is invoked successfully.\n @param tokenAddress address of the underlying token.\n @param aTokenAddress aave token address.\n @param amount amount of tokens to Withdrawal.\n @param aTokenBalanceBeforeDeposit aTokens balance after Withdrawal.\n @param aTokenBalanceAfterWithdrawal aTokens balance after Withdrawal.\n */\n event AaveWithdrawn(\n address indexed tokenAddress,\n address indexed aTokenAddress,\n uint256 amount,\n uint256 aTokenBalanceBeforeDeposit,\n uint256 aTokenBalanceAfterWithdrawal\n );\n\n /**\n @notice The deposit, the aToken needs to be approved to have access to the token balance\n @param loanID id of the loan being used in the dapp\n @param tokenAddress address of the token\n @param amount amount of tokens to deposit\n */\n function aaveDeposit(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n ILoansEscrow escrow = LibEscrow.e(loanID);\n\n IAaveLendingPool aaveLendingPool = LibDapps.getAaveLendingPool();\n escrow.setTokenAllowance(tokenAddress, address(aaveLendingPool));\n IAToken aToken = LibDapps.getAToken(tokenAddress);\n uint256 aTokenBalanceBeforeDeposit = aToken.balanceOf(address(escrow));\n\n bytes memory callData = abi.encodeWithSelector(\n aaveLendingPool.deposit.selector,\n tokenAddress,\n amount,\n address(escrow),\n 0\n );\n escrow.callDapp(address(aaveLendingPool), callData);\n\n uint256 aTokenBalanceAfterDeposit = aToken.balanceOf(address(escrow));\n require(\n aTokenBalanceAfterDeposit > aTokenBalanceBeforeDeposit,\n \"AAVE_BALANCE_NOT_INCREASED\"\n );\n\n LibEscrow.tokenUpdated(loanID, address(aToken));\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n\n emit AaveDeposited(\n tokenAddress,\n address(aToken),\n amount,\n aTokenBalanceBeforeDeposit,\n aTokenBalanceAfterDeposit\n );\n }\n\n /**\n @notice This function withdraws the user's aTokens for a specific amount\n @param loanID id of the loan being used in the dapp\n @param tokenAddress address of the token\n @param amount amount of the underlying tokens to withdraw\n */\n function aaveWithdraw(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n ILoansEscrow escrow = LibEscrow.e(loanID);\n\n IAToken aToken = LibDapps.getAToken(tokenAddress);\n IAaveLendingPool aaveLendingPool = LibDapps.getAaveLendingPool();\n uint256 aTokenBalanceBeforeWithdraw = aToken.balanceOf(address(escrow));\n require(\n aTokenBalanceBeforeWithdraw >= amount,\n \"NO_BALANCE_TO_WITHDRAW\"\n );\n\n bytes memory callData = abi.encodeWithSelector(\n aaveLendingPool.withdraw.selector,\n tokenAddress,\n amount,\n address(escrow)\n );\n LibDapps.s().loanEscrows[loanID].callDapp(\n address(aaveLendingPool),\n callData\n );\n\n uint256 aTokenBalanceAfterWithdraw = aToken.balanceOf(address(escrow));\n require(\n aTokenBalanceAfterWithdraw < aTokenBalanceBeforeWithdraw,\n \"AAVE_WITHDRAWAL_ERROR\"\n );\n\n LibEscrow.tokenUpdated(loanID, address(aToken));\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n\n emit AaveWithdrawn(\n tokenAddress,\n address(aToken),\n amount,\n aTokenBalanceBeforeWithdraw,\n aTokenBalanceAfterWithdraw\n );\n }\n\n /**\n @notice This function withdraws all the user's aTokens from previous deposits\n @param loanID id of the loan being used in the dapp\n @param tokenAddress address of the token\n */\n function aaveWithdrawAll(uint256 loanID, address tokenAddress)\n public\n paused(\"\", false)\n onlyBorrower(loanID)\n {\n ILoansEscrow escrow = LibEscrow.e(loanID);\n IAToken aToken = LibDapps.getAToken(tokenAddress);\n\n uint256 aTokenBalanceBeforeWithdraw = aToken.balanceOf(address(escrow));\n require(aTokenBalanceBeforeWithdraw >= 0, \"NO_BALANCE_TO_WITHDRAW\");\n\n IAaveLendingPool aaveLendingPool = LibDapps.getAaveLendingPool();\n\n bytes memory callData = abi.encodeWithSelector(\n aaveLendingPool.withdraw.selector,\n tokenAddress,\n aTokenBalanceBeforeWithdraw,\n address(escrow)\n );\n escrow.callDapp(address(aaveLendingPool), callData);\n\n uint256 aTokenBalanceAfterWithdraw = aToken.balanceOf(address(escrow));\n\n LibEscrow.tokenUpdated(loanID, address(aToken));\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n\n emit AaveWithdrawn(\n tokenAddress,\n address(aToken),\n aTokenBalanceBeforeWithdraw,\n aTokenBalanceBeforeWithdraw,\n aTokenBalanceAfterWithdraw\n );\n }\n}\n" + }, + "contracts/escrow/dapps/SushiswapFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { DappMods } from \"./DappMods.sol\";\nimport { PausableMods } from \"../../settings/pausable/PausableMods.sol\";\n\n// Libraries\nimport { LibEscrow } from \"../libraries/LibEscrow.sol\";\nimport { LibSushiswap } from \"./libraries/LibSushiswap.sol\";\nimport {\n ChainlinkLib\n} from \"../../price-aggregator/chainlink/ChainlinkLib.sol\";\n\n// Interfaces\nimport { IUniswapV2Router } from \"../../shared/interfaces/IUniswapV2Router.sol\";\n\ncontract SushiswapFacet is PausableMods, DappMods {\n /**\n * @notice Event emitted every time a successful swap has taken place.\n * @param sourceToken source token address.\n * @param destinationToken destination address.\n * @param sourceAmount source amount sent.\n * @param destinationAmount destination amount received.\n */\n event SushiswapSwapped(\n address indexed sourceToken,\n address indexed destinationToken,\n uint256 sourceAmount,\n uint256 destinationAmount\n );\n\n /**\n * @notice Swaps tokens for tokens on Sushiswap.\n * @dev {path} must have at least 2 token addresses\n * @param path An array of token addresses.\n * @param sourceAmount amount of source token to swap.\n * @param minDestination The minimum amount of output tokens that must be received for the transaction not to revert.\n */\n function sushiswapSwap(\n uint256 loanID,\n address[] memory path,\n uint256 sourceAmount,\n uint256 minDestination\n ) external paused(\"\", false) onlySecured(loanID) onlyBorrower(loanID) {\n address src = path[0];\n address dst = path[path.length - 1];\n require(\n ChainlinkLib.isTokenSupported(src),\n \"Teller: uniswap src not supported\"\n );\n require(\n ChainlinkLib.isTokenSupported(dst),\n \"Teller: uniswap dst not supported\"\n );\n\n // Set allowance on source token to Uniswap Router\n LibEscrow.e(loanID).setTokenAllowance(\n src,\n address(LibSushiswap.ROUTER)\n );\n\n // Encode data for LoansEscrow to call\n bytes memory callData =\n abi.encodeWithSelector(\n IUniswapV2Router.swapExactTokensForTokens.selector,\n sourceAmount,\n minDestination,\n path,\n address(LibEscrow.e(loanID)),\n block.timestamp\n );\n // Call Escrow to do swap get the response amounts\n uint256[] memory amounts =\n abi.decode(\n LibEscrow.e(loanID).callDapp(\n address(LibSushiswap.ROUTER),\n callData\n ),\n (uint256[])\n );\n uint256 destinationAmount = amounts[amounts.length - 1];\n\n LibEscrow.tokenUpdated(loanID, src);\n LibEscrow.tokenUpdated(loanID, dst);\n\n emit SushiswapSwapped(src, dst, sourceAmount, destinationAmount);\n }\n}\n" + }, + "contracts/escrow/dapps/PoolTogetherFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Storage\nimport { DappMods } from \"./DappMods.sol\";\nimport { PausableMods } from \"../../settings/pausable/PausableMods.sol\";\nimport { LibDapps } from \"./libraries/LibDapps.sol\";\nimport { LibEscrow } from \"../libraries/LibEscrow.sol\";\nimport { AssetPPoolLib } from \"../../settings/asset/libraries/AssetPPoolLib.sol\";\nimport { PoolTogetherLib } from \"./libraries/PoolTogetherLib.sol\";\nimport { PrizePoolInterface } from \"./interfaces/PrizePoolInterface.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\n\ncontract PoolTogetherFacet is PausableMods, DappMods {\n using SafeERC20 for IERC20;\n /**\n * @notice This event is emitted every time Pool Together depositTo is invoked successfully.\n * @param tokenAddress address of the underlying token.\n * @param ticketAddress pool ticket token address.\n * @param amount amount of tokens deposited.\n * @param tokenBalance underlying token balance after depositing.\n * @param creditBalanceAfter pool together credit after depositing.\n */\n event PoolTogetherDeposited(\n address indexed tokenAddress,\n address indexed ticketAddress,\n uint256 amount,\n uint256 tokenBalance,\n uint256 creditBalanceAfter\n );\n\n /**\n * @notice This event is emitted every time Pool Together withdrawInstantlyFrom is invoked successfully.\n * @param tokenAddress address of the underlying token.\n * @param ticketAddress pool ticket token address.\n * @param amount amount of tokens to Redeem.\n * @param tokenBalance underlying token balance after Redeem.\n * @param creditBalanceAfter pool together credit after depositing.\n */\n event PoolTogetherWithdrawal(\n address indexed tokenAddress,\n address indexed ticketAddress,\n uint256 amount,\n uint256 tokenBalance,\n uint256 creditBalanceAfter\n );\n\n /**\n * @notice This function deposits the users funds into a Pool Together Prize Pool for a ticket.\n * @param loanID id of the loan being used in the dapp\n * @param tokenAddress address of the token.\n * @param amount of tokens to deposit.\n */\n function poolTogetherDepositTicket(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n require(\n LibEscrow.balanceOf(loanID, tokenAddress) >= amount,\n \"POOL_INSUFFICIENT_UNDERLYING\"\n );\n\n PrizePoolInterface prizePool = AssetPPoolLib.get(tokenAddress);\n\n address ticketAddress = PoolTogetherLib.getTicketAddress(tokenAddress);\n uint256 balanceBefore = LibEscrow.balanceOf(loanID, ticketAddress);\n\n // Set token allowance to Prize Pool\n LibEscrow.e(loanID).setTokenAllowance(tokenAddress, address(prizePool));\n bytes memory callData = abi.encodeWithSelector(\n PrizePoolInterface.depositTo.selector,\n address(LibEscrow.e(loanID)), // Tickets sent to Escrow\n amount,\n ticketAddress,\n address(this) // Referrer is the Teller Diamond\n );\n LibDapps.s().loanEscrows[loanID].callDapp(address(prizePool), callData);\n uint256 balanceAfter = LibEscrow.balanceOf(loanID, ticketAddress);\n require(balanceAfter > balanceBefore, \"DEPOSIT_ERROR\");\n\n LibEscrow.tokenUpdated(loanID, address(ticketAddress));\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n\n emit PoolTogetherDeposited(\n tokenAddress,\n ticketAddress,\n amount,\n balanceBefore,\n balanceAfter\n );\n }\n\n /**\n * @notice This function withdraws the users funds from a Pool Together Prize Pool.\n * @param loanID id of the loan being used in the dapp\n * @param tokenAddress address of the token.\n * @param amount The amount of tokens to withdraw.\n */\n function poolTogetherWithdraw(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n PrizePoolInterface prizePool = AssetPPoolLib.get(tokenAddress);\n\n address ticketAddress = PoolTogetherLib.getTicketAddress(tokenAddress);\n uint256 balanceBefore = LibEscrow.balanceOf(loanID, ticketAddress);\n\n bytes memory callData = abi.encodeWithSelector(\n PrizePoolInterface.withdrawInstantlyFrom.selector,\n address(LibEscrow.e(loanID)),\n amount,\n ticketAddress,\n 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF // max exit fee\n );\n LibDapps.s().loanEscrows[loanID].callDapp(address(prizePool), callData);\n\n uint256 balanceAfter = LibEscrow.balanceOf(loanID, ticketAddress);\n require(balanceAfter < balanceBefore, \"WITHDRAW_ERROR\");\n\n LibEscrow.tokenUpdated(loanID, address(ticketAddress));\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n\n emit PoolTogetherWithdrawal(\n tokenAddress,\n ticketAddress,\n amount,\n balanceBefore,\n balanceAfter\n );\n }\n\n /**\n * @notice This function withdraws the users funds from a Pool Together Prize Pool.\n * @param loanID id of the loan being used in the dapp\n * @param tokenAddress address of the token.\n */\n function poolTogetherWithdrawAll(uint256 loanID, address tokenAddress)\n public\n paused(\"\", false)\n onlyBorrower(loanID)\n {\n PrizePoolInterface prizePool = AssetPPoolLib.get(tokenAddress);\n\n address ticketAddress = PoolTogetherLib.getTicketAddress(tokenAddress);\n uint256 balanceBefore = LibEscrow.balanceOf(loanID, ticketAddress);\n\n bytes memory callData = abi.encodeWithSelector(\n PrizePoolInterface.withdrawInstantlyFrom.selector,\n address(LibEscrow.e(loanID)),\n balanceBefore,\n ticketAddress,\n 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF\n );\n LibDapps.s().loanEscrows[loanID].callDapp(address(prizePool), callData);\n\n uint256 balanceAfter = LibEscrow.balanceOf(loanID, ticketAddress);\n require(balanceAfter < balanceBefore, \"WITHDRAW_ERROR\");\n\n LibEscrow.tokenUpdated(loanID, address(ticketAddress));\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n\n emit PoolTogetherWithdrawal(\n tokenAddress,\n ticketAddress,\n balanceBefore,\n LibEscrow.balanceOf(loanID, tokenAddress),\n balanceAfter\n );\n }\n}\n" + }, + "contracts/shared/interfaces/ICErc20.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./IComptroller.sol\";\n\ninterface ICErc20 {\n /*** User Interface ***/\n\n /**\n @notice The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of cTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.\n @param mintAmount The amount of the asset to be supplied, in units of the underlying asset.\n @return 0 on success, otherwise an Error code\n @dev msg.sender The account which shall supply the asset, and own the minted cTokens.\n @dev Before supplying an asset, users must first approve the cToken to access their token balance.\n */\n function mint(uint256 mintAmount) external returns (uint256);\n\n /**\n @notice The redeem function converts a specified quantity of cTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of cTokens redeemed, multiplied by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\n @param redeemTokens The number of cTokens to be redeemed.\n @return 0 on success, otherwise an Error code\n @dev msg.sender The account to which redeemed funds shall be transferred.\n */\n function redeem(uint256 redeemTokens) external returns (uint256);\n\n /**\n @notice The redeem underlying function converts cTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of cTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate. The amount redeemed must be less than the user's Account Liquidity and the market's available liquidity.\n @param redeemAmount The amount of underlying to be redeemed.\n @return 0 on success, otherwise an Error code\n @dev msg.sender The account to which redeemed funds shall be transferred.\n */\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\n\n /**\n @notice The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.\n @param borrowAmount The amount of the underlying asset to be borrowed.\n @return 0 on success, otherwise an Error code\n @dev msg.sender The account to which borrowed funds shall be transferred.\n */\n function borrow(uint256 borrowAmount) external returns (uint256);\n\n /**\n @notice The repay function transfers an asset into the protocol, reducing the user's borrow balance.\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\n @return 0 on success, otherwise an Error code\n @dev msg.sender The account which borrowed the asset, and shall repay the borrow.\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\n */\n function repayBorrow(uint256 repayAmount) external returns (uint256);\n\n /**\n @notice The repay function transfers an asset into the protocol, reducing the target user's borrow balance.\n @param borrower The account which borrowed the asset to be repaid.\n @param repayAmount The amount of the underlying borrowed asset to be repaid. A value of -1 (i.e. 2^256 - 1) can be used to repay the full amount.\n @return 0 on success, otherwise an Error code\n @dev msg.sender The account which shall repay the borrow.\n @dev Before repaying an asset, users must first approve the cToken to access their token balance.\n */\n function repayBorrowBehalf(address borrower, uint256 repayAmount)\n external\n returns (uint256);\n\n /*** Admin Functions ***/\n\n function _addReserves(uint256 addAmount) external returns (uint256);\n\n /** End Admin Functions */\n\n function underlying() external view returns (address);\n\n /**\n @notice Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is\n equal to: exchangeRate = (getCash() + totalBorrows() - totalReserves()) / totalSupply()\n @return The current exchange rate as an unsigned integer, scaled by 1e18.\n */\n function exchangeRateCurrent() external returns (uint256);\n\n function exchangeRateStored() external view returns (uint256);\n\n /**\n * @notice Applies accrued interest to total borrows and reserves\n * @dev This calculates interest accrued from the last checkpointed block\n * up to the current block and writes new checkpoint to storage.\n */\n function accrueInterest() external;\n\n function decimals() external view returns (uint8);\n\n function balanceOf(address account) external view returns (uint256);\n\n /**\n @notice The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.\n @param account The account to get the underlying balance of.\n @return The amount of underlying currently owned by the account.\n */\n function balanceOfUnderlying(address account) external returns (uint256);\n\n function comptroller() external view returns (IComptroller);\n}\n" + }, + "contracts/shared/interfaces/IAToken.sol": { + "content": "// SPDX-License-Identifier: agpl-3.0\npragma solidity ^0.8.0;\n\ninterface IAToken {\n /**\n * @dev Mints `amount` aTokens to `user`\n * @param user The address receiving the minted tokens\n * @param amount The amount of tokens getting minted\n * @param index The new liquidity index of the reserve\n * @return `true` if the the previous balance of the user was 0\n */\n function mint(\n address user,\n uint256 amount,\n uint256 index\n ) external returns (bool);\n\n /**\n * @dev Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`\n * @param user The owner of the aTokens, getting them burned\n * @param receiverOfUnderlying The address that will receive the underlying\n * @param amount The amount being burned\n * @param index The new liquidity index of the reserve\n **/\n function burn(\n address user,\n address receiverOfUnderlying,\n uint256 amount,\n uint256 index\n ) external;\n\n /**\n * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer\n * assets in borrow(), withdraw() and flashLoan()\n * @param user The recipient of the aTokens\n * @param amount The amount getting transferred\n * @return The amount transferred\n **/\n function transferUnderlyingTo(address user, uint256 amount)\n external\n returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender)\n external\n view\n returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the\n * updated stored balance divided by the reserve's liquidity index at the moment of the update\n * @param user The user whose balance is calculated\n * @return The scaled balance of the user\n **/\n function scaledBalanceOf(address user) external view returns (uint256);\n\n /**\n * @dev Returns the scaled balance of the user and the scaled total supply.\n * @param user The address of the user\n * @return The scaled balance of the user\n * @return The scaled balance and the scaled total supply\n **/\n function getScaledUserBalanceAndSupply(address user)\n external\n view\n returns (uint256, uint256);\n\n /**\n * @dev Returns the scaled total supply of the variable debt token. Represents sum(debt/index)\n * @return The scaled total supply\n **/\n function scaledTotalSupply() external view returns (uint256);\n}\n" + }, + "@openzeppelin/contracts/token/ERC20/IERC20.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address recipient, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\n\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n" + }, + "contracts/settings/asset/libraries/AssetCTokenLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../../shared/libraries/CacheLib.sol\";\nimport { ICErc20 } from \"../../../shared/interfaces/ICErc20.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions for Compound asset setting.\n *\n * @author develop@teller.finance\n */\nlibrary AssetCTokenLib {\n bytes32 private constant NAME = keccak256(\"cToken\");\n\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n function get(address asset) internal view returns (ICErc20) {\n return ICErc20(s(asset).addresses[NAME]);\n }\n\n function set(address asset, address newValue) internal {\n s(asset).addresses[NAME] = newValue;\n }\n}\n" + }, + "contracts/settings/asset/libraries/AssetATokenLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../../shared/libraries/CacheLib.sol\";\nimport { IAToken } from \"../../../shared/interfaces/IAToken.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions for Aave asset setting.\n *\n * @author develop@teller.finance\n */\nlibrary AssetATokenLib {\n bytes32 private constant NAME = keccak256(\"aToken\");\n\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n function get(address asset) internal view returns (IAToken) {\n return IAToken(s(asset).addresses[NAME]);\n }\n\n function set(address asset, address newValue) internal {\n s(asset).addresses[NAME] = newValue;\n }\n}\n" + }, + "contracts/settings/asset/libraries/AssetPPoolLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../../shared/libraries/CacheLib.sol\";\nimport {\n PrizePoolInterface\n} from \"../../../escrow/dapps/interfaces/PrizePoolInterface.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions for Pool together asset setting.\n *\n * @author develop@teller.finance\n */\nlibrary AssetPPoolLib {\n bytes32 private constant NAME = keccak256(\"pPool\");\n\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n function get(address asset) internal view returns (PrizePoolInterface) {\n return PrizePoolInterface(s(asset).addresses[NAME]);\n }\n\n function set(address asset, address newValue) internal {\n s(asset).addresses[NAME] = newValue;\n }\n}\n" + }, + "contracts/escrow/dapps/libraries/PoolTogetherLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Interfaces\nimport {\n AssetPPoolLib\n} from \"../../../settings/asset/libraries/AssetPPoolLib.sol\";\n\nlibrary PoolTogetherLib {\n /**\n * @notice Grabs the controlled ticket token address for the prize pool\n * @notice The pool underlying address must match the supplied token address.\n * @param tokenAddress The token address to get the cToken for.\n * @return The address of the ticket token contract.\n */\n function getTicketAddress(address tokenAddress)\n internal\n view\n returns (address)\n {\n return AssetPPoolLib.get(tokenAddress).tokens()[1];\n }\n}\n" + }, + "contracts/settings/asset/libraries/MaxLoanAmountLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../../shared/libraries/CacheLib.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions for MaxLoanAmount asset setting.\n *\n * @author develop@teller.finance\n */\nlibrary MaxLoanAmountLib {\n bytes32 private constant NAME = keccak256(\"MaxLoanAmount\");\n\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n function get(address asset) internal view returns (uint256) {\n return s(asset).uints[NAME];\n }\n\n function set(address asset, uint256 newValue) internal {\n s(asset).uints[NAME] = newValue;\n }\n}\n" + }, + "contracts/settings/asset/libraries/MaxTVLLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../../shared/libraries/CacheLib.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions for MaxDebtRatio asset setting.\n *\n * @author develop@teller.finance\n */\nlibrary MaxTVLLib {\n bytes32 private constant NAME = keccak256(\"MaxTVL\");\n\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n function get(address asset) internal view returns (uint256) {\n return s(asset).uints[NAME];\n }\n\n function set(address asset, uint256 newValue) internal {\n s(asset).uints[NAME] = newValue;\n }\n}\n" + }, + "contracts/escrow/dapps/interfaces/PrizePoolInterface.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title Escrows assets and deposits them into a yield source. Exposes interest to Prize Strategy. Users deposit and withdraw from this contract to participate in Prize Pool.\n/// @notice Accounting is managed using Controlled Tokens, whose mint and burn functions can only be called by this contract.\n/// @dev Must be inherited to provide specific yield-bearing asset control, such as Compound cTokens\ninterface PrizePoolInterface {\n /// @notice Deposit assets into the Prize Pool in exchange for tokens\n /// @param to The address receiving the newly minted tokens\n /// @param amount The amount of assets to deposit\n /// @param controlledToken The address of the type of token the user is minting\n /// @param referrer The referrer of the deposit\n function depositTo(\n address to,\n uint256 amount,\n address controlledToken,\n address referrer\n ) external;\n\n /// @notice Withdraw assets from the Prize Pool instantly. A fairness fee may be charged for an early exit.\n /// @param from The address to redeem tokens from.\n /// @param amount The amount of tokens to redeem for assets.\n /// @param controlledToken The address of the token to redeem (i.e. ticket or sponsorship)\n /// @param maximumExitFee The maximum exit fee the caller is willing to pay. This should be pre-calculated by the calculateExitFee() fxn.\n /// @return The actual exit fee paid\n function withdrawInstantlyFrom(\n address from,\n uint256 amount,\n address controlledToken,\n uint256 maximumExitFee\n ) external returns (uint256);\n\n /// @notice Returns the balance that is available to award.\n /// @dev captureAwardBalance() should be called first\n /// @return The total amount of assets to be awarded for the current prize\n function awardBalance() external view returns (uint256);\n\n /// @notice Calculates the early exit fee for the given amount\n /// @param from The user who is withdrawing\n /// @param controlledToken The type of collateral being withdrawn\n /// @param amount The amount of collateral to be withdrawn\n /// @return exitFee The exit fee\n /// @return burnedCredit The user's credit that was burned\n function calculateEarlyExitFee(\n address from,\n address controlledToken,\n uint256 amount\n ) external returns (uint256 exitFee, uint256 burnedCredit);\n\n /// @notice Estimates the amount of time it will take for a given amount of funds to accrue the given amount of credit.\n /// @param _principal The principal amount on which interest is accruing\n /// @param _interest The amount of interest that must accrue\n /// @return durationSeconds The duration of time it will take to accrue the given amount of interest, in seconds.\n function estimateCreditAccrualTime(\n address _controlledToken,\n uint256 _principal,\n uint256 _interest\n ) external view returns (uint256 durationSeconds);\n\n /// @notice Returns the credit balance for a given user. Not that this includes both minted credit and pending credit.\n /// @param user The user whose credit balance should be returned\n /// @return The balance of the users credit\n function balanceOfCredit(address user, address controlledToken)\n external\n returns (uint256);\n\n /// @notice Returns the credit rate of a controlled token\n /// @param controlledToken The controlled token to retrieve the credit rates for\n /// @return creditLimitMantissa The credit limit fraction. This number is used to calculate both the credit limit and early exit fee.\n /// @return creditRateMantissa The credit rate. This is the amount of tokens that accrue per second.\n function creditPlanOf(address controlledToken)\n external\n view\n returns (uint128 creditLimitMantissa, uint128 creditRateMantissa);\n\n /// @dev Returns the address of the underlying ERC20 asset\n /// @return The address of the asset\n function token() external view returns (address);\n\n /// @notice An array of the Tokens controlled by the Prize Pool (ie. Tickets, Sponsorship)\n /// @return An array of controlled token addresses\n function tokens() external view returns (address[] memory);\n\n /// @notice The total of all controlled tokens and timelock.\n /// @return The current total of all tokens and timelock.\n function accountedBalance() external view returns (uint256);\n}\n" + }, + "contracts/shared/interfaces/IComptroller.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IComptroller {\n /*** Assets You Are In ***/\n\n function enterMarkets(address[] calldata cTokens)\n external\n returns (uint256[] memory);\n\n function exitMarket(address cToken) external returns (uint256);\n\n /*** Policy Hooks ***/\n\n /**\n * @notice Checks if the account should be allowed to mint tokens in the given market\n * @param cToken The market to verify the mint against\n * @param minter The account which would get the minted tokens\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\n */\n function mintAllowed(\n address cToken,\n address minter,\n uint256 mintAmount\n ) external returns (uint256);\n\n /**\n * @notice Validates mint and reverts on rejection. May emit logs.\n * @param cToken Asset being minted\n * @param minter The address minting the tokens\n * @param mintAmount The amount of the underlying asset being minted\n * @param mintTokens The number of tokens being minted\n */\n function mintVerify(\n address cToken,\n address minter,\n uint256 mintAmount,\n uint256 mintTokens\n ) external;\n\n /**\n * @notice Checks if the account should be allowed to redeem tokens in the given market\n * @param cToken The market to verify the redeem against\n * @param redeemer The account which would redeem the tokens\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\n */\n function redeemAllowed(\n address cToken,\n address redeemer,\n uint256 redeemTokens\n ) external returns (uint256);\n\n /**\n * @notice Validates redeem and reverts on rejection. May emit logs.\n * @param cToken Asset being redeemed\n * @param redeemer The address redeeming the tokens\n * @param redeemAmount The amount of the underlying asset being redeemed\n * @param redeemTokens The number of tokens being redeemed\n */\n function redeemVerify(\n address cToken,\n address redeemer,\n uint256 redeemAmount,\n uint256 redeemTokens\n ) external;\n\n /**\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\n * @param cToken The market to verify the borrow against\n * @param borrower The account which would borrow the asset\n * @param borrowAmount The amount of underlying the account would borrow\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\n */\n function borrowAllowed(\n address cToken,\n address borrower,\n uint256 borrowAmount\n ) external returns (uint256);\n\n /**\n * @notice Validates borrow and reverts on rejection. May emit logs.\n * @param cToken Asset whose underlying is being borrowed\n * @param borrower The address borrowing the underlying\n * @param borrowAmount The amount of the underlying asset requested to borrow\n */\n function borrowVerify(\n address cToken,\n address borrower,\n uint256 borrowAmount\n ) external;\n\n /**\n * @notice Checks if the account should be allowed to repay a borrow in the given market\n * @param cToken The market to verify the repay against\n * @param payer The account which would repay the asset\n * @param borrower The account which would borrowed the asset\n * @param repayAmount The amount of the underlying asset the account would repay\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\n */\n function repayBorrowAllowed(\n address cToken,\n address payer,\n address borrower,\n uint256 repayAmount\n ) external returns (uint256);\n\n /**\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\n * @param cToken Asset being repaid\n * @param payer The address repaying the borrow\n * @param borrower The address of the borrower\n * @param repayAmount The amount of underlying being repaid\n * @param borrowerIndex the index of the borrower\n */\n function repayBorrowVerify(\n address cToken,\n address payer,\n address borrower,\n uint256 repayAmount,\n uint256 borrowerIndex\n ) external;\n\n /**\n * @notice Checks if the liquidation should be allowed to occur\n * @param cTokenBorrowed Asset which was borrowed by the borrower\n * @param cTokenCollateral Asset which was used as collateral and will be seized\n * @param liquidator The address repaying the borrow and seizing the collateral\n * @param borrower The address of the borrower\n * @param repayAmount The amount of underlying being repaid\n */\n function liquidateBorrowAllowed(\n address cTokenBorrowed,\n address cTokenCollateral,\n address liquidator,\n address borrower,\n uint256 repayAmount\n ) external returns (uint256);\n\n /**\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\n * @param cTokenBorrowed Asset which was borrowed by the borrower\n * @param cTokenCollateral Asset which was used as collateral and will be seized\n * @param liquidator The address repaying the borrow and seizing the collateral\n * @param borrower The address of the borrower\n * @param repayAmount The amount of underlying being repaid\n * @param seizeTokens The number of collateral tokens to seize\n */\n function liquidateBorrowVerify(\n address cTokenBorrowed,\n address cTokenCollateral,\n address liquidator,\n address borrower,\n uint256 repayAmount,\n uint256 seizeTokens\n ) external;\n\n /**\n * @notice Checks if the seizing of assets should be allowed to occur\n * @param cTokenCollateral Asset which was used as collateral and will be seized\n * @param cTokenBorrowed Asset which was borrowed by the borrower\n * @param liquidator The address repaying the borrow and seizing the collateral\n * @param borrower The address of the borrower\n * @param seizeTokens The number of collateral tokens to seize\n */\n function seizeAllowed(\n address cTokenCollateral,\n address cTokenBorrowed,\n address liquidator,\n address borrower,\n uint256 seizeTokens\n ) external returns (uint256);\n\n /**\n * @notice Validates seize and reverts on rejection. May emit logs.\n * @param cTokenCollateral Asset which was used as collateral and will be seized\n * @param cTokenBorrowed Asset which was borrowed by the borrower\n * @param liquidator The address repaying the borrow and seizing the collateral\n * @param borrower The address of the borrower\n * @param seizeTokens The number of collateral tokens to seize\n */\n function seizeVerify(\n address cTokenCollateral,\n address cTokenBorrowed,\n address liquidator,\n address borrower,\n uint256 seizeTokens\n ) external;\n\n /**\n * @notice Checks if the account should be allowed to transfer tokens in the given market\n * @param cToken The market to verify the transfer against\n * @param src The account which sources the tokens\n * @param dst The account which receives the tokens\n * @param transferTokens The number of cTokens to transfer\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\n */\n function transferAllowed(\n address cToken,\n address src,\n address dst,\n uint256 transferTokens\n ) external returns (uint256);\n\n /**\n * @notice Validates transfer and reverts on rejection. May emit logs.\n * @param cToken Asset being transferred\n * @param src The account which sources the tokens\n * @param dst The account which receives the tokens\n * @param transferTokens The number of cTokens to transfer\n */\n function transferVerify(\n address cToken,\n address src,\n address dst,\n uint256 transferTokens\n ) external;\n\n /**\n * @notice Claim all the comp accrued by holder in all markets\n * @param holder The address to claim COMP for\n */\n function claimComp(address holder) external;\n\n /**\n * @notice Claim all the comp accrued by holder in the specified markets\n * @param holder The address to claim COMP for\n * @param cTokens The list of markets to claim COMP in\n */\n function claimComp(address holder, address[] calldata cTokens) external;\n\n /**\n * @notice Claim all comp accrued by the holders\n * @param holders The addresses to claim COMP for\n * @param cTokens The list of markets to claim COMP in\n * @param borrowers Whether or not to claim COMP earned by borrowing\n * @param suppliers Whether or not to claim COMP earned by supplying\n */\n function claimComp(\n address[] calldata holders,\n address[] calldata cTokens,\n bool borrowers,\n bool suppliers\n ) external;\n\n /*** Liquidity/Liquidation Calculations ***/\n /**\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\n * @param cTokenBorrowed The address of the borrowed cToken\n * @param cTokenCollateral The address of the collateral cToken\n * @param repayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\n */\n function liquidateCalculateSeizeTokens(\n address cTokenBorrowed,\n address cTokenCollateral,\n uint256 repayAmount\n ) external view returns (uint256, uint256);\n\n /**\n * @notice Return the address of the COMP token\n * @return The address of COMP\n */\n function getCompAddress() external view returns (address);\n}\n" + }, + "@openzeppelin/contracts/utils/math/SafeCast.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\n * checks.\n *\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\n * easily result in undesired exploitation or bugs, since developers usually\n * assume that overflows raise errors. `SafeCast` restores this intuition by\n * reverting the transaction when such an operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n *\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\n * all math on `uint256` and `int256` and then downcasting.\n */\nlibrary SafeCast {\n /**\n * @dev Returns the downcasted uint128 from uint256, reverting on\n * overflow (when the input is greater than largest uint128).\n *\n * Counterpart to Solidity's `uint128` operator.\n *\n * Requirements:\n *\n * - input must fit into 128 bits\n */\n function toUint128(uint256 value) internal pure returns (uint128) {\n require(value < 2**128, \"SafeCast: value doesn\\'t fit in 128 bits\");\n return uint128(value);\n }\n\n /**\n * @dev Returns the downcasted uint64 from uint256, reverting on\n * overflow (when the input is greater than largest uint64).\n *\n * Counterpart to Solidity's `uint64` operator.\n *\n * Requirements:\n *\n * - input must fit into 64 bits\n */\n function toUint64(uint256 value) internal pure returns (uint64) {\n require(value < 2**64, \"SafeCast: value doesn\\'t fit in 64 bits\");\n return uint64(value);\n }\n\n /**\n * @dev Returns the downcasted uint32 from uint256, reverting on\n * overflow (when the input is greater than largest uint32).\n *\n * Counterpart to Solidity's `uint32` operator.\n *\n * Requirements:\n *\n * - input must fit into 32 bits\n */\n function toUint32(uint256 value) internal pure returns (uint32) {\n require(value < 2**32, \"SafeCast: value doesn\\'t fit in 32 bits\");\n return uint32(value);\n }\n\n /**\n * @dev Returns the downcasted uint16 from uint256, reverting on\n * overflow (when the input is greater than largest uint16).\n *\n * Counterpart to Solidity's `uint16` operator.\n *\n * Requirements:\n *\n * - input must fit into 16 bits\n */\n function toUint16(uint256 value) internal pure returns (uint16) {\n require(value < 2**16, \"SafeCast: value doesn\\'t fit in 16 bits\");\n return uint16(value);\n }\n\n /**\n * @dev Returns the downcasted uint8 from uint256, reverting on\n * overflow (when the input is greater than largest uint8).\n *\n * Counterpart to Solidity's `uint8` operator.\n *\n * Requirements:\n *\n * - input must fit into 8 bits.\n */\n function toUint8(uint256 value) internal pure returns (uint8) {\n require(value < 2**8, \"SafeCast: value doesn\\'t fit in 8 bits\");\n return uint8(value);\n }\n\n /**\n * @dev Converts a signed int256 into an unsigned uint256.\n *\n * Requirements:\n *\n * - input must be greater than or equal to 0.\n */\n function toUint256(int256 value) internal pure returns (uint256) {\n require(value >= 0, \"SafeCast: value must be positive\");\n return uint256(value);\n }\n\n /**\n * @dev Returns the downcasted int128 from int256, reverting on\n * overflow (when the input is less than smallest int128 or\n * greater than largest int128).\n *\n * Counterpart to Solidity's `int128` operator.\n *\n * Requirements:\n *\n * - input must fit into 128 bits\n *\n * _Available since v3.1._\n */\n function toInt128(int256 value) internal pure returns (int128) {\n require(value >= -2**127 && value < 2**127, \"SafeCast: value doesn\\'t fit in 128 bits\");\n return int128(value);\n }\n\n /**\n * @dev Returns the downcasted int64 from int256, reverting on\n * overflow (when the input is less than smallest int64 or\n * greater than largest int64).\n *\n * Counterpart to Solidity's `int64` operator.\n *\n * Requirements:\n *\n * - input must fit into 64 bits\n *\n * _Available since v3.1._\n */\n function toInt64(int256 value) internal pure returns (int64) {\n require(value >= -2**63 && value < 2**63, \"SafeCast: value doesn\\'t fit in 64 bits\");\n return int64(value);\n }\n\n /**\n * @dev Returns the downcasted int32 from int256, reverting on\n * overflow (when the input is less than smallest int32 or\n * greater than largest int32).\n *\n * Counterpart to Solidity's `int32` operator.\n *\n * Requirements:\n *\n * - input must fit into 32 bits\n *\n * _Available since v3.1._\n */\n function toInt32(int256 value) internal pure returns (int32) {\n require(value >= -2**31 && value < 2**31, \"SafeCast: value doesn\\'t fit in 32 bits\");\n return int32(value);\n }\n\n /**\n * @dev Returns the downcasted int16 from int256, reverting on\n * overflow (when the input is less than smallest int16 or\n * greater than largest int16).\n *\n * Counterpart to Solidity's `int16` operator.\n *\n * Requirements:\n *\n * - input must fit into 16 bits\n *\n * _Available since v3.1._\n */\n function toInt16(int256 value) internal pure returns (int16) {\n require(value >= -2**15 && value < 2**15, \"SafeCast: value doesn\\'t fit in 16 bits\");\n return int16(value);\n }\n\n /**\n * @dev Returns the downcasted int8 from int256, reverting on\n * overflow (when the input is less than smallest int8 or\n * greater than largest int8).\n *\n * Counterpart to Solidity's `int8` operator.\n *\n * Requirements:\n *\n * - input must fit into 8 bits.\n *\n * _Available since v3.1._\n */\n function toInt8(int256 value) internal pure returns (int8) {\n require(value >= -2**7 && value < 2**7, \"SafeCast: value doesn\\'t fit in 8 bits\");\n return int8(value);\n }\n\n /**\n * @dev Converts an unsigned uint256 into a signed int256.\n *\n * Requirements:\n *\n * - input must be less than or equal to maxInt256.\n */\n function toInt256(uint256 value) internal pure returns (int256) {\n require(value < 2**255, \"SafeCast: value doesn't fit in an int256\");\n return int256(value);\n }\n}\n" + }, + "contracts/price-aggregator/chainlink/ChainlinkLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\n// Storage\nimport {\n PriceAggStorageLib,\n ChainlinkAggStorage\n} from \"../../storage/price-aggregator.sol\";\n\nlibrary ChainlinkLib {\n function s() internal view returns (ChainlinkAggStorage storage) {\n return PriceAggStorageLib.store().chainlink;\n }\n\n /**\n * @notice It grabs the Chainlink Aggregator contract address for the token pair if it is supported.\n * @param src Source token address.\n * @param dst Destination token address.\n * @return aggregator The Chainlink Aggregator address.\n * @return found whether or not the ChainlinkAggregator exists.\n * @return inverse whether or not the values from the Aggregator should be considered inverted.\n */\n function aggregatorFor(address src, address dst)\n internal\n view\n returns (\n address aggregator,\n bool found,\n bool inverse\n )\n {\n aggregator = s().aggregators[src][dst];\n if (aggregator != address(0)) {\n found = true;\n } else {\n aggregator = s().aggregators[dst][src];\n if (aggregator != address(0)) {\n found = true;\n inverse = true;\n }\n }\n }\n\n /**\n * @dev Checks if a token address is supported by Chainlink (has a pair aggregator).\n * @param token Token address to check if is supported.\n * @return isSupported_ true if there is at least 1 pair aggregator for {token}\n */\n function isTokenSupported(address token)\n internal\n view\n returns (bool isSupported_)\n {\n isSupported_ = EnumerableSet.contains(s().supportedTokens, token);\n }\n}\n" + }, + "contracts/shared/libraries/CompoundLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Interfaces\nimport { ICErc20 } from \"../interfaces/ICErc20.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../storage/app.sol\";\n\n/**\n * @notice Utility library to calculate the value of a Compound cToken and its underlying asset.\n *\n * @author develop@teller.finance\n */\nlibrary CompoundLib {\n /**\n * @dev Compounds exchange rate is scaled by 18 decimals (10^18)\n */\n uint256 internal constant EXCHANGE_RATE_SCALE = 1e18;\n\n function exchangeRate(address cToken) internal view returns (uint256) {\n return ICErc20(cToken).exchangeRateStored();\n }\n\n /**\n * @notice Takes an amount of the Compound asset and calculates the underlying amount using the stored exchange rate.\n * @param cToken Address of the Compound token.\n * @param cTokenAmount Amount of the Compound asset.\n * @return value of the Compound token amount in underlying tokens.\n */\n function valueInUnderlying(address cToken, uint256 cTokenAmount)\n internal\n view\n returns (uint256)\n {\n return\n (cTokenAmount * ICErc20(cToken).exchangeRateStored()) /\n EXCHANGE_RATE_SCALE;\n }\n\n /**\n * @notice Takes an amount of the underlying Compound asset and calculates the cToken amount using the stored exchange rate.\n * @param cToken Address of the Compound token.\n * @param underlyingAmount Amount of the underlying asset for the Compound token.\n * @return value of the underlying amount in Compound tokens.\n */\n function valueOfUnderlying(address cToken, uint256 underlyingAmount)\n internal\n view\n returns (uint256)\n {\n return\n (underlyingAmount * EXCHANGE_RATE_SCALE) /\n ICErc20(cToken).exchangeRateStored();\n }\n\n function isCompoundToken(address token) internal view returns (bool) {\n return AppStorageLib.store().cTokenRegistry[token];\n }\n\n /**\n * @notice Tests the {underlying} function on the cToken and assumes its WETH otherwise.\n * @dev CETH is the only Compound token that does not support the {underlying} function.\n * @param cToken address of the compound token\n * @return address of the underlying cToken\n */\n function getUnderlying(address cToken) internal view returns (address) {\n (bool success, bytes memory data) =\n cToken.staticcall(abi.encode(ICErc20.underlying.selector));\n if (success) {\n return abi.decode(data, (address));\n }\n\n return AppStorageLib.store().assetAddresses[\"WETH\"];\n }\n}\n" + }, + "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./AggregatorInterface.sol\";\nimport \"./AggregatorV3Interface.sol\";\n\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface\n{\n}\n" + }, + "@openzeppelin/contracts/token/ERC20/ERC20.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IERC20.sol\";\nimport \"./extensions/IERC20Metadata.sol\";\nimport \"../../utils/Context.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * We have followed general OpenZeppelin guidelines: functions revert instead\n * of returning `false` on failure. This behavior is nonetheless conventional\n * and does not conflict with the expectations of ERC20 applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20 is Context, IERC20, IERC20Metadata {\n mapping (address => uint256) private _balances;\n\n mapping (address => mapping (address => uint256)) private _allowances;\n\n uint256 private _totalSupply;\n\n string private _name;\n string private _symbol;\n\n /**\n * @dev Sets the values for {name} and {symbol}.\n *\n * The defaut value of {decimals} is 18. To select a different value for\n * {decimals} you should overload it.\n *\n * All two of these values are immutable: they can only be set once during\n * construction.\n */\n constructor (string memory name_, string memory symbol_) {\n _name = name_;\n _symbol = symbol_;\n }\n\n /**\n * @dev Returns the name of the token.\n */\n function name() public view virtual override returns (string memory) {\n return _name;\n }\n\n /**\n * @dev Returns the symbol of the token, usually a shorter version of the\n * name.\n */\n function symbol() public view virtual override returns (string memory) {\n return _symbol;\n }\n\n /**\n * @dev Returns the number of decimals used to get its user representation.\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\n *\n * Tokens usually opt for a value of 18, imitating the relationship between\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\n * overridden;\n *\n * NOTE: This information is only used for _display_ purposes: it in\n * no way affects any of the arithmetic of the contract, including\n * {IERC20-balanceOf} and {IERC20-transfer}.\n */\n function decimals() public view virtual override returns (uint8) {\n return 18;\n }\n\n /**\n * @dev See {IERC20-totalSupply}.\n */\n function totalSupply() public view virtual override returns (uint256) {\n return _totalSupply;\n }\n\n /**\n * @dev See {IERC20-balanceOf}.\n */\n function balanceOf(address account) public view virtual override returns (uint256) {\n return _balances[account];\n }\n\n /**\n * @dev See {IERC20-transfer}.\n *\n * Requirements:\n *\n * - `recipient` cannot be the zero address.\n * - the caller must have a balance of at least `amount`.\n */\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\n _transfer(_msgSender(), recipient, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-allowance}.\n */\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\n return _allowances[owner][spender];\n }\n\n /**\n * @dev See {IERC20-approve}.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\n _approve(_msgSender(), spender, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-transferFrom}.\n *\n * Emits an {Approval} event indicating the updated allowance. This is not\n * required by the EIP. See the note at the beginning of {ERC20}.\n *\n * Requirements:\n *\n * - `sender` and `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n * - the caller must have allowance for ``sender``'s tokens of at least\n * `amount`.\n */\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\n _transfer(sender, recipient, amount);\n\n uint256 currentAllowance = _allowances[sender][_msgSender()];\n require(currentAllowance >= amount, \"ERC20: transfer amount exceeds allowance\");\n _approve(sender, _msgSender(), currentAllowance - amount);\n\n return true;\n }\n\n /**\n * @dev Atomically increases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\n return true;\n }\n\n /**\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `spender` must have allowance for the caller of at least\n * `subtractedValue`.\n */\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n uint256 currentAllowance = _allowances[_msgSender()][spender];\n require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\n\n return true;\n }\n\n /**\n * @dev Moves tokens `amount` from `sender` to `recipient`.\n *\n * This is internal function is equivalent to {transfer}, and can be used to\n * e.g. implement automatic token fees, slashing mechanisms, etc.\n *\n * Emits a {Transfer} event.\n *\n * Requirements:\n *\n * - `sender` cannot be the zero address.\n * - `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n */\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\n require(sender != address(0), \"ERC20: transfer from the zero address\");\n require(recipient != address(0), \"ERC20: transfer to the zero address\");\n\n _beforeTokenTransfer(sender, recipient, amount);\n\n uint256 senderBalance = _balances[sender];\n require(senderBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n _balances[sender] = senderBalance - amount;\n _balances[recipient] += amount;\n\n emit Transfer(sender, recipient, amount);\n }\n\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n * the total supply.\n *\n * Emits a {Transfer} event with `from` set to the zero address.\n *\n * Requirements:\n *\n * - `to` cannot be the zero address.\n */\n function _mint(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: mint to the zero address\");\n\n _beforeTokenTransfer(address(0), account, amount);\n\n _totalSupply += amount;\n _balances[account] += amount;\n emit Transfer(address(0), account, amount);\n }\n\n /**\n * @dev Destroys `amount` tokens from `account`, reducing the\n * total supply.\n *\n * Emits a {Transfer} event with `to` set to the zero address.\n *\n * Requirements:\n *\n * - `account` cannot be the zero address.\n * - `account` must have at least `amount` tokens.\n */\n function _burn(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: burn from the zero address\");\n\n _beforeTokenTransfer(account, address(0), amount);\n\n uint256 accountBalance = _balances[account];\n require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n _balances[account] = accountBalance - amount;\n _totalSupply -= amount;\n\n emit Transfer(account, address(0), amount);\n }\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n *\n * This internal function is equivalent to `approve`, and can be used to\n * e.g. set automatic allowances for certain subsystems, etc.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `owner` cannot be the zero address.\n * - `spender` cannot be the zero address.\n */\n function _approve(address owner, address spender, uint256 amount) internal virtual {\n require(owner != address(0), \"ERC20: approve from the zero address\");\n require(spender != address(0), \"ERC20: approve to the zero address\");\n\n _allowances[owner][spender] = amount;\n emit Approval(owner, spender, amount);\n }\n\n /**\n * @dev Hook that is called before any transfer of tokens. This includes\n * minting and burning.\n *\n * Calling conditions:\n *\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n * will be to transferred to `to`.\n * - when `from` is zero, `amount` tokens will be minted for `to`.\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n * - `from` and `to` are never both zero.\n *\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n */\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\n}\n" + }, + "contracts/storage/price-aggregator.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\nstruct ChainlinkAggStorage {\n // Maps source token => destination token => Chainlink Aggregator\n mapping(address => mapping(address => address)) aggregators;\n // Maps token address to number of supported Chainlink pairs\n mapping(address => uint256) pairCount;\n // Stores set of token addresses supported by Chainlink\n EnumerableSet.AddressSet supportedTokens;\n}\n\nstruct PriceAggStorage {\n ChainlinkAggStorage chainlink;\n}\n\nbytes32 constant PRICE_AGG_STORAGE_POS = keccak256(\n \"teller.price.aggregator.storage\"\n);\n\nlibrary PriceAggStorageLib {\n function store() internal pure returns (PriceAggStorage storage s) {\n bytes32 pos = PRICE_AGG_STORAGE_POS;\n assembly {\n s.slot := pos\n }\n }\n}\n" + }, + "@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface AggregatorInterface {\n function latestAnswer()\n external\n view\n returns (\n int256\n );\n \n function latestTimestamp()\n external\n view\n returns (\n uint256\n );\n\n function latestRound()\n external\n view\n returns (\n uint256\n );\n\n function getAnswer(\n uint256 roundId\n )\n external\n view\n returns (\n int256\n );\n\n function getTimestamp(\n uint256 roundId\n )\n external\n view\n returns (\n uint256\n );\n\n event AnswerUpdated(\n int256 indexed current,\n uint256 indexed roundId,\n uint256 updatedAt\n );\n\n event NewRound(\n uint256 indexed roundId,\n address indexed startedBy,\n uint256 startedAt\n );\n}\n" + }, + "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface AggregatorV3Interface {\n\n function decimals()\n external\n view\n returns (\n uint8\n );\n\n function description()\n external\n view\n returns (\n string memory\n );\n\n function version()\n external\n view\n returns (\n uint256\n );\n\n // getRoundData and latestRoundData should both raise \"No data present\"\n // if they do not have data to report, instead of returning unset values\n // which could be misinterpreted as actual reported values.\n function getRoundData(\n uint80 _roundId\n )\n external\n view\n returns (\n uint80 roundId,\n int256 answer,\n uint256 startedAt,\n uint256 updatedAt,\n uint80 answeredInRound\n );\n\n function latestRoundData()\n external\n view\n returns (\n uint80 roundId,\n int256 answer,\n uint256 startedAt,\n uint256 updatedAt,\n uint80 answeredInRound\n );\n\n}\n" + }, + "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n /**\n * @dev Returns the name of the token.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the symbol of the token.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the decimals places of the token.\n */\n function decimals() external view returns (uint8);\n}\n" + }, + "contracts/settings/pausable/PausableMods.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AppStorageLib } from \"../../storage/app.sol\";\n\nabstract contract PausableMods {\n /**\n * @notice Requires that the state of the protocol AND the given facet id equal {state}.\n * @param id id of the facet to check if is paused.\n * @param state Boolean that the protocol AND facet should be in.\n */\n modifier paused(bytes32 id, bool state) {\n require(\n __isPaused(\"\") == state && __isPaused(id) == state,\n __pausedMessage(state)\n );\n _;\n }\n\n /**\n * @dev Checks if the given id is paused.\n * @param id Encoded id of the facet to check if is paused.\n * @return the bool to tell us if the facet is paused (true) or not (false)\n */\n function __isPaused(bytes32 id) private view returns (bool) {\n return AppStorageLib.store().paused[id];\n }\n\n /**\n * @dev Gets the message that should be reverted with given a state it should be in.\n * @param state Boolean that an id should be in.\n * @return a message stating whether the facet is paused or not\n */\n function __pausedMessage(bool state) private pure returns (string memory) {\n return state ? \"Pausable: not paused\" : \"Pausable: paused\";\n }\n}\n" + }, + "contracts/contexts2/access-control/reentry/ReentryMods.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlStorageLib, AccessControlStorage } from \"../storage.sol\";\n\nabstract contract ReentryMods {\n modifier nonReentry(bytes32 id) {\n AccessControlStorage storage s = AccessControlStorageLib.store();\n require(!s.entered[id], \"AccessControl: reentered\");\n s.entered[id] = true;\n _;\n s.entered[id] = false;\n }\n}\n" + }, + "contracts/lending/ttoken/ITToken.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport {\n ERC20Upgradeable\n} from \"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\";\nimport { ERC20 } from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\nimport {\n RolesFacet\n} from \"../../contexts2/access-control/roles/RolesFacet.sol\";\n\n/**\n * @notice This contract acts as an interface for the Teller token (TToken).\n *\n * @author develop@teller.finance\n */\nabstract contract ITToken is ERC20Upgradeable, RolesFacet {\n /**\n * @notice This event is emitted when a user deposits tokens into the pool.\n */\n event Mint(\n address indexed sender,\n uint256 tTokenAmount,\n uint256 underlyingAmount\n );\n\n /**\n * @notice This event is emitted when a user withdraws tokens from the pool.\n */\n event Redeem(\n address indexed sender,\n uint256 tTokenAmount,\n uint256 underlyingAmount\n );\n\n /**\n * @notice The token that is the underlying assets for this Teller token.\n * @return ERC20 token\n */\n function underlying() external view virtual returns (ERC20);\n\n /**\n * @notice The balance of an {account} denoted in underlying value.\n * @param account Address to calculate the underlying balance.\n * @return balance_ the balance of the account\n */\n function balanceOfUnderlying(address account)\n external\n virtual\n returns (uint256 balance_);\n\n /**\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\n * @return rate_ The current exchange rate.\n */\n function exchangeRate() external virtual returns (uint256 rate_);\n\n /**\n * @notice It calculates the total supply of the underlying asset.\n * @return totalSupply_ the total supply denoted in the underlying asset.\n */\n function totalUnderlyingSupply()\n external\n virtual\n returns (uint256 totalSupply_);\n\n /**\n * @notice It calculates the market state values across a given market.\n * @notice Returns values that represent the global state across the market.\n * @return totalSupplied Total amount of the underlying asset supplied.\n * @return totalBorrowed Total amount borrowed through loans.\n * @return totalRepaid The total amount repaid till the current timestamp.\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\n * @return totalOnLoan Total amount currently deployed in loans.\n */\n function getMarketState()\n external\n virtual\n returns (\n uint256 totalSupplied,\n uint256 totalBorrowed,\n uint256 totalRepaid,\n uint256 totalInterestRepaid,\n uint256 totalOnLoan\n );\n\n /**\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\n * @return tvl_ The value locked in the pool.\n *\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\n */\n function currentTVL() external virtual returns (uint256 tvl_);\n\n /**\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\n * @param newLoanAmount the new loan amount to consider the StD ratio.\n * @return ratio_ Whether debt ratio for lending pool is valid.\n */\n function debtRatioFor(uint256 newLoanAmount)\n external\n virtual\n returns (uint16 ratio_);\n \n\n /**\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\n * @param recipient The account to send the funds to.\n * @param amount Funds requested to fulfill the loan.\n */\n function fundLoan(address recipient, uint256 amount) external virtual;\n\n /**\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\n * @param interestAmount Interest value paid into the pool from a loan.\n */\n function repayLoan(uint256 amount, uint256 interestAmount) external virtual;\n\n /**\n * @notice Increase account supply of specified token amount.\n * @param amount The amount of underlying tokens to use to mint.\n * @return mintAmount_ the amount minted of the specified token\n */\n function mint(uint256 amount)\n external\n virtual\n returns (uint256 mintAmount_);\n\n /**\n * @notice Redeem supplied Teller token underlying value.\n * @param amount The amount of Teller tokens to redeem.\n */\n function redeem(uint256 amount) external virtual;\n\n /**\n * @notice Redeem supplied underlying value.\n * @param amount The amount of underlying tokens to redeem.\n */\n function redeemUnderlying(uint256 amount) external virtual;\n\n /**\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\n *\n * See {TTokenStrategy}.\n */\n function rebalance() external virtual;\n\n /**\n * @notice Sets a new strategy to use for balancing funds.\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\n * @param initData Optional data to initialize the strategy.\n *\n * Requirements:\n * - Sender must have ADMIN role\n */\n function setStrategy(address strategy, bytes calldata initData)\n external\n virtual;\n\n /**\n * @notice Gets the strategy used for balancing funds.\n * @return address of the strategy contract\n */\n function getStrategy() external view virtual returns (address);\n\n /**\n * @notice Sets the restricted state of the platform.\n * @param state boolean value that resembles the platform's state\n */\n function restrict(bool state) external virtual;\n\n /**\n * @notice it initializes the Teller Token\n * @param admin address of the admin to the respective Teller Token\n * @param underlying address of the ERC20 token\n */\n function initialize(address admin, address underlying) external virtual;\n}\n" + }, + "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\nimport \"../../../utils/Address.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n using Address for address;\n\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n }\n\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\n }\n\n /**\n * @dev Deprecated. This function has issues similar to the ones found in\n * {IERC20-approve}, and its usage is discouraged.\n *\n * Whenever possible, use {safeIncreaseAllowance} and\n * {safeDecreaseAllowance} instead.\n */\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\n // safeApprove should only be called when setting an initial allowance,\n // or when resetting it to zero. To increase and decrease it, use\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\n // solhint-disable-next-line max-line-length\n require((value == 0) || (token.allowance(address(this), spender) == 0),\n \"SafeERC20: approve from non-zero to non-zero allowance\"\n );\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\n }\n\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n uint256 newAllowance = token.allowance(address(this), spender) + value;\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n }\n\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n unchecked {\n uint256 oldAllowance = token.allowance(address(this), spender);\n require(oldAllowance >= value, \"SafeERC20: decreased allowance below zero\");\n uint256 newAllowance = oldAllowance - value;\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n }\n }\n\n /**\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n * on the return value: the return value is optional (but if data is returned, it must not be false).\n * @param token The token targeted by the call.\n * @param data The call data (encoded using abi.encode or one of its variants).\n */\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\n // the target address contains contract code and also asserts for success in the low-level call.\n\n bytes memory returndata = address(token).functionCall(data, \"SafeERC20: low-level call failed\");\n if (returndata.length > 0) { // Return data is optional\n // solhint-disable-next-line max-line-length\n require(abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n }\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20Upgradeable.sol\";\nimport \"../../../utils/AddressUpgradeable.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20Upgradeable {\n using AddressUpgradeable for address;\n\n function safeTransfer(IERC20Upgradeable token, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n }\n\n function safeTransferFrom(IERC20Upgradeable token, address from, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\n }\n\n /**\n * @dev Deprecated. This function has issues similar to the ones found in\n * {IERC20-approve}, and its usage is discouraged.\n *\n * Whenever possible, use {safeIncreaseAllowance} and\n * {safeDecreaseAllowance} instead.\n */\n function safeApprove(IERC20Upgradeable token, address spender, uint256 value) internal {\n // safeApprove should only be called when setting an initial allowance,\n // or when resetting it to zero. To increase and decrease it, use\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\n // solhint-disable-next-line max-line-length\n require((value == 0) || (token.allowance(address(this), spender) == 0),\n \"SafeERC20: approve from non-zero to non-zero allowance\"\n );\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\n }\n\n function safeIncreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\n uint256 newAllowance = token.allowance(address(this), spender) + value;\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n }\n\n function safeDecreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\n unchecked {\n uint256 oldAllowance = token.allowance(address(this), spender);\n require(oldAllowance >= value, \"SafeERC20: decreased allowance below zero\");\n uint256 newAllowance = oldAllowance - value;\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n }\n }\n\n /**\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n * on the return value: the return value is optional (but if data is returned, it must not be false).\n * @param token The token targeted by the call.\n * @param data The call data (encoded using abi.encode or one of its variants).\n */\n function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\n // the target address contains contract code and also asserts for success in the low-level call.\n\n bytes memory returndata = address(token).functionCall(data, \"SafeERC20: low-level call failed\");\n if (returndata.length > 0) { // Return data is optional\n // solhint-disable-next-line max-line-length\n require(abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n }\n }\n}\n" + }, + "contracts/lending/libraries/LendingLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport { NumbersLib } from \"../../shared/libraries/NumbersLib.sol\";\n\n// Interfaces\nimport { ITToken } from \"../ttoken/ITToken.sol\";\n\n// Storage\nimport { MarketStorageLib, MarketStorage } from \"../../storage/market.sol\";\n\nlibrary LendingLib {\n bytes32 internal constant ID = keccak256(\"LENDING\");\n\n function s() internal pure returns (MarketStorage storage) {\n return MarketStorageLib.store();\n }\n\n function tToken(address asset) internal view returns (ITToken tToken_) {\n tToken_ = s().tTokens[asset];\n }\n}" + }, + "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IERC20Upgradeable.sol\";\nimport \"./extensions/IERC20MetadataUpgradeable.sol\";\nimport \"../../utils/ContextUpgradeable.sol\";\nimport \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * We have followed general OpenZeppelin guidelines: functions revert instead\n * of returning `false` on failure. This behavior is nonetheless conventional\n * and does not conflict with the expectations of ERC20 applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\n mapping (address => uint256) private _balances;\n\n mapping (address => mapping (address => uint256)) private _allowances;\n\n uint256 private _totalSupply;\n\n string private _name;\n string private _symbol;\n\n /**\n * @dev Sets the values for {name} and {symbol}.\n *\n * The defaut value of {decimals} is 18. To select a different value for\n * {decimals} you should overload it.\n *\n * All two of these values are immutable: they can only be set once during\n * construction.\n */\n function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\n __Context_init_unchained();\n __ERC20_init_unchained(name_, symbol_);\n }\n\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\n _name = name_;\n _symbol = symbol_;\n }\n\n /**\n * @dev Returns the name of the token.\n */\n function name() public view virtual override returns (string memory) {\n return _name;\n }\n\n /**\n * @dev Returns the symbol of the token, usually a shorter version of the\n * name.\n */\n function symbol() public view virtual override returns (string memory) {\n return _symbol;\n }\n\n /**\n * @dev Returns the number of decimals used to get its user representation.\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\n *\n * Tokens usually opt for a value of 18, imitating the relationship between\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\n * overridden;\n *\n * NOTE: This information is only used for _display_ purposes: it in\n * no way affects any of the arithmetic of the contract, including\n * {IERC20-balanceOf} and {IERC20-transfer}.\n */\n function decimals() public view virtual override returns (uint8) {\n return 18;\n }\n\n /**\n * @dev See {IERC20-totalSupply}.\n */\n function totalSupply() public view virtual override returns (uint256) {\n return _totalSupply;\n }\n\n /**\n * @dev See {IERC20-balanceOf}.\n */\n function balanceOf(address account) public view virtual override returns (uint256) {\n return _balances[account];\n }\n\n /**\n * @dev See {IERC20-transfer}.\n *\n * Requirements:\n *\n * - `recipient` cannot be the zero address.\n * - the caller must have a balance of at least `amount`.\n */\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\n _transfer(_msgSender(), recipient, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-allowance}.\n */\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\n return _allowances[owner][spender];\n }\n\n /**\n * @dev See {IERC20-approve}.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\n _approve(_msgSender(), spender, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-transferFrom}.\n *\n * Emits an {Approval} event indicating the updated allowance. This is not\n * required by the EIP. See the note at the beginning of {ERC20}.\n *\n * Requirements:\n *\n * - `sender` and `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n * - the caller must have allowance for ``sender``'s tokens of at least\n * `amount`.\n */\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\n _transfer(sender, recipient, amount);\n\n uint256 currentAllowance = _allowances[sender][_msgSender()];\n require(currentAllowance >= amount, \"ERC20: transfer amount exceeds allowance\");\n _approve(sender, _msgSender(), currentAllowance - amount);\n\n return true;\n }\n\n /**\n * @dev Atomically increases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\n return true;\n }\n\n /**\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `spender` must have allowance for the caller of at least\n * `subtractedValue`.\n */\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n uint256 currentAllowance = _allowances[_msgSender()][spender];\n require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\n\n return true;\n }\n\n /**\n * @dev Moves tokens `amount` from `sender` to `recipient`.\n *\n * This is internal function is equivalent to {transfer}, and can be used to\n * e.g. implement automatic token fees, slashing mechanisms, etc.\n *\n * Emits a {Transfer} event.\n *\n * Requirements:\n *\n * - `sender` cannot be the zero address.\n * - `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n */\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\n require(sender != address(0), \"ERC20: transfer from the zero address\");\n require(recipient != address(0), \"ERC20: transfer to the zero address\");\n\n _beforeTokenTransfer(sender, recipient, amount);\n\n uint256 senderBalance = _balances[sender];\n require(senderBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n _balances[sender] = senderBalance - amount;\n _balances[recipient] += amount;\n\n emit Transfer(sender, recipient, amount);\n }\n\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n * the total supply.\n *\n * Emits a {Transfer} event with `from` set to the zero address.\n *\n * Requirements:\n *\n * - `to` cannot be the zero address.\n */\n function _mint(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: mint to the zero address\");\n\n _beforeTokenTransfer(address(0), account, amount);\n\n _totalSupply += amount;\n _balances[account] += amount;\n emit Transfer(address(0), account, amount);\n }\n\n /**\n * @dev Destroys `amount` tokens from `account`, reducing the\n * total supply.\n *\n * Emits a {Transfer} event with `to` set to the zero address.\n *\n * Requirements:\n *\n * - `account` cannot be the zero address.\n * - `account` must have at least `amount` tokens.\n */\n function _burn(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: burn from the zero address\");\n\n _beforeTokenTransfer(account, address(0), amount);\n\n uint256 accountBalance = _balances[account];\n require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n _balances[account] = accountBalance - amount;\n _totalSupply -= amount;\n\n emit Transfer(account, address(0), amount);\n }\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n *\n * This internal function is equivalent to `approve`, and can be used to\n * e.g. set automatic allowances for certain subsystems, etc.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `owner` cannot be the zero address.\n * - `spender` cannot be the zero address.\n */\n function _approve(address owner, address spender, uint256 amount) internal virtual {\n require(owner != address(0), \"ERC20: approve from the zero address\");\n require(spender != address(0), \"ERC20: approve to the zero address\");\n\n _allowances[owner][spender] = amount;\n emit Approval(owner, spender, amount);\n }\n\n /**\n * @dev Hook that is called before any transfer of tokens. This includes\n * minting and burning.\n *\n * Calling conditions:\n *\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n * will be to transferred to `to`.\n * - when `from` is zero, `amount` tokens will be minted for `to`.\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n * - `from` and `to` are never both zero.\n *\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n */\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\n uint256[45] private __gap;\n}\n" + }, + "contracts/contexts2/access-control/roles/RolesFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { RolesMods } from \"./RolesMods.sol\";\nimport { RolesLib } from \"./RolesLib.sol\";\nimport { ADMIN } from \"../../../shared/roles.sol\";\n\ncontract RolesFacet is RolesMods {\n /**\n * @notice Checks if an account has a specific role.\n * @param role Encoding of the role to check.\n * @param account Address to check the {role} for.\n */\n function hasRole(bytes32 role, address account)\n external\n view\n returns (bool)\n {\n return RolesLib.hasRole(role, account);\n }\n\n /**\n * @notice Grants an account a new role.\n * @param role Encoding of the role to give.\n * @param account Address to give the {role} to.\n *\n * Requirements:\n * - Sender must be role admin.\n */\n function grantRole(bytes32 role, address account)\n external\n authorized(ADMIN, msg.sender)\n {\n RolesLib.grantRole(role, account);\n }\n\n /**\n * @notice Removes a role from an account.\n * @param role Encoding of the role to remove.\n * @param account Address to remove the {role} from.\n *\n * Requirements:\n * - Sender must be role admin.\n */\n function revokeRole(bytes32 role, address account)\n external\n authorized(ADMIN, msg.sender)\n {\n RolesLib.revokeRole(role, account);\n }\n\n /**\n * @notice Removes a role from the sender.\n * @param role Encoding of the role to remove.\n */\n function renounceRole(bytes32 role) external {\n RolesLib.revokeRole(role, msg.sender);\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20Upgradeable {\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address recipient, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\n\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20Upgradeable.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\n /**\n * @dev Returns the name of the token.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the symbol of the token.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the decimals places of the token.\n */\n function decimals() external view returns (uint8);\n}\n" + }, + "contracts/shared/libraries/NumbersLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/**\n * @dev Utility library for uint256 numbers\n *\n * @author develop@teller.finance\n */\nlibrary NumbersLib {\n /**\n * @dev It represents 100% with 2 decimal places.\n */\n uint256 internal constant ONE_HUNDRED_PERCENT = 10000;\n\n /**\n * @notice Returns a percentage value of a number.\n * @param self The number to get a percentage of.\n * @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).\n */\n function percent(uint256 self, uint16 percentage)\n internal\n pure\n returns (uint256)\n {\n return (self * uint256(percentage)) / ONE_HUNDRED_PERCENT;\n }\n\n function percent(int256 self, uint256 percentage)\n internal\n pure\n returns (int256)\n {\n return (self * int256(percentage)) / int256(ONE_HUNDRED_PERCENT);\n }\n\n /**\n * @notice it returns the absolute number of a specified parameter\n * @param self the number to be returned in it's absolute\n * @return the absolute number\n */\n function abs(int256 self) internal pure returns (uint256) {\n return self >= 0 ? uint256(self) : uint256(-1 * self);\n }\n\n /**\n * @notice Returns a ratio percentage of {num1} to {num2}.\n * @param num1 The number used to get the ratio for.\n * @param num2 The number used to get the ratio from.\n * @return Ratio percentage with 2 decimal places (10000 = 100%).\n */\n function ratioOf(uint256 num1, uint256 num2)\n internal\n pure\n returns (uint16)\n {\n return num2 == 0 ? 0 : uint16((num1 * ONE_HUNDRED_PERCENT) / num2);\n }\n}\n" + }, + "contracts/storage/market.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport { Counters } from \"@openzeppelin/contracts/utils/Counters.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\nimport \"../shared/libraries/NumbersList.sol\";\n\n// Interfaces\nimport { ILoansEscrow } from \"../escrow/escrow/ILoansEscrow.sol\";\nimport { ICollateralEscrow } from \"../market/collateral/ICollateralEscrow.sol\";\nimport { ITToken } from \"../lending/ttoken/ITToken.sol\";\n\n// DEPRECATED\nstruct LoanTerms {\n // Max size the loan max be taken out with\n uint256 maxLoanAmount;\n // The timestamp at which the loan terms expire, after which if the loan is not yet active, cannot be taken out\n uint32 termsExpiry;\n}\n\nenum LoanStatus { NonExistent, TermsSet, Active, Closed, Liquidated }\n\nstruct Loan {\n // Account that owns the loan\n address payable borrower;\n // The asset lent out for the loan\n address lendingToken;\n // The token used as collateral for the loan\n address collateralToken;\n // The total amount of the loan size taken out\n uint256 borrowedAmount;\n // The id of the loan for internal tracking\n uint128 id;\n // How long in seconds until the loan must be repaid\n uint32 duration;\n // The timestamp at which the loan became active\n uint32 loanStartTime;\n // The interest rate given for repaying the loan\n uint16 interestRate;\n // Ratio used to determine amount of collateral required based on the collateral asset price\n uint16 collateralRatio;\n // The status of the loan\n LoanStatus status;\n}\n\nstruct LoanDebt {\n // The total amount of the loan taken out by the borrower, reduces on loan repayments\n uint256 principalOwed;\n // The total interest owed by the borrower for the loan, reduces on loan repayments\n uint256 interestOwed;\n}\n\nstruct LoanRequest {\n LoanUserRequest request;\n LoanConsensusResponse[] responses;\n}\n\n/**\n * @notice Borrower request object to take out a loan\n * @param borrower The wallet address of the borrower\n * @param assetAddress The address of the asset for the requested loan\n * @param amount The amount of tokens requested by the borrower for the loan\n * @param requestNonce The nonce of the borrower wallet address required for authentication\n * @param duration The length of time in seconds that the loan has been requested for\n * @param requestTime The timestamp at which the loan was requested\n */\nstruct LoanUserRequest {\n address payable borrower;\n address assetAddress;\n uint256 amount;\n uint32 requestNonce;\n uint32 duration;\n uint32 requestTime;\n}\n\n/**\n * @notice Borrower response object to take out a loan\n * @param signer The wallet address of the signer validating the interest request of the lender\n * @param assetAddress The address of the asset for the requested loan\n * @param maxLoanAmount The largest amount of tokens that can be taken out in the loan by the borrower\n * @param responseTime The timestamp at which the response was sent\n * @param interestRate The signed interest rate generated by the signer's Credit Risk Algorithm (CRA)\n * @param collateralRatio The ratio of collateral to loan amount that is generated by the signer's Credit Risk Algorithm (CRA)\n * @param signature The signature generated by the signer in the format of the above Signature struct\n */\nstruct LoanConsensusResponse {\n address signer;\n address assetAddress;\n uint256 maxLoanAmount;\n uint32 responseTime;\n uint16 interestRate;\n uint16 collateralRatio;\n Signature signature;\n}\n\n/**\n * @notice Represents a user signature\n * @param v The recovery identifier represented by the last byte of a ECDSA signature as an int\n * @param r The random point x-coordinate of the signature respresented by the first 32 bytes of the generated ECDSA signature\n * @param s The signature proof represented by the second 32 bytes of the generated ECDSA signature\n */\nstruct Signature {\n uint8 v;\n bytes32 r;\n bytes32 s;\n}\n\nstruct MarketStorage {\n // Holds the index for the next loan ID\n Counters.Counter loanIDCounter;\n // Maps loanIDs to loan data\n mapping(uint256 => Loan) loans;\n // Maps loanID to loan debt (total owed left)\n mapping(uint256 => LoanDebt) loanDebt;\n // Maps loanID to loan terms\n mapping(uint256 => LoanTerms) _loanTerms; // DEPRECATED: DO NOT REMOVE\n // Maps loanIDs to escrow address to list of held tokens\n mapping(uint256 => ILoansEscrow) loanEscrows;\n // Maps loanIDs to list of tokens owned by a loan escrow\n mapping(uint256 => EnumerableSet.AddressSet) escrowTokens;\n // Maps collateral token address to a LoanCollateralEscrow that hold collateral funds\n mapping(address => ICollateralEscrow) collateralEscrows;\n // Maps accounts to owned loan IDs\n mapping(address => uint128[]) borrowerLoans;\n // Maps lending token to overall amount of interest collected from loans\n mapping(address => ITToken) tTokens;\n // Maps lending token to list of signer addresses who are only ones allowed to verify loan requests\n mapping(address => EnumerableSet.AddressSet) signers;\n // Maps lending token to list of allowed collateral tokens\n mapping(address => EnumerableSet.AddressSet) collateralTokens;\n}\n\nbytes32 constant MARKET_STORAGE_POS = keccak256(\"teller.market.storage\");\n\nlibrary MarketStorageLib {\n function store() internal pure returns (MarketStorage storage s) {\n bytes32 pos = MARKET_STORAGE_POS;\n assembly {\n s.slot := pos\n }\n }\n}\n" + }, + "contracts/shared/libraries/NumbersList.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/utils/math/SafeMath.sol\";\nimport \"./NumbersLib.sol\";\n\n/**\n * @dev Utility library of inline functions on NumbersList.Values\n *\n * @author develop@teller.finance\n */\nlibrary NumbersList {\n using NumbersLib for uint256;\n\n // Holds values to calculate the threshold of a list of numbers\n struct Values {\n uint256 count; // The total number of numbers added\n uint256 max; // The maximum number that was added\n uint256 min; // The minimum number that was added\n uint256 sum; // The total sum of the numbers that were added\n }\n\n /**\n * @dev Add to the sum while keeping track of min and max values\n * @param self The Value this function was called on\n * @param newValue Number to increment sum by\n */\n function addValue(Values memory self, uint256 newValue) internal pure {\n if (self.max < newValue) {\n self.max = newValue;\n }\n if (self.min > newValue || self.count == 0) {\n self.min = newValue;\n }\n self.sum = self.sum + (newValue);\n self.count = self.count + 1;\n }\n\n /**\n * @param self The Value this function was called on\n * @return the number of times the sum has updated\n */\n function valuesCount(Values memory self) internal pure returns (uint256) {\n return self.count;\n }\n\n /**\n * @dev Checks if the sum has been changed\n * @param self The Value this function was called on\n * @return boolean\n */\n function isEmpty(Values memory self) internal pure returns (bool) {\n return valuesCount(self) == 0;\n }\n\n /**\n * @param self The Value this function was called on\n * @return the average number that was used to calculate the sum\n */\n function getAverage(Values memory self) internal pure returns (uint256) {\n return isEmpty(self) ? 0 : self.sum / (valuesCount(self));\n }\n\n /**\n * @dev Checks if the min and max numbers are within the acceptable tolerance\n * @param self The Value this function was called on\n * @param tolerancePercentage Acceptable tolerance percentage as a whole number\n * The percentage should be entered with 2 decimal places. e.g. 2.5% should be entered as 250.\n * @return boolean\n */\n function isWithinTolerance(Values memory self, uint16 tolerancePercentage)\n internal\n pure\n returns (bool)\n {\n if (isEmpty(self)) {\n return false;\n }\n uint256 average = getAverage(self);\n uint256 toleranceAmount = average.percent(tolerancePercentage);\n\n uint256 minTolerance = average - toleranceAmount;\n if (self.min < minTolerance) {\n return false;\n }\n\n uint256 maxTolerance = average + toleranceAmount;\n if (self.max > maxTolerance) {\n return false;\n }\n return true;\n }\n}\n" + }, + "contracts/escrow/escrow/ILoansEscrow.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface ILoansEscrow {\n function init() external;\n\n /**\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\n * @param dappAddress address of the target contract address\n * @param dappData encoded abi of the function in our contract we want to call\n * @return the called data in bytes\n */\n function callDapp(address dappAddress, bytes calldata dappData)\n external\n returns (bytes memory);\n\n /**\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\n * @param token address of the respective ERC20 token to approve for the spender\n * @param spender address of the respective spender who is approved by the token contract\n */\n function setTokenAllowance(address token, address spender) external;\n\n /**\n * @notice it allows user to claim their escrow tokens\n * @dev only the owner (TellerDiamond) can make this call on behalf of the users\n * @param token address of the respective token contract to claim tokens from\n * @param to address where the tokens should be transferred to\n * @param amount uint256 amount of tokens to be claimed\n */\n function claimToken(\n address token,\n address to,\n uint256 amount\n ) external;\n}\n" + }, + "contracts/market/collateral/ICollateralEscrow.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface ICollateralEscrow {\n /**\n * @notice it initializes an escrow\n * @param tokenAddress the address of the collateral token to be stored\n * @param isWETH check if it's wrapped Ethereum\n */\n function init(address tokenAddress, bool isWETH) external;\n\n /**\n * @notice it deposits an amount of the respective collateral token into the escrow\n * @param loanID the ID of the loan\n * @param amount the amount of collateral tokens to be deposited\n */\n function deposit(uint256 loanID, uint256 amount) external payable;\n\n /**\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\n * @dev only the TellerDiamond can make this call on behalf of the borrower\n * @param loanID identifier of the loan\n * @param amount number of collateral tokens to send\n * @param receiver payable address to transfer money to\n */\n function withdraw(\n uint256 loanID,\n uint256 amount,\n address payable receiver\n ) external;\n\n /**\n * @notice it returns the supply of the respective loan\n * @param loanID the respective loan ID\n * @return supply_ the amount in collateral of the respective loan\n */\n function loanSupply(uint256 loanID) external view returns (uint256 supply_);\n\n /**\n * @notice it returns the total supply of the collateral token held by the contract\n * @return supply_ the total amount of collateral\n */\n function totalSupply() external view returns (uint256 supply_);\n}\n" + }, + "contracts/market/libraries/LibLoans.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport { LibEscrow } from \"../../escrow/libraries/LibEscrow.sol\";\nimport { NumbersLib } from \"../../shared/libraries/NumbersLib.sol\";\nimport {\n PlatformSettingsLib\n} from \"../../settings/platform/libraries/PlatformSettingsLib.sol\";\nimport { PriceAggLib } from \"../../price-aggregator/PriceAggLib.sol\";\n\n// Storage\nimport {\n MarketStorageLib,\n MarketStorage,\n Loan,\n LoanStatus,\n LoanDebt,\n LoanTerms\n} from \"../../storage/market.sol\";\n\nlibrary LibLoans {\n using NumbersLib for int256;\n using NumbersLib for uint256;\n\n bytes32 internal constant ID = keccak256(\"LOANS\");\n uint32 internal constant SECONDS_PER_YEAR = 31536000;\n\n function s() internal pure returns (MarketStorage storage) {\n return MarketStorageLib.store();\n }\n\n /**\n * @notice it returns the loan\n * @param loanID the ID of the respective loan\n * @return l_ the loan\n */\n function loan(uint256 loanID) internal view returns (Loan storage l_) {\n l_ = s().loans[loanID];\n }\n\n /**\n * @notice it returns the loan debt from a respective loan\n * @param loanID the ID of the respective loan\n * @return d_ the loan debt from a respective loan\n */\n function debt(uint256 loanID) internal view returns (LoanDebt storage d_) {\n d_ = s().loanDebt[loanID];\n }\n\n // DEPRECATED\n function terms(uint256 loanID)\n internal\n view\n returns (LoanTerms storage t_)\n {\n t_ = s()._loanTerms[loanID];\n }\n\n /**\n * @notice Returns the total amount owed for a specified loan.\n * @param loanID The loan ID to get the total amount owed.\n * @return owed_ uint256 The total owed amount.\n */\n function getTotalOwed(uint256 loanID)\n internal\n view\n returns (uint256 owed_)\n {\n if (loan(loanID).status == LoanStatus.Active) {\n owed_ = debt(loanID).principalOwed + (debt(loanID).interestOwed);\n }\n }\n\n /**\n * @notice Returns the amount of interest owed for a given loan and loan amount.\n * @param loanID The loan ID to get the owed interest.\n * @param amountBorrow The principal of the loan to take out.\n * @return uint256 The interest owed.\n */\n function getInterestOwedFor(uint256 loanID, uint256 amountBorrow)\n internal\n view\n returns (uint256)\n {\n return amountBorrow.percent(uint16(getInterestRatio(loanID)));\n }\n\n function getCollateralNeeded(uint256 loanID)\n internal\n view\n returns (uint256 _needed)\n {\n (, _needed, ) = getCollateralNeededInfo(loanID);\n }\n\n /**\n * @notice it returns the total collateral needed in lending tokens, in collateral tokens and in escrowed loan values\n * @param loanID the loanID to get the total collateral needed\n * @return neededInLendingTokens total collateral needed in lending tokens\n * @return neededInCollateralTokens total collateral needed in collateral tokens\n * @return escrowLoanValue total collateral needed in loan value\n */\n function getCollateralNeededInfo(uint256 loanID)\n internal\n view\n returns (\n uint256 neededInLendingTokens,\n uint256 neededInCollateralTokens,\n uint256 escrowLoanValue\n )\n {\n (neededInLendingTokens, escrowLoanValue) = getCollateralNeededInTokens(\n loanID\n );\n\n // check if needed lending tokens is zero. if true, then needed collateral tokens is zero. else,\n if (neededInLendingTokens == 0) {\n neededInCollateralTokens = 0;\n } else {\n neededInCollateralTokens = PriceAggLib.valueFor(\n loan(loanID).lendingToken,\n loan(loanID).collateralToken,\n neededInLendingTokens\n );\n }\n }\n\n /**\n * @notice Returns the minimum collateral value threshold, in the lending token, needed to take out the loan or for it be liquidated.\n * @dev If the loan status is TermsSet, then the value is whats needed to take out the loan.\n * @dev If the loan status is Active, then the value is the threshold at which the loan can be liquidated at.\n * @param loanID The loan ID to get needed collateral info for.\n * @return neededInLendingTokens int256 The minimum collateral value threshold required.\n * @return escrowLoanValue uint256 The value of the loan held in the escrow contract.\n */\n function getCollateralNeededInTokens(uint256 loanID)\n internal\n view\n returns (uint256 neededInLendingTokens, uint256 escrowLoanValue)\n {\n if (loan(loanID).collateralRatio == 0) {\n return (0, 0);\n }\n\n /*\n The collateral to principal owed ratio is the sum of:\n * collateral buffer percent\n * loan interest rate\n * liquidation reward percent\n * X factor of additional collateral\n */\n // * To take out a loan (if status == TermsSet), the required collateral is (max loan amount * the collateral ratio).\n // * For the loan to not be liquidated (when status == Active), the minimum collateral is (principal owed * (X collateral factor + liquidation reward)).\n // * If the loan has an escrow account, the minimum collateral is ((principal owed - escrow value) * (X collateral factor + liquidation reward)).\n if (loan(loanID).status == LoanStatus.TermsSet) {\n neededInLendingTokens = loan(loanID).borrowedAmount.percent(\n loan(loanID).collateralRatio\n );\n } else if (loan(loanID).status == LoanStatus.Active) {\n uint16 requiredRatio =\n loan(loanID).collateralRatio -\n getInterestRatio(loanID) -\n uint16(PlatformSettingsLib.getCollateralBufferValue());\n\n neededInLendingTokens =\n debt(loanID).principalOwed +\n debt(loanID).interestOwed;\n escrowLoanValue = LibEscrow.calculateTotalValue(loanID);\n if (\n escrowLoanValue > 0 && neededInLendingTokens > escrowLoanValue\n ) {\n neededInLendingTokens -= escrowLoanValue;\n }\n neededInLendingTokens = neededInLendingTokens.percent(\n requiredRatio\n );\n }\n }\n\n /**\n * @notice check if a loan can go to end of auction with a collateral ratio\n * @return bool checking if collateralRatio is >= the over collateralized buffer value\n */\n function canGoToEOAWithCollateralRatio(uint256 collateralRatio)\n internal\n view\n returns (bool)\n {\n return\n collateralRatio >=\n PlatformSettingsLib.getOverCollateralizedBufferValue();\n }\n\n /**\n * @notice Returns the interest ratio based on the loan interest rate for the loan duration.\n * @notice There is a minimum threshold of 1%.\n * @dev The interest rate is APY (annual percentage yield).\n * @param loanID The loan ID to get the interest rate for.\n */\n function getInterestRatio(uint256 loanID)\n internal\n view\n returns (uint16 ratio_)\n {\n ratio_ = uint16(\n (uint64(loan(loanID).duration) * loan(loanID).interestRate) /\n SECONDS_PER_YEAR\n );\n\n if (ratio_ == 0) {\n ratio_ = 1;\n }\n }\n}\n" + }, + "contracts/escrow/libraries/LibEscrow.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport { LibDapps } from \"../dapps/libraries/LibDapps.sol\";\nimport { LibLoans } from \"../../market/libraries/LibLoans.sol\";\nimport { PriceAggLib } from \"../../price-aggregator/PriceAggLib.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\n// Interfaces\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { ILoansEscrow } from \"../escrow/ILoansEscrow.sol\";\n\n// Storage\nimport { MarketStorageLib, MarketStorage } from \"../../storage/market.sol\";\n\nlibrary LibEscrow {\n function s() internal pure returns (MarketStorage storage) {\n return MarketStorageLib.store();\n }\n\n function e(uint256 loanID) internal view returns (ILoansEscrow e_) {\n e_ = s().loanEscrows[loanID];\n }\n\n /**\n * @notice It returns a list of tokens owned by a loan escrow\n * @param loanID uint256 index used to return our token list\n * @return t_ which is a list of tokens \n */\n function getEscrowTokens(uint256 loanID)\n internal\n view\n returns (EnumerableSet.AddressSet storage t_)\n {\n t_ = s().escrowTokens[loanID];\n }\n\n /**\n * @notice It returns the balance of a respective token in a loan escrow\n * @param loanID uint256 index used to point to our loan escrow\n * @param token address of respective token to give us the balance of in our loan escrow\n * @return uint256 balance of respective token returned in an escrow loan\n */\n function balanceOf(uint256 loanID, address token)\n internal\n view\n returns (uint256)\n {\n return IERC20(token).balanceOf(address(e(loanID)));\n }\n\n /**\n * @notice Adds or removes tokens held by the Escrow contract\n * @param loanID The loan ID to update the token list for\n * @param tokenAddress The token address to be added or removed\n */\n function tokenUpdated(uint256 loanID, address tokenAddress) internal {\n // Skip if is lending token\n if (LibLoans.loan(loanID).lendingToken == tokenAddress) return;\n\n EnumerableSet.AddressSet storage tokens = s().escrowTokens[loanID];\n bool contains = EnumerableSet.contains(tokens, tokenAddress);\n if (balanceOf(loanID, tokenAddress) > 0) {\n if (!contains) {\n EnumerableSet.add(tokens, tokenAddress);\n }\n } else if (contains) {\n EnumerableSet.remove(tokens, tokenAddress);\n }\n }\n\n /**\n * @notice Calculate the value of the loan by getting the value of all tokens the Escrow owns.\n * @param loanID The loan ID to calculate value for\n * @return value_ Escrow total value denoted in the lending token.\n */\n function calculateTotalValue(uint256 loanID)\n internal\n view\n returns (uint256 value_)\n {\n address lendingToken = LibLoans.loan(loanID).lendingToken;\n value_ += balanceOf(loanID, lendingToken);\n\n EnumerableSet.AddressSet storage tokens = getEscrowTokens(loanID);\n if (EnumerableSet.length(tokens) > 0) {\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\n uint256 tokenBal =\n balanceOf(loanID, EnumerableSet.at(tokens, i));\n value_ += PriceAggLib.valueFor(\n EnumerableSet.at(tokens, i),\n lendingToken,\n tokenBal\n );\n }\n }\n }\n}\n" + }, + "contracts/market/libraries/LibCollateral.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Interfaces\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\nimport { ICollateralEscrow } from \"../collateral/ICollateralEscrow.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../storage/app.sol\";\nimport { MarketStorageLib } from \"../../storage/market.sol\";\n\nlibrary LibCollateral {\n /**\n * @notice This event is emitted when collateral has been deposited for the loan\n * @param loanID ID of the loan for which collateral was deposited\n * @param depositor Account that deposited funds\n * @param amount Amount of collateral deposited\n */\n event CollateralDeposited(\n uint256 indexed loanID,\n address indexed depositor,\n uint256 amount\n );\n\n /**\n * @notice This event is emitted when collateral has been withdrawn\n * @param loanID ID of loan from which collateral was withdrawn\n * @param receiver Account that received funds\n * @param amount Value of collateral withdrawn\n */\n event CollateralWithdrawn(\n uint256 indexed loanID,\n address indexed receiver,\n uint256 amount\n );\n\n /**\n * @notice it gets MarketStorage's collateral escrow using the loanID\n * @param loanID the loanID to be used\n * @return c_ which is the collateral escrow\n */\n function e(uint256 loanID) internal view returns (ICollateralEscrow c_) {\n c_ = MarketStorageLib.store().collateralEscrows[\n MarketStorageLib.store().loans[loanID].collateralToken\n ];\n }\n\n function e(address token) internal view returns (ICollateralEscrow c_) {\n c_ = MarketStorageLib.store().collateralEscrows[token];\n }\n\n /**\n * @notice it deposits an amount of collateral into a collateral escrow's address of a respective loan\n * @param loanID the respective loan ID\n * @param amount the amount of collateral to deposit\n */\n function deposit(uint256 loanID, uint256 amount) internal {\n e(loanID).deposit{ value: amount }(loanID, amount);\n\n emit CollateralDeposited(loanID, msg.sender, amount);\n }\n\n /**\n * @notice it withdraws an amount from the collateral escrow\n * @param loanID the respective loanID to withdraw from\n * @param amount the number of collateral tokens to withdraw\n * @param receiver the address who receives the withdrawal\n */\n function withdraw(\n uint256 loanID,\n uint256 amount,\n address payable receiver\n ) internal {\n e(loanID).withdraw(loanID, amount, receiver);\n\n emit CollateralWithdrawn(loanID, receiver, amount);\n }\n\n /**\n * @notice it withdraws the entire supply in collateral of a respective loan to an address\n * @param loanID the respective loan's ID\n * @param receiver the address of the receiver to withdraw tokens from\n */\n function withdrawAll(uint256 loanID, address payable receiver) internal {\n withdraw(loanID, e(loanID).loanSupply(loanID), receiver);\n }\n\n /**\n * @notice it initializes a new escrow collateral to hold collateral tokens\n * @param token address of the collateral token it holds\n */\n function createEscrow(address token) internal {\n // Check if collateral escrow exists\n if (address(e(token)) == address(0)) {\n // Create escrow\n address escrow =\n AppStorageLib.store().collateralEscrowBeacon.cloneProxy(\"\");\n ICollateralEscrow(escrow).init(\n token,\n // Check if collateral token is the base network token\n token == AppStorageLib.store().wrappedNativeToken\n );\n\n // Set max allowance\n IERC20(token).approve(escrow, type(uint256).max);\n // Save escrow address for loan\n MarketStorageLib.store().collateralEscrows[\n token\n ] = ICollateralEscrow(escrow);\n }\n }\n}\n" + }, + "contracts/market/libraries/LibConsensus.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AppStorageLib } from \"../../storage/app.sol\";\nimport {\n MarketStorageLib,\n MarketStorage,\n LoanRequest,\n LoanUserRequest,\n LoanConsensusResponse,\n Signature\n} from \"../../storage/market.sol\";\nimport { NumbersLib } from \"../../shared/libraries/NumbersLib.sol\";\nimport { NumbersList } from \"../../shared/libraries/NumbersList.sol\";\nimport {\n PlatformSettingsLib\n} from \"../../settings/platform/libraries/PlatformSettingsLib.sol\";\nimport { ECDSA } from \"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\";\nimport { RolesLib } from \"../../contexts2/access-control/roles/RolesLib.sol\";\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\nlibrary LibConsensus {\n using NumbersList for NumbersList.Values;\n\n /**\n * @notice Represents loan terms based on consensus values\n * @param interestRate The consensus value for the interest rate based on all the loan responses from the signers\n * @param collateralRatio The consensus value for the ratio of collateral to loan amount required for the loan, based on all the loan responses from the signers\n * @param maxLoanAmount The consensus value for the largest amount of tokens that can be taken out in the loan, based on all the loan responses from the signers\n */\n struct AccruedLoanTerms {\n NumbersList.Values interestRate;\n NumbersList.Values collateralRatio;\n NumbersList.Values maxLoanAmount;\n }\n\n function s() private pure returns (MarketStorage storage) {\n return MarketStorageLib.store();\n }\n\n /**\n * @notice it processes a loan terms by doing multiple checks on the LoanRequest request and LoanResponse[] responses\n * @param request LoanRequest is the borrower request object to take out a loan\n * @return interestRate the borrower needs to pay back\n * @return collateralRatio the ratio of collateral the borrower needs to put up for the loan with an underlying asset\n * @return maxLoanAmount the borrower is entitled for\n */\n function processLoanTerms(LoanRequest calldata request)\n internal\n view\n returns (\n uint16 interestRate,\n uint16 collateralRatio,\n uint256 maxLoanAmount\n )\n {\n // get the signers from the asset address\n EnumerableSet.AddressSet storage signers =\n s().signers[request.request.assetAddress];\n\n require(\n uint256(\n NumbersLib.ratioOf(\n request.responses.length,\n EnumerableSet.length(signers)\n )\n ) >= PlatformSettingsLib.getRequiredSubmissionsPercentageValue(),\n \"Teller: insufficient signer responses\"\n );\n\n _validateLoanRequest(\n request.request.borrower,\n request.request.requestNonce\n );\n\n uint32 chainId = _getChainId();\n bytes32 requestHash = _hashRequest(request.request, chainId);\n\n // create term submissions for every response ...\n AccruedLoanTerms memory termSubmissions;\n\n for (uint256 i = 0; i < request.responses.length; i++) {\n LoanConsensusResponse memory response = request.responses[i];\n\n // check if the signers contains the response's signer\n require(\n EnumerableSet.contains(signers, response.signer),\n \"Teller: invalid signer\"\n );\n\n // check if the request's asset address equates to the response's asset address\n require(\n response.assetAddress == request.request.assetAddress,\n \"Teller: consensus address mismatch\"\n );\n\n // check if consensus response has expired\n require(\n uint256(response.responseTime) >=\n block.timestamp -\n PlatformSettingsLib.getTermsExpiryTimeValue(),\n \"Teller: consensus response expired\"\n );\n\n // check if the signature of hashed response data matches\n require(\n _signatureValid(\n response.signature,\n _hashResponse(requestHash, response, chainId),\n response.signer\n ),\n \"Teller: response signature invalid\"\n );\n\n // TODO: use a local AddressArrayLib instead to save gas\n for (uint8 j = 0; j < i; j++) {\n require(\n response.signer != request.responses[j].signer,\n \"Teller: dup signer response\"\n );\n }\n\n termSubmissions.interestRate.addValue(response.interestRate);\n termSubmissions.collateralRatio.addValue(response.collateralRatio);\n termSubmissions.maxLoanAmount.addValue(response.maxLoanAmount);\n }\n\n // get maximum tolerance value in order to receive the interestRate, collateralRatio and maxLoanAmount\n uint16 tolerance =\n uint16(PlatformSettingsLib.getMaximumToleranceValue());\n interestRate = uint16(\n _getConsensus(termSubmissions.interestRate, tolerance)\n );\n collateralRatio = uint16(\n _getConsensus(termSubmissions.collateralRatio, tolerance)\n );\n maxLoanAmount = _getConsensus(termSubmissions.maxLoanAmount, tolerance);\n }\n\n /**\n * @dev Checks if the nonce provided in the request is equal to the borrower's number of loans.\n * @dev Also verifies if the borrower has taken out a loan recently (rate limit).\n * @param borrower the borrower's address.\n * @param nonce the nonce included in the loan request.\n */\n function _validateLoanRequest(address borrower, uint256 nonce)\n private\n view\n {\n uint128[] storage borrowerLoans = s().borrowerLoans[borrower];\n uint256 numberOfLoans = borrowerLoans.length;\n\n require(nonce == numberOfLoans, \"Teller: bad request nonce\");\n\n // In case it is the first time that borrower requests loan terms, we don't\n // validate the rate limit.\n if (numberOfLoans == 0) {\n return;\n }\n\n require(\n uint256(\n s().loans[uint256(borrowerLoans[numberOfLoans - 1])]\n .loanStartTime\n ) +\n PlatformSettingsLib.getRequestLoanTermsRateLimitValue() <=\n block.timestamp,\n \"Teller: loan terms rate limit reached\"\n );\n }\n\n /**\n * @notice Gets the current chain id using the opcode 'chainid()'.\n * @return id_ The current chain id.\n */\n function _getChainId() private view returns (uint32 id_) {\n // silence state mutability warning without generating bytecode.\n // see https://github.com/ethereum/solidity/issues/2691\n assembly {\n id_ := chainid()\n }\n }\n\n /**\n * @notice Generates a hash for the loan request\n * @param request Struct of the protocol loan request\n * @return bytes32 Hash of the loan request\n */\n function _hashRequest(LoanUserRequest memory request, uint32 chainId)\n private\n pure\n returns (bytes32)\n {\n return\n keccak256(\n abi.encode(\n request.borrower,\n request.assetAddress,\n request.amount,\n request.requestNonce,\n request.duration,\n request.requestTime,\n chainId\n )\n );\n }\n\n /**\n * @notice Generates a hash for the loan response\n * @param requestHash Hash of the loan request\n * @param response Structs of the protocol loan responses\n * @return bytes32 Hash of the loan response\n */\n function _hashResponse(\n bytes32 requestHash,\n LoanConsensusResponse memory response,\n uint32 chainId\n ) internal pure returns (bytes32) {\n return\n keccak256(\n abi.encode(\n response.assetAddress,\n response.maxLoanAmount,\n requestHash,\n response.responseTime,\n response.interestRate,\n response.collateralRatio,\n chainId\n )\n );\n }\n\n /**\n * @notice It validates whether a signature is valid or not.\n * @param signature signature to validate.\n * @param dataHash used to recover the signer.\n * @param expectedSigner the expected signer address.\n * @return true if the expected signer is equal to the signer. Otherwise it returns false.\n */\n function _signatureValid(\n Signature memory signature,\n bytes32 dataHash,\n address expectedSigner\n ) internal pure returns (bool) {\n return\n expectedSigner ==\n ECDSA.recover(\n keccak256(\n abi.encodePacked(\n \"\\x19Ethereum Signed Message:\\n32\",\n dataHash\n )\n ),\n signature.v,\n signature.r,\n signature.s\n );\n }\n\n /**\n * @notice Gets the consensus value for a list of values (uint values).\n * @notice The values must be in a maximum tolerance range.\n * @return the consensus value.\n */\n function _getConsensus(NumbersList.Values memory values, uint16 tolerance)\n internal\n pure\n returns (uint256)\n {\n require(\n values.isWithinTolerance(tolerance),\n \"Teller: consensus response values too varied\"\n );\n\n return values.getAverage();\n }\n}\n" + }, + "contracts/settings/asset/libraries/MaxDebtRatioLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../../shared/libraries/CacheLib.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions for MaxDebtRatio asset setting.\n *\n * @author develop@teller.finance\n */\nlibrary MaxDebtRatioLib {\n bytes32 private constant NAME = keccak256(\"MaxDebtRatio\");\n\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n function get(address asset) internal view returns (uint16) {\n return uint16(s(asset).uints[NAME]);\n }\n\n function set(address asset, uint16 newValue) internal {\n s(asset).uints[NAME] = uint256(newValue);\n }\n}\n" + }, + "@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IBeacon.sol\";\nimport \"../Proxy.sol\";\nimport \"../ERC1967/ERC1967Upgrade.sol\";\n\n/**\n * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.\n *\n * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't\n * conflict with the storage layout of the implementation behind the proxy.\n *\n * _Available since v3.4._\n */\ncontract BeaconProxy is Proxy, ERC1967Upgrade {\n /**\n * @dev Initializes the proxy with `beacon`.\n *\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This\n * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity\n * constructor.\n *\n * Requirements:\n *\n * - `beacon` must be a contract with the interface {IBeacon}.\n */\n constructor(address beacon, bytes memory data) payable {\n assert(_BEACON_SLOT == bytes32(uint256(keccak256(\"eip1967.proxy.beacon\")) - 1));\n _upgradeBeaconToAndCall(beacon, data, false);\n }\n\n /**\n * @dev Returns the current beacon address.\n */\n function _beacon() internal view virtual returns (address) {\n return _getBeacon();\n }\n\n /**\n * @dev Returns the current implementation address of the associated beacon.\n */\n function _implementation() internal view virtual override returns (address) {\n return IBeacon(_getBeacon()).implementation();\n }\n\n /**\n * @dev Changes the proxy to use a new beacon. Deprecated: see {_upgradeBeaconToAndCall}.\n *\n * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.\n *\n * Requirements:\n *\n * - `beacon` must be a contract.\n * - The implementation returned by `beacon` must be a contract.\n */\n function _setBeacon(address beacon, bytes memory data) internal virtual {\n _upgradeBeaconToAndCall(beacon, data, false);\n }\n}\n" + }, + "contracts/price-aggregator/PriceAggLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { PriceAggFacet } from \"./PriceAggFacet.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../storage/app.sol\";\n\n/**\n * @notice Helper functions to staticcall into the PriceAggFacet from other facets. See {PriceAggFacet.getPriceFor}\n */\nlibrary PriceAggLib {\n /**\n * @notice It calculates the value of one token amount into another\n * @param src the source token\n * @param dst the destination token\n * @param srcAmount the amount of source token\n * @return value_ the returned value of src in dst\n */\n function valueFor(\n address src,\n address dst,\n uint256 srcAmount\n ) internal view returns (uint256 value_) {\n value_ = PriceAggFacet(address(this)).getValueFor(src, dst, srcAmount);\n }\n\n /**\n * @notice It returns the price of the token pair as given from Compound.\n * @dev if no compound price is calculated, then it checks Chainlink price Aggregator\n * @param src the address of the source token\n * @param dst the address of the desitnation token\n * @return price_ gets the price of src in dst\n */\n function priceFor(address src, address dst)\n internal\n view\n returns (int256 price_)\n {\n price_ = PriceAggFacet(address(this)).getPriceFor(src, dst);\n }\n}\n" + }, + "contracts/escrow/dapps/libraries/LibDapps.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Interfaces\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { IAToken } from \"../../../shared/interfaces/IAToken.sol\";\nimport {\n IAaveLendingPool\n} from \"../../../shared/interfaces/IAaveLendingPool.sol\";\nimport {\n IAaveLendingPoolAddressesProvider\n} from \"../../../shared/interfaces/IAaveLendingPoolAddressesProvider.sol\";\nimport {\n IUniswapV2Router\n} from \"../../../shared/interfaces/IUniswapV2Router.sol\";\nimport { IVault } from \"../interfaces/IVault.sol\";\n\n// Libraries\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\n// Storage\nimport { MarketStorageLib, MarketStorage } from \"../../../storage/market.sol\";\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\nlibrary LibDapps {\n function s() internal pure returns (MarketStorage storage) {\n return MarketStorageLib.store();\n }\n\n /**\n @notice Grabs the Aave lending pool instance from the Aave lending pool address provider\n @return IAaveLendingPool instance address\n */\n function getAaveLendingPool() internal view returns (IAaveLendingPool) {\n return\n IAaveLendingPool(\n IAaveLendingPoolAddressesProvider(\n 0xd05e3E715d945B59290df0ae8eF85c1BdB684744 // Polygon mainnet\n )\n .getLendingPool()\n ); // LP address provider contract is immutable and the address will never change\n }\n\n /**\n @notice Grabs the aToken instance from the lending pool\n @param tokenAddress The underlying asset address to get the aToken for\n @return IAToken instance\n */\n function getAToken(address tokenAddress) internal view returns (IAToken) {\n return\n IAToken(\n getAaveLendingPool().getReserveData(tokenAddress).aTokenAddress\n );\n }\n\n /**\n @notice Grabs the yVault address for a token from the asset settings\n @param tokenAddress The underlying token address for the associated yVault\n @return yVault instance\n */\n function getYVault(address tokenAddress) internal view returns (IVault) {\n return\n IVault(\n AppStorageLib.store().assetSettings[tokenAddress].addresses[\n keccak256(\"yVaultAddress\")\n ]\n );\n }\n}\n" + }, + "contracts/shared/interfaces/IAaveLendingPool.sol": { + "content": "// SPDX-License-Identifier: agpl-3.0\npragma solidity ^0.8.0;\n\nimport \"./IAaveLendingPoolAddressesProvider.sol\";\nimport \"./DataTypes.sol\";\n\ninterface IAaveLendingPool {\n /**\n * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.\n * - E.g. User deposits 100 USDC and gets in return 100 aUSDC\n * @param asset The address of the underlying asset to deposit\n * @param amount The amount to be deposited\n * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user\n * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens\n * is a different wallet\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\n * 0 if the action is executed directly by the user, without any middle-man\n **/\n function deposit(\n address asset,\n uint256 amount,\n address onBehalfOf,\n uint16 referralCode\n ) external;\n\n /**\n * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned\n * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC\n * @param asset The address of the underlying asset to withdraw\n * @param amount The underlying amount to be withdrawn\n * - Send the value type(uint256).max in order to withdraw the whole aToken balance\n * @param to Address that will receive the underlying, same as msg.sender if the user\n * wants to receive it on his own wallet, or a different address if the beneficiary is a\n * different wallet\n * @return The final amount withdrawn\n **/\n function withdraw(\n address asset,\n uint256 amount,\n address to\n ) external returns (uint256);\n\n /**\n * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower\n * already deposited enough collateral, or he was given enough allowance by a credit delegator on the\n * corresponding debt token (StableDebtToken or VariableDebtToken)\n * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet\n * and 100 stable/variable debt tokens, depending on the `interestRateMode`\n * @param asset The address of the underlying asset to borrow\n * @param amount The amount to be borrowed\n * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\n * 0 if the action is executed directly by the user, without any middle-man\n * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself\n * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator\n * if he has been given credit delegation allowance\n **/\n function borrow(\n address asset,\n uint256 amount,\n uint256 interestRateMode,\n uint16 referralCode,\n address onBehalfOf\n ) external;\n\n /**\n * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned\n * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address\n * @param asset The address of the borrowed underlying asset previously borrowed\n * @param amount The amount to repay\n * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`\n * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable\n * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the\n * user calling the function if he wants to reduce/remove his own debt, or the address of any other\n * other borrower whose debt should be removed\n * @return The final amount repaid\n **/\n function repay(\n address asset,\n uint256 amount,\n uint256 rateMode,\n address onBehalfOf\n ) external returns (uint256);\n\n /**\n * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa\n * @param asset The address of the underlying asset borrowed\n * @param rateMode The rate mode that the user wants to swap to\n **/\n function swapBorrowRateMode(address asset, uint256 rateMode) external;\n\n /**\n * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.\n * - Users can be rebalanced if the following conditions are satisfied:\n * 1. Usage ratio is above 95%\n * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been\n * borrowed at a stable rate and depositors are not earning enough\n * @param asset The address of the underlying asset borrowed\n * @param user The address of the user to be rebalanced\n **/\n function rebalanceStableBorrowRate(address asset, address user) external;\n\n /**\n * @dev Allows depositors to enable/disable a specific deposited asset as collateral\n * @param asset The address of the underlying asset deposited\n * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise\n **/\n function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)\n external;\n\n /**\n * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1\n * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives\n * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk\n * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation\n * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation\n * @param user The address of the borrower getting liquidated\n * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover\n * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants\n * to receive the underlying collateral asset directly\n **/\n function liquidationCall(\n address collateralAsset,\n address debtAsset,\n address user,\n uint256 debtToCover,\n bool receiveAToken\n ) external;\n\n /**\n * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,\n * as long as the amount taken plus a fee is returned.\n * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.\n * For further details please visit https://developers.aave.com\n * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface\n * @param assets The addresses of the assets being flash-borrowed\n * @param amounts The amounts amounts being flash-borrowed\n * @param modes Types of the debt to open if the flash loan is not returned:\n * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver\n * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\n * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address\n * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2\n * @param params Variadic packed params to pass to the receiver as extra information\n * @param referralCode Code used to register the integrator originating the operation, for potential rewards.\n * 0 if the action is executed directly by the user, without any middle-man\n **/\n function flashLoan(\n address receiverAddress,\n address[] calldata assets,\n uint256[] calldata amounts,\n uint256[] calldata modes,\n address onBehalfOf,\n bytes calldata params,\n uint16 referralCode\n ) external;\n\n /**\n * @dev Returns the user account data across all the reserves\n * @param user The address of the user\n * @return totalCollateralETH the total collateral in ETH of the user\n * @return totalDebtETH the total debt in ETH of the user\n * @return availableBorrowsETH the borrowing power left of the user\n * @return currentLiquidationThreshold the liquidation threshold of the user\n * @return ltv the loan to value of the user\n * @return healthFactor the current health factor of the user\n **/\n function getUserAccountData(address user)\n external\n view\n returns (\n uint256 totalCollateralETH,\n uint256 totalDebtETH,\n uint256 availableBorrowsETH,\n uint256 currentLiquidationThreshold,\n uint256 ltv,\n uint256 healthFactor\n );\n\n /**\n * @dev Returns the configuration of the reserve\n * @param asset The address of the underlying asset of the reserve\n * @return The configuration of the reserve\n **/\n function getConfiguration(address asset)\n external\n view\n returns (DataTypes.ReserveConfigurationMap memory);\n\n /**\n * @dev Returns the configuration of the user across all the reserves\n * @param user The user address\n * @return The configuration of the user\n **/\n function getUserConfiguration(address user)\n external\n view\n returns (DataTypes.UserConfigurationMap memory);\n\n /**\n * @dev Returns the normalized income normalized income of the reserve\n * @param asset The address of the underlying asset of the reserve\n * @return The reserve's normalized income\n */\n function getReserveNormalizedIncome(address asset)\n external\n view\n returns (uint256);\n\n /**\n * @dev Returns the normalized variable debt per unit of asset\n * @param asset The address of the underlying asset of the reserve\n * @return The reserve normalized variable debt\n */\n function getReserveNormalizedVariableDebt(address asset)\n external\n view\n returns (uint256);\n\n /**\n * @dev Returns the state and configuration of the reserve\n * @param asset The address of the underlying asset of the reserve\n * @return The state of the reserve\n **/\n function getReserveData(address asset)\n external\n view\n returns (DataTypes.ReserveData memory);\n\n function finalizeTransfer(\n address asset,\n address from,\n address to,\n uint256 amount,\n uint256 balanceFromAfter,\n uint256 balanceToBefore\n ) external;\n\n function getReservesList() external view returns (address[] memory);\n\n function getAddressesProvider()\n external\n view\n returns (IAaveLendingPoolAddressesProvider);\n\n function paused() external view returns (bool);\n}\n" + }, + "contracts/shared/interfaces/IAaveLendingPoolAddressesProvider.sol": { + "content": "// SPDX-License-Identifier: agpl-3.0\npragma solidity ^0.8.0;\n\n/**\n * @title LendingPoolAddressesProvider contract\n * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles\n * - Acting also as factory of proxies and admin of those, so with right to change its implementations\n * - Owned by the Aave Governance\n * @author Aave\n **/\ninterface IAaveLendingPoolAddressesProvider {\n function getMarketId() external view returns (string memory);\n\n function getAddress(bytes32 id) external view returns (address);\n\n function getLendingPool() external view returns (address);\n\n function getPriceOracle() external view returns (address);\n\n function getLendingRateOracle() external view returns (address);\n}\n" + }, + "contracts/escrow/dapps/interfaces/IVault.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/**\n @notice This interface defines the different functions available for a Yearn Vault\n @author develop@teller.finance\n */\n\ninterface IVault {\n /**\n @notice Returns the unwrapped native token address that the Vault takes as deposit\n @return The address of the unwrapped token\n */\n function token() external view returns (address);\n\n /**\n @notice Returns the vault's wrapped token name as a string, example 'yearn Dai Stablecoin'\n @return The name of the wrapped token\n */\n function name() external view returns (string memory);\n\n /**\n @notice Returns the vault's wrapped token symbol as a string, example 'yDai'\n @return The symbol of the wrapped token\n */\n function symbol() external view returns (string memory);\n\n /**\n @notice Returns the amount of decimals for this vault's wrapped token as a uin8\n @return The number of decimals for the token\n */\n function decimals() external view returns (uint8);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n @notice Returns the address of the Vault's controller\n @return The address of the controller contract\n */\n function controller() external view returns (address);\n\n /**\n @notice Returns the address of the Vault's governance contract\n @return The contract address\n */\n function governance() external view returns (address);\n\n /**\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\n @return The token price\n */\n function getPricePerFullShare() external view returns (uint256); // v1 vaults\n\n /**\n @notice Returns the price of the Vault's wrapped token, denominated in the unwrapped native token\n @notice Calculation is: nativeTokenBalance/yTokenTotalSupply,\n - nativeTokenBalance is the current balance of the native token (example DAI) in the Vault\n - yTokenTotalSupply is the total supply of the Vault's wrapped token (example yDAI)\n @return The token price\n */\n function getPricePerShare() external view returns (uint256); // v2 vaults\n\n /**\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\n @param amountToDeposit The amount of tokens to deposit\n */\n function deposit(uint256 amountToDeposit) external;\n\n /**\n @notice Deposits the maximum available amount of the native wrapped token (same as token()) into the Vault\n */\n function depositAll() external;\n\n /**\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\n @param amountToWithdraw The amount to withdraw\n */\n function withdraw(uint256 amountToWithdraw) external;\n\n /**\n @notice Withdraws the maximum available amount of native unwrapped token (same as token()) from the Vault\n */\n function withdrawAll() external;\n}\n" + }, + "contracts/shared/interfaces/DataTypes.sol": { + "content": "// SPDX-License-Identifier: agpl-3.0\npragma solidity ^0.8.0;\n\nlibrary DataTypes {\n // refer to the aave whitepaper, section 1.1 basic concepts for a formal description of these properties.\n struct ReserveData {\n //stores the reserve configuration\n ReserveConfigurationMap configuration;\n //the liquidity index. Expressed in ray\n uint128 liquidityIndex;\n //variable borrow index. Expressed in ray\n uint128 variableBorrowIndex;\n //the current supply rate. Expressed in ray\n uint128 currentLiquidityRate;\n //the current variable borrow rate. Expressed in ray\n uint128 currentVariableBorrowRate;\n //the current stable borrow rate. Expressed in ray\n uint128 currentStableBorrowRate;\n uint40 lastUpdateTimestamp;\n //tokens addresses\n address aTokenAddress;\n address stableDebtTokenAddress;\n address variableDebtTokenAddress;\n //address of the interest rate strategy\n address interestRateStrategyAddress;\n //the id of the reserve. Represents the position in the list of the active reserves\n uint8 id;\n }\n\n struct ReserveConfigurationMap {\n //bit 0-15: LTV\n //bit 16-31: Liq. threshold\n //bit 32-47: Liq. bonus\n //bit 48-55: Decimals\n //bit 56: Reserve is active\n //bit 57: reserve is frozen\n //bit 58: borrowing is enabled\n //bit 59: stable rate borrowing enabled\n //bit 60-63: reserved\n //bit 64-79: reserve factor\n uint256 data;\n }\n\n struct UserConfigurationMap {\n uint256 data;\n }\n\n enum InterestRateMode { NONE, STABLE, VARIABLE }\n}\n" + }, + "@openzeppelin/contracts/utils/cryptography/ECDSA.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\n *\n * These functions can be used to verify that a message was signed by the holder\n * of the private keys of a given address.\n */\nlibrary ECDSA {\n /**\n * @dev Returns the address that signed a hashed message (`hash`) with\n * `signature`. This address can then be used for verification purposes.\n *\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\n * this function rejects them by requiring the `s` value to be in the lower\n * half order, and the `v` value to be either 27 or 28.\n *\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n * verification to be secure: it is possible to craft signatures that\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n * this is by receiving a hash of the original message (which may otherwise\n * be too long), and then calling {toEthSignedMessageHash} on it.\n */\n function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\n // Divide the signature in r, s and v variables\n bytes32 r;\n bytes32 s;\n uint8 v;\n\n // Check the signature length\n // - case 65: r,s,v signature (standard)\n // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._\n if (signature.length == 65) {\n // ecrecover takes the signature parameters, and the only way to get them\n // currently is to use assembly.\n // solhint-disable-next-line no-inline-assembly\n assembly {\n r := mload(add(signature, 0x20))\n s := mload(add(signature, 0x40))\n v := byte(0, mload(add(signature, 0x60)))\n }\n } else if (signature.length == 64) {\n // ecrecover takes the signature parameters, and the only way to get them\n // currently is to use assembly.\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let vs := mload(add(signature, 0x40))\n r := mload(add(signature, 0x20))\n s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)\n v := add(shr(255, vs), 27)\n }\n } else {\n revert(\"ECDSA: invalid signature length\");\n }\n\n return recover(hash, v, r, s);\n }\n\n /**\n * @dev Overload of {ECDSA-recover} that receives the `v`,\n * `r` and `s` signature fields separately.\n */\n function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {\n // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n //\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n // these malleable signatures as well.\n require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, \"ECDSA: invalid signature 's' value\");\n require(v == 27 || v == 28, \"ECDSA: invalid signature 'v' value\");\n\n // If the signature is valid (and not malleable), return the signer address\n address signer = ecrecover(hash, v, r, s);\n require(signer != address(0), \"ECDSA: invalid signature\");\n\n return signer;\n }\n\n /**\n * @dev Returns an Ethereum Signed Message, created from a `hash`. This\n * produces hash corresponding to the one signed with the\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\n * JSON-RPC method as part of EIP-191.\n *\n * See {recover}.\n */\n function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {\n // 32 is the length in bytes of hash,\n // enforced by the type signature above\n return keccak256(abi.encodePacked(\"\\x19Ethereum Signed Message:\\n32\", hash));\n }\n\n /**\n * @dev Returns an Ethereum Signed Typed Data, created from a\n * `domainSeparator` and a `structHash`. This produces hash corresponding\n * to the one signed with the\n * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\n * JSON-RPC method as part of EIP-712.\n *\n * See {recover}.\n */\n function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {\n return keccak256(abi.encodePacked(\"\\x19\\x01\", domainSeparator, structHash));\n }\n}\n" + }, + "@openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.2;\n\nimport \"../beacon/IBeacon.sol\";\nimport \"../../utils/Address.sol\";\nimport \"../../utils/StorageSlot.sol\";\n\n/**\n * @dev This abstract contract provides getters and event emitting update functions for\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\n *\n * _Available since v4.1._\n *\n * @custom:oz-upgrades-unsafe-allow delegatecall\n */\nabstract contract ERC1967Upgrade {\n // This is the keccak-256 hash of \"eip1967.proxy.rollback\" subtracted by 1\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\n\n /**\n * @dev Storage slot with the address of the current implementation.\n * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n /**\n * @dev Emitted when the implementation is upgraded.\n */\n event Upgraded(address indexed implementation);\n\n /**\n * @dev Returns the current implementation address.\n */\n function _getImplementation() internal view returns (address) {\n return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the EIP1967 implementation slot.\n */\n function _setImplementation(address newImplementation) private {\n require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n }\n\n /**\n * @dev Perform implementation upgrade\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeTo(address newImplementation) internal {\n _setImplementation(newImplementation);\n emit Upgraded(newImplementation);\n }\n\n /**\n * @dev Perform implementation upgrade with additional setup call.\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {\n _setImplementation(newImplementation);\n emit Upgraded(newImplementation);\n if (data.length > 0 || forceCall) {\n Address.functionDelegateCall(newImplementation, data);\n }\n }\n\n /**\n * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeToAndCallSecure(address newImplementation, bytes memory data, bool forceCall) internal {\n address oldImplementation = _getImplementation();\n\n // Initial upgrade and setup call\n _setImplementation(newImplementation);\n if (data.length > 0 || forceCall) {\n Address.functionDelegateCall(newImplementation, data);\n }\n\n // Perform rollback test if not already in progress\n StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);\n if (!rollbackTesting.value) {\n // Trigger rollback using upgradeTo from the new implementation\n rollbackTesting.value = true;\n Address.functionDelegateCall(\n newImplementation,\n abi.encodeWithSignature(\n \"upgradeTo(address)\",\n oldImplementation\n )\n );\n rollbackTesting.value = false;\n // Check rollback was effective\n require(oldImplementation == _getImplementation(), \"ERC1967Upgrade: upgrade breaks further upgrades\");\n // Finally reset to the new implementation and log the upgrade\n _setImplementation(newImplementation);\n emit Upgraded(newImplementation);\n }\n }\n\n /**\n * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\n * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\n *\n * Emits a {BeaconUpgraded} event.\n */\n function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {\n _setBeacon(newBeacon);\n emit BeaconUpgraded(newBeacon);\n if (data.length > 0 || forceCall) {\n Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\n }\n }\n\n /**\n * @dev Storage slot with the admin of the contract.\n * This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\n\n /**\n * @dev Emitted when the admin account has changed.\n */\n event AdminChanged(address previousAdmin, address newAdmin);\n\n /**\n * @dev Returns the current admin.\n */\n function _getAdmin() internal view returns (address) {\n return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the EIP1967 admin slot.\n */\n function _setAdmin(address newAdmin) private {\n require(newAdmin != address(0), \"ERC1967: new admin is the zero address\");\n StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\n }\n\n /**\n * @dev Changes the admin of the proxy.\n *\n * Emits an {AdminChanged} event.\n */\n function _changeAdmin(address newAdmin) internal {\n emit AdminChanged(_getAdmin(), newAdmin);\n _setAdmin(newAdmin);\n }\n\n /**\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\n */\n bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\n\n /**\n * @dev Emitted when the beacon is upgraded.\n */\n event BeaconUpgraded(address indexed beacon);\n\n /**\n * @dev Returns the current beacon.\n */\n function _getBeacon() internal view returns (address) {\n return StorageSlot.getAddressSlot(_BEACON_SLOT).value;\n }\n\n /**\n * @dev Stores a new beacon in the EIP1967 beacon slot.\n */\n function _setBeacon(address newBeacon) private {\n require(\n Address.isContract(newBeacon),\n \"ERC1967: new beacon is not a contract\"\n );\n require(\n Address.isContract(IBeacon(newBeacon).implementation()),\n \"ERC1967: beacon implementation is not a contract\"\n );\n StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;\n }\n}\n" + }, + "@openzeppelin/contracts/utils/StorageSlot.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC1967 implementation slot:\n * ```\n * contract ERC1967 {\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n * function _getImplementation() internal view returns (address) {\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n * }\n *\n * function _setImplementation(address newImplementation) internal {\n * require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n * }\n * }\n * ```\n *\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\n */\nlibrary StorageSlot {\n struct AddressSlot {\n address value;\n }\n\n struct BooleanSlot {\n bool value;\n }\n\n struct Bytes32Slot {\n bytes32 value;\n }\n\n struct Uint256Slot {\n uint256 value;\n }\n\n /**\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n */\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\n */\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\n */\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\n */\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n assembly {\n r.slot := slot\n }\n }\n}\n" + }, + "contracts/escrow/EscrowClaimTokens.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport { PausableMods } from \"../settings/pausable/PausableMods.sol\";\n\n// Interfaces\nimport {\n EnumerableSet\n} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\n\n// Storage\nimport { MarketStorageLib, LoanStatus } from \"../storage/market.sol\";\n\n// Libraries\nimport { LibLoans } from \"../market/libraries/LibLoans.sol\";\nimport { LibEscrow } from \"./libraries/LibEscrow.sol\";\n\n/**\n * @notice Contains functionality to claim tokens that are in an escrow contract for a loan.\n */\ncontract EscrowClaimTokens is PausableMods {\n /**\n * @notice Notifies when the Escrow's tokens have been claimed.\n * @param recipient address where the tokens where sent to.\n */\n event TokensClaimed(address recipient);\n\n /**\n * @notice Sends the tokens owned by this escrow to the owner.\n * @param loanID The id of the loan being used.\n */\n function claimTokens(uint256 loanID) external paused(\"\", false) {\n require(\n LibLoans.loan(loanID).borrower == msg.sender,\n \"Teller: claim not borrower\"\n );\n require(\n LibLoans.loan(loanID).status == LoanStatus.Closed,\n \"Teller: loan not closed\"\n );\n\n __claimEscrowTokens(loanID);\n }\n\n function __claimEscrowTokens(uint256 loanID) internal {\n __claimToken(loanID, LibLoans.loan(loanID).lendingToken);\n\n EnumerableSet.AddressSet storage tokens =\n MarketStorageLib.store().escrowTokens[loanID];\n for (uint256 i = 0; i < EnumerableSet.length(tokens); i++) {\n __claimToken(loanID, EnumerableSet.at(tokens, i));\n }\n\n emit TokensClaimed(msg.sender);\n }\n\n function __claimToken(uint256 loanID, address token) private {\n uint256 balance = LibEscrow.balanceOf(loanID, token);\n if (balance > 0) {\n LibEscrow.e(loanID).claimToken(\n token,\n LibLoans.loan(loanID).borrower,\n balance\n );\n }\n }\n}\n" + }, + "contracts/escrow/dapps/DappMods.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport { LibLoans } from \"../../market/libraries/LibLoans.sol\";\nimport {\n PlatformSettingsLib\n} from \"../../settings/platform/libraries/PlatformSettingsLib.sol\";\n\nabstract contract DappMods {\n /**\n * @notice it checks if the caller to a respective loan escrow is the borrower\n * @param loanID uint256 of the respective loan escrow\n */\n modifier onlyBorrower(uint256 loanID) {\n require(\n msg.sender == LibLoans.loan(loanID).borrower,\n \"Teller: dapp not loan borrower\"\n );\n _;\n }\n \n /**\n * @notice checks if the respective loan escrow is secure\n * @param loanID uint256 of the respective loan escrow\n */\n modifier onlySecured(uint256 loanID) {\n require(\n LibLoans.loan(loanID).collateralRatio >=\n PlatformSettingsLib.getCollateralBufferValue(),\n \"Teller: dapp loan not secured\"\n );\n _;\n }\n}\n" + }, + "contracts/escrow/dapps/libraries/LibCompound.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nlibrary LibCompound {\n // Compound error code for no errors\n uint256 constant NO_ERROR = 0;\n\n // Compound error code when caller does not have sufficient balance in the ERC-20 contract to complete the desired action.\n uint256 constant TOKEN_INSUFFICIENT_BALANCE = 13;\n}\n" + }, + "contracts/escrow/dapps/libraries/LibUniswap.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Interfaces\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport {\n IUniswapV2Router\n} from \"../../../shared/interfaces/IUniswapV2Router.sol\";\n\n// Libraries\nimport {\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\n\nlibrary LibUniswap {\n IUniswapV2Router constant ROUTER =\n IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);\n\n /**\n * @notice Swaps tokens for tokens on Uniswap.\n * @dev {path} must have at least 2 token addresses\n * @param path An array of token addresses.\n * @param sourceAmount amount of source token to swap.\n * @param minDestination The minimum amount of output tokens that must be received for the transaction not to revert.\n * @return amounts is the resulting number of tokens swapped for\n */\n function swap(\n address[] memory path,\n uint256 sourceAmount,\n uint256 minDestination\n ) internal returns (uint256) {\n SafeERC20.safeIncreaseAllowance(\n IERC20(path[0]),\n address(ROUTER),\n sourceAmount\n );\n uint256[] memory amounts =\n ROUTER.swapExactTokensForTokens(\n sourceAmount,\n minDestination,\n path,\n address(this),\n block.timestamp\n );\n\n return amounts[amounts.length - 1];\n }\n}\n" + }, + "contracts/escrow/dapps/libraries/LibSushiswap.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Interfaces\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport {\n IUniswapV2Router\n} from \"../../../shared/interfaces/IUniswapV2Router.sol\";\n\n// Libraries\nimport {\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\n\nlibrary LibSushiswap {\n IUniswapV2Router constant ROUTER =\n IUniswapV2Router(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506); // Sushiswap polygon\n\n /**\n * @notice Swaps tokens for tokens on Sushiswap.\n * @dev {path} must have at least 2 token addresses\n * @param path An array of token addresses.\n * @param sourceAmount amount of source token to swap.\n * @param minDestination The minimum amount of output tokens that must be received for the transaction not to revert.\n */\n function swap(\n address[] memory path,\n uint256 sourceAmount,\n uint256 minDestination\n ) internal returns (uint256) {\n SafeERC20.safeIncreaseAllowance(\n IERC20(path[0]),\n address(ROUTER),\n sourceAmount\n );\n uint256[] memory amounts =\n ROUTER.swapExactTokensForTokens(\n sourceAmount,\n minDestination,\n path,\n address(this),\n block.timestamp\n );\n\n return amounts[amounts.length - 1];\n }\n}\n" + }, + "contracts/nft/distributor/internal/distributor.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../store.sol\";\n\n// Libraries\nimport \"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\";\n\n// Utils\nimport { ClaimNFTRequest } from \"../data.sol\";\n\ncontract int_distributor_NFT_v1 is sto_NFTDistributor {\n /**\n * @notice It checks the merkle root for a tier if it has already been claimed.\n * @param merkleIndex Index of the tier.\n * @param nodeIndex Index of the node in the merkle root.\n */\n function _setClaimed(uint256 merkleIndex, uint256 nodeIndex) internal {\n uint256 claimedWordIndex = nodeIndex / 256;\n uint256 claimedBitIndex = nodeIndex % 256;\n distributorStore().claimedBitMap[merkleIndex][claimedWordIndex] =\n distributorStore().claimedBitMap[merkleIndex][claimedWordIndex] |\n (1 << claimedBitIndex);\n }\n\n /**\n * @notice It checks the merkle root for a tier if it has already been claimed.\n * @param merkleIndex Index of the tier.\n * @param nodeIndex Index of the node in the merkle root.\n * @return claimed_ returns a boolean to check if the tier has already been claimed\n */\n function _isClaimed(uint256 merkleIndex, uint256 nodeIndex)\n internal\n view\n returns (bool)\n {\n uint256 claimedWordIndex = nodeIndex / 256;\n uint256 claimedBitIndex = nodeIndex % 256;\n uint256 claimedWord =\n distributorStore().claimedBitMap[merkleIndex][claimedWordIndex];\n uint256 mask = (1 << claimedBitIndex);\n return claimedWord & mask == mask;\n }\n\n /**\n * @notice it verifies the request's merkle proof with the merkle root in order to claim an NFT\n * @param account the account's address to be hashed and verified with the claim\n * @param request the request with the merkle proof to verify\n */\n function _verifyProof(address account, ClaimNFTRequest memory request)\n internal\n view\n returns (bool verified)\n {\n verified = MerkleProof.verify(\n request.merkleProof,\n distributorStore().merkleRoots[request.merkleIndex].merkleRoot,\n keccak256(\n abi.encodePacked(request.nodeIndex, account, request.amount)\n )\n );\n }\n}\n" + }, + "contracts/nft/distributor/external/distributor.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../store.sol\";\nimport \"../internal/distributor.sol\";\n\ncontract ext_distributor_NFT_v1 is sto_NFTDistributor, int_distributor_NFT_v1 {\n /**\n * @notice It gets the TellerNFT diamond instance used to mint.\n * @return nft_ returns the NFT instance\n */\n function nft() external view returns (ITellerNFT nft_) {\n nft_ = distributorStore().nft;\n }\n\n /**\n * @notice It gets the merkle roots for NFTs it can distribute.\n * @return roots_ returns the merkle\n */\n function getMerkleRoots()\n external\n view\n returns (MerkleRoot[] memory roots_)\n {\n roots_ = distributorStore().merkleRoots;\n }\n\n /**\n * @notice It checks the merkle root for a tier if it has already been claimed.\n * @param merkleIndex Index of the tier.\n * @param nodeIndex Index of the node in the merkle root.\n * @return claimed_ returns a boolean to check if the tier has already been claimed\n */\n function isClaimed(uint256 merkleIndex, uint256 nodeIndex)\n external\n view\n returns (bool claimed_)\n {\n claimed_ = _isClaimed(merkleIndex, nodeIndex);\n }\n}\n\ncontract ext_distributor_NFT is ext_distributor_NFT_v1 {}\n" + }, + "contracts/nft/distributor/entry/claim.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../store.sol\";\nimport \"../../../contexts/access-control/modifiers/authorized.sol\";\n\nimport \"../internal/distributor.sol\";\n\n// Utils\nimport { ClaimNFTRequest, ADMIN, DistributorEvents } from \"../data.sol\";\n\ncontract ent_claim_NFTDistributor_v1 is\n sto_NFTDistributor,\n int_distributor_NFT_v1,\n mod_authorized_AccessControl_v1\n{\n /**\n * @notice Claims TellerNFTs for a given verifiable merkle proofs for each tier.\n * @param account The address to claim NFTs on behalf.\n * @param requests An array requests data generated from the merkle tree.\n *\n * Requirements:\n * - Node in the merkle root must not be claimed already\n * - Proof of the node must match the merkle tree\n */\n function claim(address account, ClaimNFTRequest[] calldata requests)\n external\n {\n for (uint256 i; i < requests.length; i++) {\n require(\n !_isClaimed(requests[i].merkleIndex, requests[i].nodeIndex),\n \"TellerNFT Distributor: already claimed\"\n );\n require(\n _verifyProof(account, requests[i]),\n \"TellerNFT Distributor: invalid proof\"\n );\n\n // Mark it claimed and send the token.\n _setClaimed(requests[i].merkleIndex, requests[i].nodeIndex);\n uint256 tierIndex =\n distributorStore().merkleRoots[requests[i].merkleIndex]\n .tierIndex;\n for (uint256 j; j < requests[i].amount; j++) {\n distributorStore().nft.mint(tierIndex, account);\n }\n\n //Find the newly minted tokens and add to memory\n uint256[] memory postOwnedTokens =\n distributorStore().nft.getOwnedTokens(account);\n\n uint256[] memory newlyMintedTokenIds =\n new uint256[](requests[i].amount);\n\n uint256 offset = postOwnedTokens.length - requests[i].amount;\n\n for (uint256 k; k < requests[i].amount; k++) {\n newlyMintedTokenIds[k] = postOwnedTokens[k + offset];\n }\n\n //For each newly minted token, set the tier index in the Dictionary contract\n distributorStore().dictionary.setTokenTierForTokenIds(\n newlyMintedTokenIds,\n tierIndex\n );\n }\n\n emit DistributorEvents.Claimed(account);\n }\n\n function setNFTDictionaryAddress(address dictionary)\n external\n authorized(ADMIN, msg.sender)\n {\n distributorStore().dictionary = TellerNFTDictionary(dictionary);\n }\n}\n" + }, + "contracts/nft/distributor/entry/add-merkle.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"../store.sol\";\nimport \"../../../contexts/access-control/modifiers/authorized.sol\";\n\n// Utils\nimport { DistributorEvents, ADMIN, MerkleRoot } from \"../data.sol\";\n\ncontract ent_addMerkle_NFTDistributor_v1 is\n sto_NFTDistributor,\n mod_authorized_AccessControl_v1\n{\n /**\n * @notice Adds a new merkle to be able to claim NFTs.\n * @param tierIndex Index of NFT tier to assign merkle for.\n * @param merkleRoot The merkle root to assign to the new tier.\n *\n * Requirements:\n * - Caller must be an admin\n */\n function addMerkle(uint256 tierIndex, bytes32 merkleRoot)\n external\n authorized(ADMIN, msg.sender)\n {\n MerkleRoot storage merkle = distributorStore().merkleRoots.push();\n merkle.tierIndex = tierIndex;\n merkle.merkleRoot = merkleRoot;\n\n emit DistributorEvents.MerkleAdded(\n distributorStore().merkleRoots.length - 1\n );\n }\n}\n" + }, + "contracts/escrow/escrow/LoansEscrow_V1.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\n\n// Interfaces\nimport { ILoansEscrow } from \"./ILoansEscrow.sol\";\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { ICErc20 } from \"../../shared/interfaces/ICErc20.sol\";\n\n// Libraries\nimport {\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport { Address } from \"@openzeppelin/contracts/utils/Address.sol\";\n\n// Proxy\nimport {\n InitializeableBeaconProxy\n} from \"../../shared/proxy/beacon/InitializeableBeaconProxy.sol\";\nimport { IBeacon } from \"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\";\n\ncontract LoansEscrow_V1 is ILoansEscrow {\n address public owner;\n\n modifier onlyOwner {\n require(owner == msg.sender, \"Teller: loan escrow not owner\");\n _;\n }\n\n function init() external override {\n require(owner == address(0), \"Teller: loan escrow already initialized\");\n owner = msg.sender;\n }\n\n /**\n * @notice it calls a dapp like YearnFinance at a target contract address with specified calldata\n * @param dappAddress address of the target contract address\n * @param dappData encoded abi of the function in our contract we want to call\n * @return resData_ the called data in\n */\n function callDapp(address dappAddress, bytes calldata dappData)\n external\n override\n onlyOwner\n returns (bytes memory resData_)\n {\n resData_ = Address.functionCall(\n dappAddress,\n dappData,\n \"Teller: dapp call failed\"\n );\n }\n\n /**\n * @notice it approves the spender to spend a maximum amount of a respective token from a token address\n * @param token address of the respective ERC20 token to approve for the spender\n * @param spender address of the respective spender who is approved by the token contract\n */\n function setTokenAllowance(address token, address spender)\n external\n override\n onlyOwner\n {\n IERC20(token).approve(spender, type(uint256).max);\n }\n\n /**\n * @notice it allows user to claim their escrow tokens\n * @dev only the owner (TellerDiamond) can make this call on behalf of their users\n * @param token address of the respective token contract to claim tokens from\n * @param to address where the tokens should be transferred to\n * @param amount uint256 amount of tokens to be claimed\n */\n function claimToken(\n address token,\n address to,\n uint256 amount\n ) external override onlyOwner {\n SafeERC20.safeTransfer(IERC20(token), to, amount);\n }\n}\n" + }, + "contracts/market/collateral/CollateralEscrow_V1.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport \"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\";\n\n// Interfaces\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { ICollateralEscrow } from \"./ICollateralEscrow.sol\";\nimport { IWETH } from \"../../shared/interfaces/IWETH.sol\";\n\n// Libraries\nimport {\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport { Address } from \"@openzeppelin/contracts/utils/Address.sol\";\n\ncontract CollateralEscrow_V1 is OwnableUpgradeable, ICollateralEscrow {\n mapping(uint256 => uint256) internal _balances; // loanID -> collateral\n address public collateralToken;\n bool internal _isWrappedNativeToken; // Should this be renamed to _isNetworkToken? more agnostic in cases of WMATIC\n\n /**\n * @notice it initializes an escrow\n * @param tokenAddress the address of the collateral token to be stored\n * @param isWrappedNativeToken check if it's wrapped Ethereum/MATIC\n */\n function init(address tokenAddress, bool isWrappedNativeToken)\n external\n override\n {\n require(\n tokenAddress != address(0),\n \"Teller escrow: collateral token address 0\"\n );\n\n OwnableUpgradeable.__Ownable_init();\n collateralToken = tokenAddress;\n _isWrappedNativeToken = isWrappedNativeToken;\n }\n\n /**\n * @notice it deposits an amount of the respective collateral token into the escrow\n * @param loanID the ID of the loan\n * @param amount the amount of collateral tokens to be deposited\n */\n function deposit(uint256 loanID, uint256 amount)\n external\n payable\n override\n onlyOwner\n {\n if (_isWrappedNativeToken && msg.value > 0) {\n require(msg.value == amount, \"Teller: incorrect eth deposit\");\n IWETH(collateralToken).deposit{ value: msg.value }();\n } else {\n SafeERC20.safeTransferFrom(\n IERC20(collateralToken),\n msg.sender,\n address(this),\n amount\n );\n }\n\n _balances[loanID] += amount;\n }\n\n /**\n * @notice it withdraws an amount of tokens in a respective loanID on behalf of the borrower\n * @dev only the TellerDiamond can make this call on behalf of the borrower\n * @param loanID identifier of the loan\n * @param amount number of collateral tokens to send\n * @param receiver payable address to transfer money to\n */\n function withdraw(\n uint256 loanID,\n uint256 amount,\n address payable receiver\n ) external override onlyOwner {\n require(\n _balances[loanID] >= amount,\n \"Teller escrow: Insufficient collateral balance\"\n );\n\n SafeERC20.safeTransfer(IERC20(collateralToken), receiver, amount);\n _balances[loanID] -= amount;\n }\n\n /**\n * @notice it returns the supply of collateral of the respective loan\n * @param loanID the respective loan ID\n * @return supply_ the amount in collateral of the respective loan\n */\n function loanSupply(uint256 loanID)\n external\n view\n override\n returns (uint256 supply_)\n {\n supply_ = _balances[loanID];\n }\n\n /**\n * @notice it returns the total supply of the collateral token held by the contract\n * @return supply_ the total amount of collateral\n */\n function totalSupply() external view override returns (uint256 supply_) {\n supply_ = IERC20(collateralToken).balanceOf(address(this));\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\n address private _owner;\n\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Initializes the contract setting the deployer as the initial owner.\n */\n function __Ownable_init() internal initializer {\n __Context_init_unchained();\n __Ownable_init_unchained();\n }\n\n function __Ownable_init_unchained() internal initializer {\n address msgSender = _msgSender();\n _owner = msgSender;\n emit OwnershipTransferred(address(0), msgSender);\n }\n\n /**\n * @dev Returns the address of the current owner.\n */\n function owner() public view virtual returns (address) {\n return _owner;\n }\n\n /**\n * @dev Throws if called by any account other than the owner.\n */\n modifier onlyOwner() {\n require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n _;\n }\n\n /**\n * @dev Leaves the contract without owner. It will not be possible to call\n * `onlyOwner` functions anymore. Can only be called by the current owner.\n *\n * NOTE: Renouncing ownership will leave the contract without an owner,\n * thereby removing any functionality that is only available to the owner.\n */\n function renounceOwnership() public virtual onlyOwner {\n emit OwnershipTransferred(_owner, address(0));\n _owner = address(0);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) public virtual onlyOwner {\n require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n emit OwnershipTransferred(_owner, newOwner);\n _owner = newOwner;\n }\n uint256[49] private __gap;\n}\n" + }, + "contracts/shared/interfaces/IWETH.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/**\n * @notice It is the interface of functions that we use for the canonical WETH contract.\n *\n * @author develop@teller.finance\n */\ninterface IWETH {\n /**\n * @notice It withdraws ETH from the contract by sending it to the caller and reducing the caller's internal balance of WETH.\n * @param amount The amount of ETH to withdraw.\n */\n function withdraw(uint256 amount) external;\n\n /**\n * @notice It deposits ETH into the contract and increases the caller's internal balance of WETH.\n */\n function deposit() external payable;\n\n /**\n * @notice It gets the ETH deposit balance of an {account}.\n * @param account Address to get balance of.\n */\n function balanceOf(address account) external view returns (uint256);\n}\n" + }, + "contracts/lending/ttoken/TToken_V1.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Contracts\nimport {\n CONTROLLER,\n ADMIN,\n EXCHANGE_RATE_FACTOR,\n ONE_HUNDRED_PERCENT\n} from \"./data.sol\";\nimport { ITTokenStrategy } from \"./strategies/ITTokenStrategy.sol\";\nimport { ERC20 } from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\n\n// Utils\nimport { Address } from \"@openzeppelin/contracts/utils/Address.sol\";\n\n// Interfaces\nimport { ITToken } from \"./ITToken.sol\";\nimport { ICErc20 } from \"../../shared/interfaces/ICErc20.sol\";\n\n// Libraries\nimport {\n IERC20,\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport {\n ERC165Checker\n} from \"@openzeppelin/contracts/utils/introspection/ERC165Checker.sol\";\nimport { RolesLib } from \"../../contexts2/access-control/roles/RolesLib.sol\";\nimport { NumbersLib } from \"../../shared/libraries/NumbersLib.sol\";\n\n// Storage\nimport \"./storage.sol\" as Storage;\n\n/**\n * @notice This contract represents a lending pool for an asset within Teller protocol.\n * @author develop@teller.finance\n */\ncontract TToken_V1 is ITToken {\n function() pure returns (Storage.Store storage) private constant s =\n Storage.store;\n\n /* Modifiers */\n\n /**\n * @notice Checks if the LP is restricted or has the CONTROLLER role.\n *\n * The LP being restricted means that only the Teller protocol may\n * lend/borrow funds.\n */\n modifier notRestricted {\n require(\n !s().restricted || RolesLib.hasRole(CONTROLLER, _msgSender()),\n \"Teller: platform restricted\"\n );\n _;\n }\n\n /* Public Functions */\n\n /**\n * @notice it returns the decimal places of the respective TToken\n * @return decimals of the token\n */\n function decimals() public view override returns (uint8) {\n return s().decimals;\n }\n\n /**\n * @notice The token that is the underlying assets for this Teller token.\n * @return ERC20 token that is the underlying asset\n */\n function underlying() public view override returns (ERC20) {\n return s().underlying;\n }\n\n /**\n * @notice The balance of an {account} denoted in underlying value.\n * @param account Address to calculate the underlying balance.\n * @return balance_ the balance of the account\n */\n function balanceOfUnderlying(address account)\n public\n override\n returns (uint256)\n {\n return _valueInUnderlying(balanceOf(account), exchangeRate());\n }\n\n /**\n * @notice It calculates the current exchange rate for a whole Teller Token based of the underlying token balance.\n * @return rate_ The current exchange rate.\n */\n function exchangeRate() public override returns (uint256 rate_) {\n if (totalSupply() == 0) {\n return EXCHANGE_RATE_FACTOR;\n }\n\n rate_ = (currentTVL() * EXCHANGE_RATE_FACTOR) / totalSupply();\n }\n\n /**\n * @notice It calculates the total supply of the underlying asset.\n * @return totalSupply_ the total supply denoted in the underlying asset.\n */\n function totalUnderlyingSupply() public override returns (uint256) {\n bytes memory data =\n _delegateStrategy(\n abi.encodeWithSelector(\n ITTokenStrategy.totalUnderlyingSupply.selector\n )\n );\n return abi.decode(data, (uint256));\n }\n\n /**\n * @notice It calculates the market state values across a given markets.\n * @notice Returns values that represent the global state across the market.\n * @return totalSupplied Total amount of the underlying asset supplied.\n * @return totalBorrowed Total amount borrowed through loans.\n * @return totalRepaid The total amount repaid till the current timestamp.\n * @return totalInterestRepaid The total amount interest repaid till the current timestamp.\n * @return totalOnLoan Total amount currently deployed in loans.\n */\n function getMarketState()\n external\n override\n returns (\n uint256 totalSupplied,\n uint256 totalBorrowed,\n uint256 totalRepaid,\n uint256 totalInterestRepaid,\n uint256 totalOnLoan\n )\n {\n totalSupplied = totalUnderlyingSupply();\n totalBorrowed = s().totalBorrowed;\n totalRepaid = s().totalRepaid;\n totalInterestRepaid = s().totalInterestRepaid;\n totalOnLoan = totalBorrowed - totalRepaid;\n }\n\n /**\n * @notice Calculates the current Total Value Locked, denoted in the underlying asset, in the Teller Token pool.\n * @return tvl_ The value locked in the pool.\n *\n * Note: This value includes the amount that is on loan (including ones that were sent to EOAs).\n */\n function currentTVL() public override returns (uint256 tvl_) {\n tvl_ += totalUnderlyingSupply();\n tvl_ += s().totalBorrowed;\n tvl_ -= s().totalRepaid;\n }\n\n /**\n * @notice It validates whether supply to debt (StD) ratio is valid including the loan amount.\n * @param newLoanAmount the new loan amount to consider the StD ratio.\n * @return ratio_ Whether debt ratio for lending pool is valid.\n */\n function debtRatioFor(uint256 newLoanAmount)\n external\n override\n returns (uint16 ratio_)\n {\n uint256 onLoan = s().totalBorrowed - s().totalRepaid;\n uint256 supplied = totalUnderlyingSupply() + onLoan;\n if (supplied > 0) {\n ratio_ = NumbersLib.ratioOf(onLoan + newLoanAmount, supplied);\n }\n }\n\n /**\n * @notice Called by the Teller Diamond contract when a loan has been taken out and requires funds.\n * @param recipient The account to send the funds to.\n * @param amount Funds requested to fulfil the loan.\n */\n function fundLoan(address recipient, uint256 amount)\n external\n override\n authorized(CONTROLLER, _msgSender())\n {\n // If TToken is not holding enough funds to cover the loan, call the strategy to try to withdraw\n uint256 balance = s().underlying.balanceOf(address(this));\n if (balance < amount) {\n _delegateStrategy(\n abi.encodeWithSelector(\n ITTokenStrategy.withdraw.selector,\n amount - balance\n )\n );\n }\n\n // Increase total borrowed amount\n s().totalBorrowed += amount;\n\n // Transfer tokens to recipient\n SafeERC20.safeTransfer(s().underlying, recipient, amount);\n }\n\n /**\n * @notice Called by the Teller Diamond contract when a loan has been repaid.\n * @param amount Funds deposited back into the pool to repay the principal amount of a loan.\n * @param interestAmount Interest value paid into the pool from a loan.\n */\n function repayLoan(uint256 amount, uint256 interestAmount)\n external\n override\n authorized(CONTROLLER, _msgSender())\n {\n s().totalRepaid += amount;\n s().totalInterestRepaid += interestAmount;\n }\n\n /**\n * @notice Deposit underlying token amount into LP and mint tokens.\n * @param amount The amount of underlying tokens to use to mint.\n * @return Amount of TTokens minted.\n */\n function mint(uint256 amount)\n external\n override\n notRestricted\n returns (uint256)\n {\n require(amount > 0, \"Teller: cannot mint 0\");\n require(\n amount <= s().underlying.balanceOf(_msgSender()),\n \"Teller: insufficient underlying\"\n );\n\n // Calculate amount of tokens to mint\n uint256 mintAmount = _valueOfUnderlying(amount, exchangeRate());\n\n // Transfer tokens from lender\n SafeERC20.safeTransferFrom(\n s().underlying,\n _msgSender(),\n address(this),\n amount\n );\n\n // Mint Teller token value of underlying\n _mint(_msgSender(), mintAmount);\n\n emit Mint(_msgSender(), mintAmount, amount);\n\n return mintAmount;\n }\n\n /**\n * @notice Redeem supplied Teller token underlying value.\n * @param amount The amount of Teller tokens to redeem.\n */\n function redeem(uint256 amount) external override {\n require(amount > 0, \"Teller: cannot withdraw 0\");\n require(\n amount <= balanceOf(_msgSender()),\n \"Teller: redeem amount exceeds balance\"\n );\n\n // Accrue interest and calculate exchange rate\n uint256 underlyingAmount = _valueInUnderlying(amount, exchangeRate());\n require(\n underlyingAmount <= totalUnderlyingSupply(),\n \"Teller: redeem ttoken lp not enough supply\"\n );\n\n // Burn Teller Tokens and transfer underlying\n _redeem(amount, underlyingAmount);\n }\n\n /**\n * @notice Redeem supplied underlying value.\n * @param amount The amount of underlying tokens to redeem.\n */\n function redeemUnderlying(uint256 amount) external override {\n require(amount > 0, \"Teller: cannot withdraw 0\");\n require(\n amount <= totalUnderlyingSupply(),\n \"Teller: redeem ttoken lp not enough supply\"\n );\n\n // Accrue interest and calculate exchange rate\n uint256 rate = exchangeRate();\n uint256 tokenValue = _valueOfUnderlying(amount, rate);\n\n // Make sure sender has adequate balance\n require(\n tokenValue <= balanceOf(_msgSender()),\n \"Teller: redeem amount exceeds balance\"\n );\n\n // Burn Teller Tokens and transfer underlying\n _redeem(tokenValue, amount);\n }\n\n /**\n * @dev Redeem an {amount} of Teller Tokens and transfers {underlyingAmount} to the caller.\n * @param amount Total amount of Teller Tokens to burn.\n * @param underlyingAmount Total amount of underlying asset tokens to transfer to caller.\n *\n * This function should only be called by {redeem} and {redeemUnderlying} after the exchange\n * rate and both token values have been calculated to use.\n */\n function _redeem(uint256 amount, uint256 underlyingAmount) internal {\n // Burn Teller tokens\n _burn(_msgSender(), amount);\n\n // Make sure enough funds are available to redeem\n _delegateStrategy(\n abi.encodeWithSelector(\n ITTokenStrategy.withdraw.selector,\n underlyingAmount\n )\n );\n\n // Transfer funds back to lender\n SafeERC20.safeTransfer(s().underlying, _msgSender(), underlyingAmount);\n\n emit Redeem(_msgSender(), amount, underlyingAmount);\n }\n\n /**\n * @notice Rebalances the funds controlled by Teller Token according to the current strategy.\n *\n * See {TTokenStrategy}.\n */\n function rebalance() public override {\n _delegateStrategy(\n abi.encodeWithSelector(ITTokenStrategy.rebalance.selector)\n );\n }\n\n /**\n * @notice Sets a new strategy to use for balancing funds.\n * @param strategy Address to the new strategy contract. Must implement the {ITTokenStrategy} interface.\n * @param initData Optional data to initialize the strategy.\n *\n * Requirements:\n * - Sender must have ADMIN role\n */\n function setStrategy(address strategy, bytes calldata initData)\n external\n override\n authorized(ADMIN, _msgSender())\n {\n require(\n ERC165Checker.supportsInterface(\n strategy,\n type(ITTokenStrategy).interfaceId\n ),\n \"Teller: strategy does not support ITTokenStrategy\"\n );\n s().strategy = strategy;\n if (initData.length > 0) {\n _delegateStrategy(initData);\n }\n }\n\n /**\n * @notice Gets the strategy used for balancing funds.\n * @return address of the strategy contract\n */\n function getStrategy() external view override returns (address) {\n return s().strategy;\n }\n\n /**\n * @notice Sets the restricted state of the platform.\n * @param state boolean value that resembles the platform's state\n */\n function restrict(bool state)\n public\n override\n authorized(ADMIN, _msgSender())\n {\n s().restricted = state;\n }\n\n /**\n * @notice it initializes the Teller Token\n * @param admin address of the admin to the respective Teller Token\n * @param underlying address of the ERC20 token\n */\n function initialize(address admin, address underlying)\n external\n override\n initializer\n {\n require(\n Address.isContract(msg.sender),\n \"Teller: controller not contract\"\n );\n require(\n Address.isContract(underlying),\n \"Teller: underlying token not contract\"\n );\n\n RolesLib.grantRole(CONTROLLER, msg.sender);\n RolesLib.grantRole(ADMIN, admin);\n\n s().underlying = ERC20(underlying);\n __ERC20_init(\n string(abi.encodePacked(\"Teller \", s().underlying.name())),\n string(abi.encodePacked(\"t\", s().underlying.symbol()))\n );\n s().decimals = s().underlying.decimals();\n // Platform restricted by default\n s().restricted = true;\n }\n\n /**\n * @notice it retrieves the value of the underlying token\n * @param amount the amount of tokens to calculate the value of\n * @param rate the exchangeRate() to divide with the amount * exchange_rate_factor\n * @return value_ the underlying value of the token amount\n */\n function _valueOfUnderlying(uint256 amount, uint256 rate)\n internal\n pure\n returns (uint256 value_)\n {\n value_ = (amount * EXCHANGE_RATE_FACTOR) / rate;\n }\n\n /**\n * @notice it retrives the value in the underlying tokens\n *\n */\n function _valueInUnderlying(uint256 amount, uint256 rate)\n internal\n pure\n returns (uint256 value_)\n {\n value_ = (amount * (rate)) / EXCHANGE_RATE_FACTOR;\n }\n\n /**\n * @notice Delegates data to call on the strategy contract.\n * @param callData Data to call the strategy contract with.\n *\n * Requirements:\n * - Sender must have ADMIN role\n */\n function _delegateStrategy(bytes memory callData)\n internal\n returns (bytes memory)\n {\n return Address.functionDelegateCall(s().strategy, callData);\n }\n}\n" + }, + "contracts/lending/ttoken/data.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Role ID used to pull funds for the asset it manages (i.e. TellerDiamond)\nbytes32 constant CONTROLLER = keccak256(\"CONTROLLER\");\n// Role ID used to for accounts to call special methods that modify its state\nbytes32 constant ADMIN = keccak256(\"ADMIN\");\n\nuint256 constant EXCHANGE_RATE_FACTOR = 1e18;\nuint256 constant ONE_HUNDRED_PERCENT = 10000;\n" + }, + "contracts/lending/ttoken/strategies/ITTokenStrategy.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface ITTokenStrategy {\n event StrategyRebalanced(\n string indexed strategyName,\n address indexed sender\n );\n\n /**\n * @notice it returns the total supply of an underlying asset in a Teller token.\n * @return uint256 the underlying supply\n */\n function totalUnderlyingSupply() external returns (uint256);\n\n /**\n * @notice it rebalances the underlying asset held by the Teller Token.\n *\n */\n function rebalance() external;\n\n /**\n * @notice it withdraws amount of tokens in a pool\n * @param amount amount to withdraw\n */\n\n function withdraw(uint256 amount) external;\n}\n" + }, + "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165.sol\";\n\n/**\n * @dev Library used to query support of an interface declared via {IERC165}.\n *\n * Note that these functions return the actual result of the query: they do not\n * `revert` if an interface is not supported. It is up to the caller to decide\n * what to do in these cases.\n */\nlibrary ERC165Checker {\n // As per the EIP-165 spec, no interface should ever match 0xffffffff\n bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;\n\n /**\n * @dev Returns true if `account` supports the {IERC165} interface,\n */\n function supportsERC165(address account) internal view returns (bool) {\n // Any contract that implements ERC165 must explicitly indicate support of\n // InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid\n return _supportsERC165Interface(account, type(IERC165).interfaceId) &&\n !_supportsERC165Interface(account, _INTERFACE_ID_INVALID);\n }\n\n /**\n * @dev Returns true if `account` supports the interface defined by\n * `interfaceId`. Support for {IERC165} itself is queried automatically.\n *\n * See {IERC165-supportsInterface}.\n */\n function supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) {\n // query support of both ERC165 as per the spec and support of _interfaceId\n return supportsERC165(account) &&\n _supportsERC165Interface(account, interfaceId);\n }\n\n /**\n * @dev Returns a boolean array where each value corresponds to the\n * interfaces passed in and whether they're supported or not. This allows\n * you to batch check interfaces for a contract where your expectation\n * is that some interfaces may not be supported.\n *\n * See {IERC165-supportsInterface}.\n *\n * _Available since v3.4._\n */\n function getSupportedInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool[] memory) {\n // an array of booleans corresponding to interfaceIds and whether they're supported or not\n bool[] memory interfaceIdsSupported = new bool[](interfaceIds.length);\n\n // query support of ERC165 itself\n if (supportsERC165(account)) {\n // query support of each interface in interfaceIds\n for (uint256 i = 0; i < interfaceIds.length; i++) {\n interfaceIdsSupported[i] = _supportsERC165Interface(account, interfaceIds[i]);\n }\n }\n\n return interfaceIdsSupported;\n }\n\n /**\n * @dev Returns true if `account` supports all the interfaces defined in\n * `interfaceIds`. Support for {IERC165} itself is queried automatically.\n *\n * Batch-querying can lead to gas savings by skipping repeated checks for\n * {IERC165} support.\n *\n * See {IERC165-supportsInterface}.\n */\n function supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) {\n // query support of ERC165 itself\n if (!supportsERC165(account)) {\n return false;\n }\n\n // query support of each interface in _interfaceIds\n for (uint256 i = 0; i < interfaceIds.length; i++) {\n if (!_supportsERC165Interface(account, interfaceIds[i])) {\n return false;\n }\n }\n\n // all interfaces supported\n return true;\n }\n\n /**\n * @notice Query if a contract implements an interface, does not check ERC165 support\n * @param account The address of the contract to query for support of an interface\n * @param interfaceId The interface identifier, as specified in ERC-165\n * @return true if the contract at account indicates support of the interface with\n * identifier interfaceId, false otherwise\n * @dev Assumes that account contains a contract that supports ERC165, otherwise\n * the behavior of this method is undefined. This precondition can be checked\n * with {supportsERC165}.\n * Interface identification is specified in ERC-165.\n */\n function _supportsERC165Interface(address account, bytes4 interfaceId) private view returns (bool) {\n bytes memory encodedParams = abi.encodeWithSelector(IERC165(account).supportsInterface.selector, interfaceId);\n (bool success, bytes memory result) = account.staticcall{ gas: 30000 }(encodedParams);\n if (result.length < 32) return false;\n return success && abi.decode(result, (bool));\n }\n}\n" + }, + "contracts/lending/ttoken/storage.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { ERC20, IERC20 } from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\n\nstruct Store {\n ERC20 underlying;\n address strategy;\n uint256 totalBorrowed;\n uint256 totalRepaid;\n uint256 totalInterestRepaid;\n uint8 decimals;\n bool restricted;\n}\n\nbytes32 constant POSITION = keccak256(\"ttoken.storage.position\");\n\n/**\n * @notice it saves the Store struct in a hashed slot\n */\nfunction store() pure returns (Store storage s_) {\n bytes32 position = POSITION;\n assembly {\n s_.slot := position\n }\n}\n" + }, + "contracts/lending/ttoken/strategies/compound/TTokenCompoundStrategy_1.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// contracts\nimport {\n RolesMods\n} from \"../../../../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN } from \"../../data.sol\";\n\n// Interfaces\nimport { ICErc20 } from \"../../../../shared/interfaces/ICErc20.sol\";\nimport { TTokenStrategy } from \"../TTokenStrategy.sol\";\n\n// Libraries\nimport {\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport { NumbersLib } from \"../../../../shared/libraries/NumbersLib.sol\";\n\n// Storage\nimport \"../../storage.sol\" as TokenStorage;\nimport \"./storage.sol\" as CompoundStorage;\n\ncontract TTokenCompoundStrategy_1 is RolesMods, TTokenStrategy {\n /**\n * @dev it creates a reference to the TToken storage\n */\n function() pure returns (TokenStorage.Store storage)\n private constant tokenStore = TokenStorage.store;\n\n /**\n * @dev it creates a reference to the Compound storage\n */\n function() pure returns (CompoundStorage.Store storage)\n private constant compoundStore = CompoundStorage.store;\n\n string public constant NAME = \"CompoundStrategy_1\";\n\n /* External Functions */\n\n /**\n * @notice it returns the total supply of an underlying asset in a Teller token.\n * @return uint256 the underlying supply\n */\n function totalUnderlyingSupply() external override returns (uint256) {\n return\n tokenStore().underlying.balanceOf(address(this)) +\n compoundStore().cToken.balanceOfUnderlying(address(this));\n }\n\n /**\n * @notice Rebalances the underlying asset held by the Teller Token.\n *\n * This strategy looks at the ratio of held underlying asset balance and balance deposited into\n * Compound. Based on the store {balanceRatioMin} and {balanceRatioMax} values, will deposit\n * (storedRatio > balanceRatioMax) or withdraw to keep the ratio within that range.\n */\n function rebalance() public override {\n (uint256 storedBal, uint256 compoundBal, uint16 storedRatio) =\n _getBalanceInfo();\n if (storedRatio > compoundStore().balanceRatioMax) {\n // Calculate median ratio to rebalance to\n uint16 medianRatio =\n (compoundStore().balanceRatioMax +\n compoundStore().balanceRatioMin) / 2;\n uint256 requiredBal =\n NumbersLib.percent(storedBal + compoundBal, medianRatio);\n uint256 amountToDeposit = storedBal - requiredBal;\n\n // Allow Compound to take underlying tokens\n SafeERC20.safeIncreaseAllowance(\n tokenStore().underlying,\n address(compoundStore().cToken),\n amountToDeposit\n );\n\n // Deposit tokens into Compound\n compoundStore().cToken.mint(amountToDeposit);\n\n emit StrategyRebalanced(NAME, msg.sender);\n } else if (storedRatio < compoundStore().balanceRatioMin) {\n // Withdraw tokens from Compound\n _withdraw(0, storedBal, compoundBal, storedRatio);\n\n emit StrategyRebalanced(NAME, msg.sender);\n }\n }\n\n /**\n * @notice Rebalances the TToken funds by indicating a minimum {amount} of underlying tokens that must be present\n * after the call.\n * @notice If the minimum amount is present, no rebalance happens.\n * @param amount Amount of underlying tokens that must be available.\n */\n function withdraw(uint256 amount) external override {\n (uint256 storedBal, uint256 compoundBal, uint16 storedRatio) =\n _getBalanceInfo();\n if (storedBal < amount) {\n _withdraw(amount, storedBal, compoundBal, storedRatio);\n }\n }\n\n /**\n * @notice it gets balances and the current ratio of the underlying asset stored on the TToken.\n * @return storedBalance_ returns the total stored balance of the current underlying token\n * @return compoundBalance_ returns the total stored balance\n * @return storedRatio_ ratio of current storedBalance_ over storedBalance_ and compoundBalance_\n */\n function _getBalanceInfo()\n internal\n returns (\n uint256 storedBalance_,\n uint256 compoundBalance_,\n uint16 storedRatio_\n )\n {\n storedBalance_ = tokenStore().underlying.balanceOf(address(this));\n compoundBalance_ = compoundStore().cToken.balanceOfUnderlying(\n address(this)\n );\n storedRatio_ = NumbersLib.ratioOf(\n storedBalance_,\n storedBalance_ + compoundBalance_\n );\n }\n\n /**\n * @notice it rebalances funds stored on the TToken by indicating an extra {amount} to withdraw.\n */\n function _withdraw(\n uint256 amount,\n uint256 storedBal,\n uint256 compoundBal,\n uint16 storedRatio\n ) internal {\n // Calculate amount to rebalance\n uint16 medianRatio =\n (compoundStore().balanceRatioMax +\n compoundStore().balanceRatioMin) / 2;\n uint256 requiredBal =\n NumbersLib.percent(\n storedBal + compoundBal - amount,\n medianRatio - storedRatio\n );\n uint256 redeemAmount = requiredBal - storedBal + amount;\n // Withdraw tokens from Compound if needed\n compoundStore().cToken.redeemUnderlying(redeemAmount);\n }\n\n /**\n * @notice Sets the Compound token that should be used to manage the underlying Teller Token asset.\n * @param cTokenAddress Address of the Compound token that has the same underlying asset as the TToken.\n * @param balanceRatioMin Percentage indicating the _ limit of underlying token balance should remain on the TToken\n * @param balanceRatioMax Percentage indicating the _ limit of underlying token balance should remain on the TToken\n */\n function init(\n address cTokenAddress,\n uint16 balanceRatioMin,\n uint16 balanceRatioMax\n ) external {\n compoundStore().cToken = ICErc20(cTokenAddress);\n compoundStore().balanceRatioMin = balanceRatioMin;\n compoundStore().balanceRatioMax = balanceRatioMax;\n }\n}\n" + }, + "contracts/lending/ttoken/strategies/TTokenStrategy.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { ERC165 } from \"@openzeppelin/contracts/utils/introspection/ERC165.sol\";\nimport { ITTokenStrategy } from \"./ITTokenStrategy.sol\";\n\nabstract contract TTokenStrategy is ITTokenStrategy, ERC165 {\n /**\n * @notice it checks if interface is supported according to the ERC165 standard\n * @param interfaceId Id of the interface in question\n */\n function supportsInterface(bytes4 interfaceId)\n public\n view\n override\n returns (bool)\n {\n return\n ERC165.supportsInterface(interfaceId) ||\n interfaceId == type(ITTokenStrategy).interfaceId;\n }\n}\n" + }, + "contracts/lending/ttoken/strategies/compound/storage.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { ICErc20 } from \"../../../../shared/interfaces/ICErc20.sol\";\n\nstruct Store {\n ICErc20 cToken;\n uint16 balanceRatioMax;\n uint16 balanceRatioMin;\n}\n\nbytes32 constant POSITION = keccak256(\n \"ttoken.strategy.compound.storage.position\"\n);\n\nfunction store() pure returns (Store storage s_) {\n bytes32 position = POSITION;\n assembly {\n s_.slot := position\n }\n}\n" + }, + "@openzeppelin/contracts/utils/introspection/ERC165.sol": { + "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n *\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\n */\nabstract contract ERC165 is IERC165 {\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return interfaceId == type(IERC165).interfaceId;\n }\n}\n" + }, + "contracts/settings/asset/libraries/AssetYVaultLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Libraries\nimport {\n CacheLib,\n Cache,\n CacheType\n} from \"../../../shared/libraries/CacheLib.sol\";\nimport { IVault } from \"../../../escrow/dapps/interfaces/IVault.sol\";\n\n// Storage\nimport { AppStorageLib } from \"../../../storage/app.sol\";\n\n/**\n * @notice Utility library of inline functions for Yearn vault asset setting.\n *\n * @author develop@teller.finance\n */\nlibrary AssetYVaultLib {\n bytes32 private constant NAME = keccak256(\"yVault\");\n\n function s(address asset) private view returns (Cache storage) {\n return AppStorageLib.store().assetSettings[asset];\n }\n\n function get(address asset) internal view returns (IVault) {\n return IVault(s(asset).addresses[NAME]);\n }\n\n function set(address asset, address newValue) internal {\n s(asset).addresses[NAME] = newValue;\n }\n}\n" + }, + "contracts/escrow/dapps/YearnFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// Storage\nimport { DappMods } from \"./DappMods.sol\";\nimport { PausableMods } from \"../../settings/pausable/PausableMods.sol\";\nimport { LibDapps } from \"./libraries/LibDapps.sol\";\nimport { LibEscrow } from \"../libraries/LibEscrow.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport { IVault } from \"./interfaces/IVault.sol\";\n\ncontract YearnFacet is PausableMods, DappMods {\n using SafeERC20 for IERC20;\n\n /**\n @notice This event is emitted when a yVault deposit is invoked successfully\n @param iVault The address of the yVault\n @param amount The amount of funds to deposit\n @param tokenBalanceBeforeDeposit The balance of tokens held after depositing\n @param tokenBalanceAfterDeposit The balance of tokens held after depositing\n */\n event YearnDeposited(\n address tokenAddress,\n address iVault,\n uint256 amount,\n uint256 tokenBalanceBeforeDeposit,\n uint256 tokenBalanceAfterDeposit\n );\n\n /**\n @notice This event is emitted when a yVault withdraw is invoked successfully\n @param underlyingToken The address of the underlying token of the vault\n @param iVault The address of the yVault\n @param amount The amount of funds to withdraw\n @param tokenBalanceBeforeWithdrawal The balance of tokens held before withdrawal\n @param tokenBalanceAfterWithdrawal The balance of tokens held after withdrawal\n */\n event YearnWithdrawn(\n address underlyingToken,\n address iVault,\n uint256 amount,\n uint256 tokenBalanceBeforeWithdrawal,\n uint256 tokenBalanceAfterWithdrawal\n );\n\n /**\n @notice Deposits the specified amount of the native unwrapped token (same as token() returns) into the Vault\n @param loanID The id of the loan being used\n @param tokenAddress The address of the token being deposited\n @param amount The amount of tokens to be deposited into the vault\n */\n function yearnDeposit(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n IVault iVault = LibDapps.getYVault(tokenAddress);\n uint256 tokenBalanceBeforeDeposit = iVault.balanceOf(address(this));\n IERC20(tokenAddress).safeApprove(address(iVault), amount);\n\n bytes memory callData = abi.encode(IVault.deposit.selector, amount);\n LibDapps.s().loanEscrows[loanID].callDapp(address(iVault), callData);\n\n uint256 tokenBalanceAfterDeposit = iVault.balanceOf(address(this));\n require(\n tokenBalanceAfterDeposit > tokenBalanceBeforeDeposit,\n \"YEARN_BALANCE_NOT_INCREASED\"\n );\n\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n LibEscrow.tokenUpdated(loanID, address(iVault));\n\n emit YearnDeposited(\n tokenAddress,\n address(iVault),\n amount,\n tokenBalanceBeforeDeposit,\n tokenBalanceAfterDeposit\n );\n }\n\n /**\n @notice Withdraws the specified amount of the native unwrapped token (same as token() returns) from the Vault\n @param loanID the id of the loan being used\n @param tokenAddress The address of the token being deposited\n @param amount The amount of tokens to be deposited into the vault\n */\n function yearnWithdraw(\n uint256 loanID,\n address tokenAddress,\n uint256 amount\n ) public paused(\"\", false) onlyBorrower(loanID) {\n IVault iVault = LibDapps.getYVault(tokenAddress);\n uint256 price = iVault.getPricePerShare();\n uint256 shares = amount / price;\n uint256 tokenBalanceBeforeWithdrawal =\n IERC20(tokenAddress).balanceOf(address(this));\n require(\n shares >= iVault.balanceOf(address(this)),\n \"INSUFFICIENT_DEPOSIT\"\n );\n\n bytes memory callData = abi.encode(IVault.withdraw.selector, shares);\n LibDapps.s().loanEscrows[loanID].callDapp(address(iVault), callData);\n\n uint256 tokenBalanceAfterWithdrawal =\n IERC20(tokenAddress).balanceOf(address(this));\n require(\n tokenBalanceAfterWithdrawal > tokenBalanceBeforeWithdrawal,\n \"WITHDRAWAL_UNSUCCESSFUL\"\n );\n\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n LibEscrow.tokenUpdated(loanID, address(iVault));\n\n emit YearnWithdrawn(\n iVault.token(),\n address(iVault),\n amount,\n tokenBalanceBeforeWithdrawal,\n tokenBalanceAfterWithdrawal\n );\n }\n\n /**\n @notice Redeems all funds from a yVault from a previous deposit\n @param loanID the id of the loan being used\n @param tokenAddress The address of the token being deposited\n */\n function yearnWithdrawAll(uint256 loanID, address tokenAddress)\n public\n paused(\"\", false)\n onlyBorrower(loanID)\n {\n IVault iVault = LibDapps.getYVault(tokenAddress);\n uint256 tokenBalanceBeforeWithdrawal =\n IERC20(tokenAddress).balanceOf(address(this));\n\n bytes memory callData = abi.encode(IVault.withdrawAll.selector);\n LibDapps.s().loanEscrows[loanID].callDapp(address(iVault), callData);\n\n uint256 tokenBalanceAfterWithdrawal =\n IERC20(tokenAddress).balanceOf(address(this));\n require(\n tokenBalanceAfterWithdrawal > tokenBalanceBeforeWithdrawal,\n \"WITHDRAWAL_UNSUCCESSFUL\"\n );\n\n LibEscrow.tokenUpdated(loanID, tokenAddress);\n LibEscrow.tokenUpdated(loanID, address(iVault));\n\n emit YearnWithdrawn(\n iVault.token(),\n address(iVault),\n tokenBalanceBeforeWithdrawal,\n tokenBalanceBeforeWithdrawal,\n tokenBalanceAfterWithdrawal\n );\n }\n}\n" + }, + "contracts/contexts2/access-control/ownership/OwnerLib.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlStorageLib, AccessControlStorage } from \"../storage.sol\";\n\nlibrary OwnerLib {\n function s() private pure returns (AccessControlStorage storage) {\n return AccessControlStorageLib.store();\n }\n\n /**\n * @dev Emitted when {owner} is set for {account}.\n */\n event OwnerSet(address indexed account, address indexed owner);\n\n /**\n * @dev Emitted when new {owner} is given ownership of {account}.\n */\n event OwnerTransferred(\n address indexed account,\n address indexed owner,\n address indexed prevOwner\n );\n\n /**\n * @notice Gets the owner for an address.\n * @param account Address to check ownership of.\n */\n function ownerOf(address account) internal view returns (address) {\n return AccessControlStorageLib.store().owners[account];\n }\n\n /**\n * @notice Sets an owner for an address.\n * @dev Should only use when circumventing admin checking.\n * @param account Address to set ownership of.\n * @param owner Address to set ownership of {account} to.\n */\n function setOwner(address account, address owner) internal {\n s().owners[account] = owner;\n emit OwnerSet(account, owner);\n }\n\n /**\n * @notice Transfers ownership of an address.\n * @dev Should only use when circumventing admin checking.\n * @param account Address to transfer ownership of.\n * @param newOwner Address to transfer ownership of {account} to.\n */\n function transferOwner(address account, address newOwner) internal {\n s().owners[account] = newOwner;\n emit OwnerTransferred(account, newOwner, msg.sender);\n }\n}\n" + }, + "contracts/contexts2/access-control/ownership/OwnerMods.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { OwnerLib } from \"./OwnerLib.sol\";\n\nabstract contract OwnerMods {\n modifier onlyOwner(address addr) {\n require(\n OwnerLib.ownerOf(addr) == msg.sender,\n \"AccessControl: not owner\"\n );\n _;\n }\n}\n" + }, + "contracts/contexts2/access-control/ownership/OwnerFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { AccessControlStorageLib } from \"../storage.sol\";\nimport { OwnerLib } from \"./OwnerLib.sol\";\nimport { RolesMods } from \"../roles/RolesMods.sol\";\nimport { ADMIN } from \"../../../shared/roles.sol\";\n\ncontract OwnerFacet is RolesMods {\n /**\n * @notice Sets an owner for an address.\n * @param account Address to set ownership of.\n * @param owner Address to set ownership of {account} to.\n *\n * Requirements:\n * - Sender must be role admin.\n */\n function setOwner(address account, address owner)\n external\n authorized(ADMIN, msg.sender)\n {\n require(\n OwnerLib.ownerOf(account) == address(0),\n \"AccessControl: owner already set\"\n );\n OwnerLib.setOwner(account, owner);\n }\n\n /**\n * @notice Transfers ownership of an address.\n * @param account Address to transfer ownership of.\n * @param owner Address to transfer ownership of {account} to.\n *\n * Requirements:\n * - Sender must be role admin.\n */\n function transferOwner(address account, address owner)\n external\n authorized(ADMIN, msg.sender)\n {\n require(\n OwnerLib.ownerOf(account) == msg.sender,\n \"AccessControl: not owner\"\n );\n OwnerLib.transferOwner(account, owner);\n }\n}\n" + }, + "contracts/lending/ttoken/strategies/aave/TTokenAaveStrategy_1.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// contracts\nimport {\n RolesMods\n} from \"../../../../contexts2/access-control/roles/RolesMods.sol\";\nimport { ADMIN } from \"../../data.sol\";\n\n// Interfaces\nimport { IAToken } from \"../../../../shared/interfaces/IAToken.sol\";\nimport {\n IAaveLendingPool\n} from \"../../../../shared/interfaces/IAaveLendingPool.sol\";\nimport { TTokenStrategy } from \"../TTokenStrategy.sol\";\n\n// Libraries\nimport {\n SafeERC20\n} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport { NumbersLib } from \"../../../../shared/libraries/NumbersLib.sol\";\nimport { LibDapps } from \"../../../../escrow/dapps/libraries/LibDapps.sol\";\n\n// Storage\nimport \"../../storage.sol\" as TokenStorage;\nimport \"./storage.sol\" as AaveStorage;\n\ncontract TTokenAaveStrategy_1 is RolesMods, TTokenStrategy {\n function() pure returns (TokenStorage.Store storage)\n private constant tokenStore = TokenStorage.store;\n\n function() pure returns (AaveStorage.Store storage)\n private constant aaveStore = AaveStorage.store;\n\n string public constant NAME = \"AaveStrategy_1\";\n\n /* External Functions */\n\n function totalUnderlyingSupply() external override returns (uint256) {\n return\n tokenStore().underlying.balanceOf(address(this)) +\n aaveStore().aToken.balanceOf(address(this));\n }\n\n /**\n * @notice Rebalances the underlying asset held by the Teller Token.\n *\n * This strategy looks at the ratio of held underlying asset balance and balance deposited into\n * Aave. Based on the store {balanceRatioMin} and {balanceRatioMax} values, will deposit or\n * withdraw to keep the ratio within that range.\n */\n function rebalance() public override {\n (uint256 storedBal, uint256 aaveBal, uint16 storedRatio) =\n _getBalanceInfo();\n if (storedRatio > aaveStore().balanceRatioMax) {\n // Calculate median ratio to rebalance to\n uint16 medianRatio =\n (aaveStore().balanceRatioMax + aaveStore().balanceRatioMin) / 2;\n uint256 requiredBal =\n NumbersLib.percent(storedBal + aaveBal, medianRatio);\n uint256 amountToDeposit = storedBal - requiredBal;\n\n IAaveLendingPool lendingPool = LibDapps.getAaveLendingPool();\n\n // Approve Aave lending pool\n SafeERC20.safeIncreaseAllowance(\n tokenStore().underlying,\n address(lendingPool),\n amountToDeposit\n );\n // Deposit into Aave\n lendingPool.deposit(\n address(tokenStore().underlying),\n amountToDeposit,\n address(this),\n 0 // TODO get referral code from Aave when applicable\n );\n\n emit StrategyRebalanced(NAME, msg.sender);\n } else {\n // Withdraw tokens from Aave\n _withdraw(0, storedBal, aaveBal, storedRatio);\n\n emit StrategyRebalanced(NAME, msg.sender);\n }\n }\n\n /**\n * @notice Rebalances the TToken funds by indicating a minimum {amount} of underlying tokens that must be present\n * after the call.\n * @notice If the minimum amount is present, no rebalance happens.\n * @param amount Amount of underlying tokens that must be available.\n */\n function withdraw(uint256 amount) external override {\n (uint256 storedBal, uint256 aaveBal, uint16 storedRatio) =\n _getBalanceInfo();\n if (storedBal < amount) {\n _withdraw(amount, storedBal, aaveBal, storedRatio);\n }\n }\n\n /**\n * @dev Gets balances and the current ratio of the underlying asset stored on the TToken.\n */\n function _getBalanceInfo()\n internal\n returns (\n uint256 storedBalance_,\n uint256 aaveBalance_,\n uint16 storedRatio_\n )\n {\n storedBalance_ = tokenStore().underlying.balanceOf(address(this));\n aaveBalance_ = aaveStore().aToken.balanceOf(address(this));\n storedRatio_ = NumbersLib.ratioOf(\n storedBalance_,\n storedBalance_ + aaveBalance_\n );\n }\n\n /**\n * @dev Rebalances funds stored on the TToken by indicating an extra {amount} to withdraw.\n */\n function _withdraw(\n uint256 amount,\n uint256 storedBal,\n uint256 aaveBal,\n uint16 storedRatio\n ) internal {\n // Calculate amount to rebalance\n uint16 medianRatio =\n (aaveStore().balanceRatioMax + aaveStore().balanceRatioMin) / 2;\n uint256 requiredBal =\n NumbersLib.percent(\n storedBal + aaveBal - amount,\n medianRatio - storedRatio\n );\n uint256 redeemAmount = requiredBal - storedBal + amount;\n // Withdraw tokens from the Aave lending pool if needed\n IAaveLendingPool lendingPool = LibDapps.getAaveLendingPool();\n lendingPool.withdraw(\n address(tokenStore().underlying),\n redeemAmount,\n address(this)\n );\n }\n\n /**\n * @notice Sets the Aave token that should be used to manage the underlying Teller Token asset.\n * @param aTokenAddress Address of the Aave token that has the same underlying asset as the TToken.\n * @param balanceRatioMin Percentage indicating the _ limit of underlying token balance should remain on the TToken\n * @param balanceRatioMax Percentage indicating the _ limit of underlying token balance should remain on the TToken\n */\n function init(\n address aTokenAddress,\n uint16 balanceRatioMin,\n uint16 balanceRatioMax\n ) external {\n aaveStore().aToken = IAToken(aTokenAddress);\n aaveStore().balanceRatioMin = balanceRatioMin;\n aaveStore().balanceRatioMax = balanceRatioMax;\n }\n}\n" + }, + "contracts/lending/ttoken/strategies/aave/storage.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { IAToken } from \"../../../../shared/interfaces/IAToken.sol\";\n\nstruct Store {\n IAToken aToken;\n uint16 balanceRatioMax;\n uint16 balanceRatioMin;\n}\n\nbytes32 constant POSITION = keccak256(\"ttoken.strategy.aave.storage.position\");\n\nfunction store() pure returns (Store storage s_) {\n bytes32 position = POSITION;\n assembly {\n s_.slot := position\n }\n}\n" + }, + "contracts/shared/facets/DiamondLoupeFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/******************************************************************************\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\n/******************************************************************************/\n\nimport { LibDiamond } from \"../libraries/LibDiamond.sol\";\nimport { IDiamondLoupe } from \"../interfaces/IDiamondLoupe.sol\";\nimport {\n IERC165\n} from \"@openzeppelin/contracts/utils/introspection/IERC165.sol\";\n\ncontract DiamondLoupeFacet is IDiamondLoupe, IERC165 {\n // Diamond Loupe Functions\n ////////////////////////////////////////////////////////////////////\n /// These functions are expected to be called frequently by tools.\n //\n // struct Facet {\n // address facetAddress;\n // bytes4[] functionSelectors;\n // }\n\n /// @notice Gets all facets and their selectors.\n /// @return facets_ Facet\n function facets() external view override returns (Facet[] memory facets_) {\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\n uint256 numFacets = ds.facetAddresses.length;\n facets_ = new Facet[](numFacets);\n for (uint256 i; i < numFacets; i++) {\n address facetAddress_ = ds.facetAddresses[i];\n facets_[i].facetAddress = facetAddress_;\n facets_[i].functionSelectors = ds.facetFunctionSelectors[\n facetAddress_\n ]\n .functionSelectors;\n }\n }\n\n /// @notice Gets all the function selectors provided by a facet.\n /// @param _facet The facet address.\n /// @return facetFunctionSelectors_\n function facetFunctionSelectors(address _facet)\n external\n view\n override\n returns (bytes4[] memory facetFunctionSelectors_)\n {\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\n facetFunctionSelectors_ = ds.facetFunctionSelectors[_facet]\n .functionSelectors;\n }\n\n /// @notice Get all the facet addresses used by a diamond.\n /// @return facetAddresses_\n function facetAddresses()\n external\n view\n override\n returns (address[] memory facetAddresses_)\n {\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\n facetAddresses_ = ds.facetAddresses;\n }\n\n /// @notice Gets the facet that supports the given selector.\n /// @dev If facet is not found return address(0).\n /// @param _functionSelector The function selector.\n /// @return facetAddress_ The facet address.\n function facetAddress(bytes4 _functionSelector)\n external\n view\n override\n returns (address facetAddress_)\n {\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\n facetAddress_ = ds.selectorToFacetAndPosition[_functionSelector]\n .facetAddress;\n }\n\n // This implements ERC-165.\n function supportsInterface(bytes4 _interfaceId)\n external\n view\n override\n returns (bool)\n {\n LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();\n return ds.supportedInterfaces[_interfaceId];\n }\n}\n" + }, + "contracts/shared/libraries/LibDiamond.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/******************************************************************************\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\n/******************************************************************************/\n\nimport { IDiamondCut } from \"../interfaces/IDiamondCut.sol\";\nimport { IDiamondLoupe } from \"../interfaces/IDiamondLoupe.sol\";\nimport {\n IERC165\n} from \"@openzeppelin/contracts/utils/introspection/IERC165.sol\";\nimport { IERC173 } from \"../interfaces/IERC173.sol\";\nimport { LibMeta } from \"./LibMeta.sol\";\n\nlibrary LibDiamond {\n bytes32 constant DIAMOND_STORAGE_POSITION =\n keccak256(\"diamond.standard.diamond.storage\");\n\n struct FacetAddressAndPosition {\n address facetAddress;\n uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\n }\n\n struct FacetFunctionSelectors {\n bytes4[] functionSelectors;\n uint16 facetAddressPosition; // position of facetAddress in facetAddresses array\n }\n\n struct DiamondStorage {\n // maps function selector to the facet address and\n // the position of the selector in the facetFunctionSelectors.selectors array\n mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\n // maps facet addresses to function selectors\n mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\n // facet addresses\n address[] facetAddresses;\n // Used to query if a contract implements an interface.\n // Used to implement ERC-165.\n mapping(bytes4 => bool) supportedInterfaces;\n // owner of the contract\n address contractOwner;\n }\n\n function diamondStorage()\n internal\n pure\n returns (DiamondStorage storage ds)\n {\n bytes32 position = DIAMOND_STORAGE_POSITION;\n assembly {\n ds.slot := position\n }\n }\n\n event OwnershipTransferred(\n address indexed previousOwner,\n address indexed newOwner\n );\n\n function setContractOwner(address _newOwner) internal {\n DiamondStorage storage ds = diamondStorage();\n address previousOwner = ds.contractOwner;\n ds.contractOwner = _newOwner;\n emit OwnershipTransferred(previousOwner, _newOwner);\n }\n\n function contractOwner() internal view returns (address contractOwner_) {\n contractOwner_ = diamondStorage().contractOwner;\n }\n\n function enforceIsContractOwner() internal view {\n require(\n LibMeta.msgSender() == diamondStorage().contractOwner,\n \"LibDiamond: Must be contract owner\"\n );\n }\n\n event DiamondCut(\n IDiamondCut.FacetCut[] _diamondCut,\n address _init,\n bytes _calldata\n );\n\n function addDiamondFunctions(\n address _diamondCutFacet,\n address _diamondLoupeFacet,\n address _ownershipFacet\n ) internal {\n IDiamondCut.FacetCut[] memory cut = new IDiamondCut.FacetCut[](3);\n bytes4[] memory functionSelectors = new bytes4[](1);\n functionSelectors[0] = IDiamondCut.diamondCut.selector;\n cut[0] = IDiamondCut.FacetCut({\n facetAddress: _diamondCutFacet,\n action: IDiamondCut.FacetCutAction.Add,\n functionSelectors: functionSelectors\n });\n functionSelectors = new bytes4[](5);\n functionSelectors[0] = IDiamondLoupe.facets.selector;\n functionSelectors[1] = IDiamondLoupe.facetFunctionSelectors.selector;\n functionSelectors[2] = IDiamondLoupe.facetAddresses.selector;\n functionSelectors[3] = IDiamondLoupe.facetAddress.selector;\n functionSelectors[4] = IERC165.supportsInterface.selector;\n cut[1] = IDiamondCut.FacetCut({\n facetAddress: _diamondLoupeFacet,\n action: IDiamondCut.FacetCutAction.Add,\n functionSelectors: functionSelectors\n });\n functionSelectors = new bytes4[](2);\n functionSelectors[0] = IERC173.transferOwnership.selector;\n functionSelectors[1] = IERC173.owner.selector;\n cut[2] = IDiamondCut.FacetCut({\n facetAddress: _ownershipFacet,\n action: IDiamondCut.FacetCutAction.Add,\n functionSelectors: functionSelectors\n });\n diamondCut(cut, address(0), \"\");\n }\n\n // Internal function version of diamondCut\n function diamondCut(\n IDiamondCut.FacetCut[] memory _diamondCut,\n address _init,\n bytes memory _calldata\n ) internal {\n for (\n uint256 facetIndex;\n facetIndex < _diamondCut.length;\n facetIndex++\n ) {\n IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\n if (action == IDiamondCut.FacetCutAction.Add) {\n addFunctions(\n _diamondCut[facetIndex].facetAddress,\n _diamondCut[facetIndex].functionSelectors\n );\n } else if (action == IDiamondCut.FacetCutAction.Replace) {\n replaceFunctions(\n _diamondCut[facetIndex].facetAddress,\n _diamondCut[facetIndex].functionSelectors\n );\n } else if (action == IDiamondCut.FacetCutAction.Remove) {\n removeFunctions(\n _diamondCut[facetIndex].facetAddress,\n _diamondCut[facetIndex].functionSelectors\n );\n } else {\n revert(\"LibDiamondCut: Incorrect FacetCutAction\");\n }\n }\n emit DiamondCut(_diamondCut, _init, _calldata);\n initializeDiamondCut(_init, _calldata);\n }\n\n function addFunctions(\n address _facetAddress,\n bytes4[] memory _functionSelectors\n ) internal {\n require(\n _functionSelectors.length > 0,\n \"LibDiamondCut: No selectors in facet to cut\"\n );\n DiamondStorage storage ds = diamondStorage();\n // uint16 selectorCount = uint16(diamondStorage().selectors.length);\n require(\n _facetAddress != address(0),\n \"LibDiamondCut: Add facet can't be address(0)\"\n );\n uint16 selectorPosition =\n uint16(\n ds.facetFunctionSelectors[_facetAddress]\n .functionSelectors\n .length\n );\n // add new facet address if it does not exist\n if (selectorPosition == 0) {\n enforceHasContractCode(\n _facetAddress,\n \"LibDiamondCut: New facet has no code\"\n );\n ds.facetFunctionSelectors[_facetAddress]\n .facetAddressPosition = uint16(ds.facetAddresses.length);\n ds.facetAddresses.push(_facetAddress);\n }\n for (\n uint256 selectorIndex;\n selectorIndex < _functionSelectors.length;\n selectorIndex++\n ) {\n bytes4 selector = _functionSelectors[selectorIndex];\n address oldFacetAddress =\n ds.selectorToFacetAndPosition[selector].facetAddress;\n require(\n oldFacetAddress == address(0),\n \"LibDiamondCut: Can't add function that already exists\"\n );\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(\n selector\n );\n ds.selectorToFacetAndPosition[selector]\n .facetAddress = _facetAddress;\n ds.selectorToFacetAndPosition[selector]\n .functionSelectorPosition = selectorPosition;\n selectorPosition++;\n }\n }\n\n function replaceFunctions(\n address _facetAddress,\n bytes4[] memory _functionSelectors\n ) internal {\n require(\n _functionSelectors.length > 0,\n \"LibDiamondCut: No selectors in facet to cut\"\n );\n DiamondStorage storage ds = diamondStorage();\n require(\n _facetAddress != address(0),\n \"LibDiamondCut: Add facet can't be address(0)\"\n );\n uint16 selectorPosition =\n uint16(\n ds.facetFunctionSelectors[_facetAddress]\n .functionSelectors\n .length\n );\n // add new facet address if it does not exist\n if (selectorPosition == 0) {\n enforceHasContractCode(\n _facetAddress,\n \"LibDiamondCut: New facet has no code\"\n );\n ds.facetFunctionSelectors[_facetAddress]\n .facetAddressPosition = uint16(ds.facetAddresses.length);\n ds.facetAddresses.push(_facetAddress);\n }\n for (\n uint256 selectorIndex;\n selectorIndex < _functionSelectors.length;\n selectorIndex++\n ) {\n bytes4 selector = _functionSelectors[selectorIndex];\n address oldFacetAddress =\n ds.selectorToFacetAndPosition[selector].facetAddress;\n require(\n oldFacetAddress != _facetAddress,\n \"LibDiamondCut: Can't replace function with same function\"\n );\n removeFunction(oldFacetAddress, selector);\n // add function\n ds.selectorToFacetAndPosition[selector]\n .functionSelectorPosition = selectorPosition;\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(\n selector\n );\n ds.selectorToFacetAndPosition[selector]\n .facetAddress = _facetAddress;\n selectorPosition++;\n }\n }\n\n function removeFunctions(\n address _facetAddress,\n bytes4[] memory _functionSelectors\n ) internal {\n require(\n _functionSelectors.length > 0,\n \"LibDiamondCut: No selectors in facet to cut\"\n );\n DiamondStorage storage ds = diamondStorage();\n // if function does not exist then do nothing and return\n require(\n _facetAddress == address(0),\n \"LibDiamondCut: Remove facet address must be address(0)\"\n );\n for (\n uint256 selectorIndex;\n selectorIndex < _functionSelectors.length;\n selectorIndex++\n ) {\n bytes4 selector = _functionSelectors[selectorIndex];\n address oldFacetAddress =\n ds.selectorToFacetAndPosition[selector].facetAddress;\n removeFunction(oldFacetAddress, selector);\n }\n }\n\n function removeFunction(address _facetAddress, bytes4 _selector) internal {\n DiamondStorage storage ds = diamondStorage();\n require(\n _facetAddress != address(0),\n \"LibDiamondCut: Can't remove function that doesn't exist\"\n );\n // an immutable function is a function defined directly in a diamond\n require(\n _facetAddress != address(this),\n \"LibDiamondCut: Can't remove immutable function\"\n );\n // replace selector with last selector, then delete last selector\n uint256 selectorPosition =\n ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\n uint256 lastSelectorPosition =\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.length -\n 1;\n // if not the same then replace _selector with lastSelector\n if (selectorPosition != lastSelectorPosition) {\n bytes4 lastSelector =\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[\n lastSelectorPosition\n ];\n ds.facetFunctionSelectors[_facetAddress].functionSelectors[\n selectorPosition\n ] = lastSelector;\n ds.selectorToFacetAndPosition[lastSelector]\n .functionSelectorPosition = uint16(selectorPosition);\n }\n // delete the last selector\n ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\n delete ds.selectorToFacetAndPosition[_selector];\n\n // if no more selectors for facet address then delete the facet address\n if (lastSelectorPosition == 0) {\n // replace facet address with last facet address and delete last facet address\n uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\n uint256 facetAddressPosition =\n ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\n if (facetAddressPosition != lastFacetAddressPosition) {\n address lastFacetAddress =\n ds.facetAddresses[lastFacetAddressPosition];\n ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\n ds.facetFunctionSelectors[lastFacetAddress]\n .facetAddressPosition = uint16(facetAddressPosition);\n }\n ds.facetAddresses.pop();\n delete ds.facetFunctionSelectors[_facetAddress]\n .facetAddressPosition;\n }\n }\n\n function initializeDiamondCut(address _init, bytes memory _calldata)\n internal\n {\n if (_init == address(0)) {\n require(\n _calldata.length == 0,\n \"LibDiamondCut: _init is address(0) but_calldata is not empty\"\n );\n } else {\n require(\n _calldata.length > 0,\n \"LibDiamondCut: _calldata is empty but _init is not address(0)\"\n );\n if (_init != address(this)) {\n enforceHasContractCode(\n _init,\n \"LibDiamondCut: _init address has no code\"\n );\n }\n (bool success, bytes memory error) = _init.delegatecall(_calldata);\n if (success == false) {\n if (error.length > 0) {\n // bubble up the error\n revert(string(error));\n } else {\n revert(\"LibDiamondCut: _init function reverted\");\n }\n }\n }\n }\n\n function enforceHasContractCode(\n address _contract,\n string memory _errorMessage\n ) internal view {\n uint256 contractSize;\n assembly {\n contractSize := extcodesize(_contract)\n }\n require(contractSize != 0, _errorMessage);\n }\n}\n" + }, + "contracts/shared/interfaces/IERC173.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title ERC-173 Contract Ownership Standard\n/// Note: the ERC-165 identifier for this interface is 0x7f5828d0\n/* is ERC165 */\ninterface IERC173 {\n /// @notice Get the address of the owner\n /// @return owner_ The address of the owner.\n function owner() external view returns (address owner_);\n\n /**\n * @notice Set the address of the new owner of the contract\n * @dev Set _newOwner to address(0) to renounce any ownership.\n * @param _newOwner The address of the new owner of the contract\n */\n function transferOwnership(address _newOwner) external;\n}\n" + }, + "contracts/shared/libraries/LibMeta.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nlibrary LibMeta {\n function getChainID() internal view returns (uint256 id) {\n assembly {\n id := chainid()\n }\n }\n\n function msgSender() internal view returns (address sender_) {\n if (msg.sender == address(this)) {\n bytes memory array = msg.data;\n uint256 index = msg.data.length;\n assembly {\n // Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those.\n sender_ := and(\n mload(add(array, index)),\n 0xffffffffffffffffffffffffffffffffffffffff\n )\n }\n } else {\n sender_ = msg.sender;\n }\n }\n}\n" + }, + "contracts/shared/facets/OwnershipFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { LibDiamond } from \"../libraries/LibDiamond.sol\";\nimport { IERC173 } from \"../interfaces/IERC173.sol\";\n\ncontract OwnershipFacet is IERC173 {\n function transferOwnership(address _newOwner) external override {\n LibDiamond.enforceIsContractOwner();\n LibDiamond.setContractOwner(_newOwner);\n }\n\n function owner() external view override returns (address owner_) {\n owner_ = LibDiamond.contractOwner();\n }\n}\n" + }, + "contracts/shared/facets/DiamondCutFacet.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/******************************************************************************\\\n* Author: Nick Mudge (https://twitter.com/mudgen)\n* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535\n/******************************************************************************/\n\nimport { IDiamondCut } from \"../interfaces/IDiamondCut.sol\";\nimport { LibDiamond } from \"../libraries/LibDiamond.sol\";\n\ncontract DiamondCutFacet is IDiamondCut {\n /// @notice Add/replace/remove any number of functions and optionally execute\n /// a function with delegatecall\n /// @param _diamondCut Contains the facet addresses and function selectors\n /// @param _init The address of the contract or facet to execute _calldata\n /// @param _calldata A function call, including function selector and arguments\n /// _calldata is executed with delegatecall on _init\n function diamondCut(\n FacetCut[] calldata _diamondCut,\n address _init,\n bytes calldata _calldata\n ) external override {\n LibDiamond.enforceIsContractOwner();\n LibDiamond.diamondCut(_diamondCut, _init, _calldata);\n }\n}\n" + }, + "contracts/contexts/access-control/internal/authorize.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./has-role.sol\";\n\nabstract contract int_authorize_AccessControl_v1 is\n int_hasRole_AccessControl_v1\n{\n function authorize(bytes32 role, address account) internal view {\n require(_hasRole(role, account), \"UNAUTHORIZED\");\n }\n}\n" + }, + "contracts/contexts/access-control/external/has-role.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { int_hasRole_AccessControl_v1 } from \"../internal/has-role.sol\";\n\ncontract ext_hasRole_AccessControl_V1 is int_hasRole_AccessControl_v1 {\n function hasRole(bytes32 role, address account)\n external\n view\n returns (bool hasRole_)\n {\n hasRole_ = _hasRole(role, account);\n }\n}\n\ncontract ext_hasRole_AccessControl is ext_hasRole_AccessControl_V1 {}\n" + }, + "contracts/contexts/access-control/external/index.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./has-role.sol\";\n" + }, + "contracts/contexts/access-control/external/admin-role-for.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {\n int_adminRoleFor_AccessControl_v1\n} from \"../internal/admin-role-for.sol\";\n\ncontract ext_adminRoleFor_AccessControl_V1 is\n int_adminRoleFor_AccessControl_v1\n{\n function adminRoleFor(bytes32 role)\n external\n view\n returns (bytes32 adminRoleFor_)\n {\n adminRoleFor_ = _adminRoleFor(role);\n }\n}\n\ncontract ext_adminRoleFor_AccessControl is int_adminRoleFor_AccessControl_v1 {}\n" + } + }, + "settings": { + "optimizer": { + "enabled": true, + "runs": 200 + }, + "outputSelection": { + "*": { + "*": [ + "abi", + "evm.bytecode", + "evm.deployedBytecode", + "evm.methodIdentifiers", + "metadata", + "devdoc", + "userdoc", + "storageLayout", + "evm.gasEstimates" + ], + "": ["ast"] + } + }, + "metadata": { + "useLiteralContent": true + } + } +} diff --git a/hardhat.config.ts b/hardhat.config.ts index f54f37e98..c15869d8b 100644 --- a/hardhat.config.ts +++ b/hardhat.config.ts @@ -7,12 +7,14 @@ import 'hardhat-gas-reporter' import { config } from 'dotenv' import { BigNumber as BN, ethers } from 'ethers' +import fs from 'fs' import { HardhatUserConfig } from 'hardhat/config' import { HardhatNetworkHDAccountsUserConfig, HardhatNetworkUserConfig, NetworkUserConfig, } from 'hardhat/types' +import path from 'path' config() @@ -59,10 +61,23 @@ const networkUrls: { [network: string]: string } = { polygon_mumbai: MATIC_MUMBAI_KEY!, } -const networkForkingBlock: { [network: string]: number } = { - mainnet: 12648380, - // polygon: 14891625, - // polygon_mumbai: 14244031, +const getLatestDeploymentBlock = (networkName: string): number | undefined => { + try { + return parseInt( + fs + .readFileSync( + path.resolve( + __dirname, + 'deployments', + networkName, + '.latestDeploymentBlock' + ) + ) + .toString() + ) + } catch { + // Network deployment does not exist + } } const networkConfig = (config: NetworkUserConfig): NetworkUserConfig => { @@ -87,7 +102,7 @@ export default { }, tenderly: { username: 'soltel', - project: 'teller', + project: 'mumbai', }, paths: { sources: 'contracts', @@ -105,10 +120,10 @@ export default { solidity: { compilers: [ { - version: '0.8.3', + version: '0.8.4', settings: { optimizer: { - enabled: true, + enabled: process.env.TESTING !== '1', runs: 200, }, }, @@ -121,6 +136,7 @@ export default { disambiguatePaths: false, }, gasReporter: { + enabled: true, currency: 'USD', coinmarketcap: CMC_KEY, outputFile: SAVE_GAS_REPORT ? 'gas-reporter.txt' : undefined, @@ -195,7 +211,7 @@ export default { : { enabled: true, url: networkUrls[FORKING_NETWORK], - blockNumber: networkForkingBlock[FORKING_NETWORK], + blockNumber: getLatestDeploymentBlock(FORKING_NETWORK), }, }), localhost: networkConfig({ diff --git a/package.json b/package.json index db108a786..d3ecee423 100644 --- a/package.json +++ b/package.json @@ -5,10 +5,11 @@ "scripts": { "setup": "./scripts/setup.sh", "hf": "hf() { local network=\"$1\"; shift; FORKING_NETWORK=$network yarn hh \"$@\"; }; hf", - "test": "test() { TS_NODE_TRANSPILE_ONLY=1 yarn hf \"$1\" test; }; test", + "test": "test() { TS_NODE_TRANSPILE_ONLY=1 TESTING=1 yarn hf \"$1\" test; }; test", + "fork": "fork() { TS_NODE_TRANSPILE_ONLY=1 yarn hf \"$1\" fork; }; fork", "lint": "eslint .", "lint:fix": "eslint . --fix", - "format:write": "prettier --write", + "format:write": "prettier --write '**/*.sol' && eslint --fix '**/*.ts'", "compile": "COMPILING=true yarn hh compile", "build": "yarn compile && yarn types && yarn tsc", "types": "yarn typechain --target ethers-v5 --outDir types/typechain 'artifacts/!(build-info)/**/+([a-zA-Z0-9]).json'", @@ -17,6 +18,7 @@ }, "dependencies": { "@chainlink/contracts": "^0.1.6", + "@ensdomains/ens-contracts": "^0.0.5", "@nomiclabs/hardhat-ethers": "^2.0.1", "@nomiclabs/hardhat-etherscan": "^2.1.0", "@nomiclabs/hardhat-waffle": "^2.0.1", @@ -65,9 +67,9 @@ "lint-staged": "^10.5.3", "mocha": "^7.1.0", "moment": "^2.29.1", - "node-fetch": "^2.6.1", + "prando": "^6.0.1", "prettier": "^2.3.1", - "prettier-plugin-solidity": "^1.0.0-beta.7", + "prettier-plugin-solidity": "prettier-solidity/prettier-plugin-solidity#aa41b1093421f6ff67a0e6b1442081e05dabe71c", "solhint": "^3.3.4", "solhint-plugin-prettier": "^0.0.5", "ts-generator": "^0.1.1", @@ -78,12 +80,15 @@ }, "husky": { "hooks": { - "pre-commit": "lint-staged" + "pre-commit": "yarn build && lint-staged" } }, "lint-staged": { - "*.{sol,js,ts,json,md}": [ + "*.sol": [ "prettier --write" + ], + "*.{js,ts}": [ + "eslint --fix" ] } } diff --git a/scripts/hh.sh b/scripts/hh.sh index 8434decc4..849af2678 100755 --- a/scripts/hh.sh +++ b/scripts/hh.sh @@ -11,7 +11,7 @@ echo -available_networks=('mainnet' 'rinkeby' 'kovan' 'ropsten') +available_networks=('mainnet' 'rinkeby' 'kovan' 'ropsten', 'polygon') ## Exit and display help output show_main_help() { diff --git a/scripts/merkle/merkle-tree.ts b/scripts/merkle/merkle-tree.ts index eb2f0b74a..faebeb75b 100644 --- a/scripts/merkle/merkle-tree.ts +++ b/scripts/merkle/merkle-tree.ts @@ -69,7 +69,7 @@ export default class MerkleTree { return bufferToHex(this.getRoot()) } - getProof(el: Buffer) { + getProof(el: Buffer): Buffer[] { let idx = this.bufferElementPositionIndex[bufferToHex(el)] if (typeof idx !== 'number') { diff --git a/tasks/fork.ts b/tasks/fork.ts index 3e1c4677b..8a071fbc7 100644 --- a/tasks/fork.ts +++ b/tasks/fork.ts @@ -12,13 +12,14 @@ interface NetworkArgs { chain: string block?: number onlyDeployment: boolean + noDeploy: boolean } export const forkNetwork: ActionType = async ( args: NetworkArgs, hre: HardhatRuntimeEnvironment ): Promise => { - const { block, onlyDeployment } = args + const { block, onlyDeployment, noDeploy } = args const { log, run, network } = hre if (network.name !== HARDHAT_NETWORK_NAME) { @@ -61,7 +62,7 @@ export const forkNetwork: ActionType = async ( await run('node', { fork: network.config.forking.url, forkBlockNumber: block ?? network.config.forking.blockNumber, - noDeploy: true, + noDeploy: noDeploy, noReset: true, }) } @@ -78,23 +79,39 @@ task('fork', 'Forks a chain and starts a JSON-RPC server of that forked chain') ) .addFlag( 'onlyDeployment', - 'optional flag that just copies the deployment files' + 'Just copies the deployment files without starting a local node' ) + .addFlag('noDeploy', 'Prevents deploy script from executing') .setAction(forkNetwork) subtask('fork:fund-deployer').setAction(async (args, hre) => { - const { ethers } = hre + const { ethers, network } = hre const [mainAccount] = await hre.getUnnamedAccounts() const { deployer } = await hre.getNamedAccounts() if ( ethers.utils.getAddress(mainAccount) !== ethers.utils.getAddress(deployer) ) { - await getFunds({ - to: deployer, - tokenSym: 'ETH', - amount: hre.ethers.utils.parseEther('1000'), - hre, - }) + const chain = process.env.FORKING_NETWORK + if ( + chain === 'mainnet' || + chain === 'kovan' || + chain === 'rinkeby' || + chain === 'ropsten' + ) { + await getFunds({ + to: deployer, + tokenSym: 'ETH', + amount: hre.ethers.utils.parseEther('1000'), + hre, + }) + } else { + await getFunds({ + to: deployer, + tokenSym: 'MATIC', + amount: hre.ethers.utils.parseEther('10000'), + hre, + }) + } } }) diff --git a/tasks/get-price.ts b/tasks/get-price.ts index 1faa79619..6a6ac3493 100644 --- a/tasks/get-price.ts +++ b/tasks/get-price.ts @@ -3,7 +3,7 @@ import { task, types } from 'hardhat/config' import { HardhatRuntimeEnvironment } from 'hardhat/types' import { getTokens } from '../config' -import { ITellerDiamond } from '../types/typechain' +import { PriceAggregator } from '../types/typechain' interface GetPricesArgs { src: string @@ -32,7 +32,7 @@ export const getPrice = async ( } const { [srcStr]: srcAddress, [dstStr]: dstAddress } = getTokens(network).all - const diamond = await contracts.get('TellerDiamond') + const priceAgg = await contracts.get('PriceAggregator') const src = await tokens.get(srcStr) const dst = await tokens.get(dstStr) @@ -42,11 +42,11 @@ export const getPrice = async ( log(``) log(`Price for ${srcStr}/${dstStr}`, { indent: 1 }) - const answer = await diamond.getPriceFor(srcAddress, dstAddress) + const answer = await priceAgg.getPriceFor(srcAddress, dstAddress) const price = FN.from(answer).divUnsafe(FN.from(dstFactor)) let value = price if (args.amount) { - const valueFor = await diamond.getValueFor( + const valueFor = await priceAgg.getValueFor( srcAddress, dstAddress, // eslint-disable-next-line @typescript-eslint/no-base-to-string diff --git a/tasks/nft/add-nft-merkles.ts b/tasks/nft/add-nft-merkles.ts index 093a80582..ee15be6d1 100644 --- a/tasks/nft/add-nft-merkles.ts +++ b/tasks/nft/add-nft-merkles.ts @@ -108,7 +108,10 @@ export const addMerkles = async ( ) log('') - log(`Output written to ${distributionsOutputFile}`, { indent: 3, star: true }) + log(`Output written to ${distributionsOutputFile}`, { + indent: 3, + star: true, + }) log('') } diff --git a/tasks/nft/add-nft-tiers.ts b/tasks/nft/add-nft-tiers.ts index 3b97e3455..8743e02bf 100644 --- a/tasks/nft/add-nft-tiers.ts +++ b/tasks/nft/add-nft-tiers.ts @@ -1,13 +1,15 @@ +import colors from 'colors' import * as ethers from 'ethers' import { task } from 'hardhat/config' import { HardhatRuntimeEnvironment } from 'hardhat/types' import { getNFT } from '../../config' -import { ITellerNFT, TellerNFT } from '../../types/typechain' -import { TellerNFTDictionary } from '../../types/typechain/TellerNFTDictionary' - +import { + ITellerNFT, + TellerNFT, + TellerNFTDictionary, +} from '../../types/typechain' import { NULL_ADDRESS } from '../../utils/consts' -import colors from 'colors' interface AddTiersArgs { sendTx?: boolean @@ -69,22 +71,22 @@ export const addTiers = async ( } log('') - log(`Setting NFT token tier mapping...`, { indent: 2, star: true, nl: false }) + log(`Setting NFT token tier mapping...`, { + indent: 2, + star: true, + nl: false, + }) /* Inject the compressedTiersMapping */ if (await nftDictionary._tokenTierMappingCompressedSet()) { log(`${'already'.yellow} set.`) } else { + const intervalID = setInterval(() => log('.', { nl: false }), 5000) + // iterate through all tokens to get their tierIndex (run a task) - const promise = new Promise(async (resolve) => { - const claimedNFTData = await getAllTellerNFTTierData(hre) - - const compressedTierData = - compressTokenTierMappingsFromArray(claimedNFTData) - resolve(compressedTierData) - }) - const intervalID = setInterval(async () => log('.', { nl: false }), 5000) - const compressedTierData = await promise + const compressedTierData = compressTokenTierMappingsFromArray( + await getAllTellerNFTTierData(hre) + ) if (compressedTierData == null) { throw new Error('Failed to compress token tier data') } @@ -96,26 +98,25 @@ export const addTiers = async ( clearInterval(intervalID) - log(` set with ${colors.cyan(`${receipt!.gasUsed} gas`)}`) + log(` set with ${colors.cyan(`${receipt.gasUsed} gas`)}`) } } const compressTokenTierMappingsFromArray = ( - tokenTiers: Array -): Array => { - let tokenTierMappingCompressed = [] + tokenTiers: ethers.BigNumber[] +): string[] => { + const tokenTierMappingCompressed = [] - let tokenTierMappingLengthMax = tokenTiers.length / 32 + const tokenTierMappingLengthMax = tokenTiers.length / 32 for (let i = 0; i < tokenTierMappingLengthMax; i++) { let newRow = '0x' for (let j = 0; j < 32; j++) { - let tokenId = i * 32 + j + const tokenId = i * 32 + j if (tokenId < tokenTiers.length) { - let tierLevelHexBytes = tokenTiers[tokenId].toHexString().substr(2) - // console.log('tier level hex bytes', tierLevelHexBytes.padStart(2, '0')) + const tierLevelHexBytes = tokenTiers[tokenId].toHexString().substr(2) newRow += tierLevelHexBytes.padStart(2, '0') } else { newRow += '00' @@ -130,12 +131,12 @@ const compressTokenTierMappingsFromArray = ( export const getAllTellerNFTTierData = async ( hre: HardhatRuntimeEnvironment -): Promise> => { +): Promise => { const { contracts, ethers, toBN } = hre const nft = await contracts.get('TellerNFT') - const info: Array = [] + const info: ethers.BigNumber[] = [] try { let nftID = ethers.BigNumber.from(0) while (await nft.ownerOf(nftID)) { diff --git a/tasks/settings/update-platform-setting.ts b/tasks/settings/update-platform-setting.ts index 33e3e5d42..cad4bba06 100644 --- a/tasks/settings/update-platform-setting.ts +++ b/tasks/settings/update-platform-setting.ts @@ -15,11 +15,8 @@ export async function updatePlatformSetting( ): Promise { const { name, value } = args const { getNamedSigner, contracts, network, ethers, log } = hre - - const deployer = await getNamedSigner('deployer') - log('') - + const deployer = await getNamedSigner('deployer') const settingNames = Object.keys(getPlatformSettings(network)) if (!settingNames.includes(name)) { log(`>>>>>> Setting name does not exist: ${name} <<<<<<`, { indent: 1 }) diff --git a/tasks/test.ts b/tasks/test.ts index e82cefc29..1aca31ccb 100644 --- a/tasks/test.ts +++ b/tasks/test.ts @@ -1,9 +1,16 @@ -import { task, types } from 'hardhat/config' +import { TASK_TEST_RUN_MOCHA_TESTS } from 'hardhat/builtin-tasks/task-names' +import { task } from 'hardhat/config' +import { subtask } from 'hardhat/config' +import { HardhatRuntimeEnvironment } from 'hardhat/types' +import Mocha from 'mocha' + +import { generateAllStoryTests } from '../test/integration/story-test-manager' task('test').setAction(async (args, hre, runSuper) => { const { run } = hre const chain = process.env.FORKING_NETWORK + if (chain == null) { throw new Error(`Invalid network to fork and run tests on: ${chain}`) } @@ -15,11 +22,51 @@ task('test').setAction(async (args, hre, runSuper) => { }) // Disable logging - // process.env.DISABLE_LOGS = 'true' + process.env.DISABLE_LOGS = 'true' // Run the actual test task await runSuper({ ...args, - deployFixture: true, + deployFixture: false, }) }) + +function createStoryTests( + mochaInstance: Mocha, + hre: HardhatRuntimeEnvironment +): number { + //custom code + const storyMochaInstance: Mocha = generateAllStoryTests(mochaInstance, hre) + + // console.log('\n\n\n\n') + + //console.log('Completed story tests.') + + return 0 +} + +// https://github.com/nomiclabs/hardhat/blob/master/packages/hardhat-core/src/builtin-tasks/test.ts +// https://github.com/cgewecke/hardhat-gas-reporter/blob/master/src/index.ts + +/** + * Overrides TASK_TEST_RUN_MOCHA_TEST to (conditionally) use eth-gas-reporter as + * the mocha test reporter and passes mocha relevant options. These are listed + * on the `gasReporter` of the user's config. + */ + +subtask(TASK_TEST_RUN_MOCHA_TESTS).setAction( + async ({ testFiles }: { testFiles: string[] }, hre, runSuper) => { + //run the gas reporter plugin + await runSuper({ testFiles }) + + const mocha = new Mocha(hre.config.mocha) + + await createStoryTests(mocha, hre) //adds them to mocha as suite + + //testFiles.forEach((file) => mocha.addFile(file)) + const testFailures = await new Promise((resolve, _) => { + mocha.run(resolve) + }) + return testFailures + } +) diff --git a/test/fixtures/markets.ts b/test/fixtures/markets.ts index 24be1119d..1760d83d0 100644 --- a/test/fixtures/markets.ts +++ b/test/fixtures/markets.ts @@ -1,5 +1,4 @@ import { BigNumberish } from 'ethers' -import hre from 'hardhat' import { HardhatRuntimeEnvironment } from 'hardhat/types' import { ERC20, ITellerDiamond } from '../../types/typechain' @@ -10,6 +9,7 @@ export interface FundedMarketArgs { // Amount should be denoted in decimal value for the token (i.e. 100 = 100 * (10^tokenDecimals) amount?: BigNumberish tags?: string[] + // fund?: boolean } export interface FundedMarketReturn { @@ -17,43 +17,44 @@ export interface FundedMarketReturn { lendingToken: ERC20 } -export const fundedMarket = hre.deployments.createFixture( - async ( - hre: HardhatRuntimeEnvironment, - opts?: FundedMarketArgs - ): Promise => { - const { contracts, deployments, getNamedSigner, toBN, tokens } = hre - const { assetSym = 'DAI', amount, tags = [] } = opts ?? {} - - tags.push('markets') - await deployments.fixture(tags) - - const diamond = await contracts.get('TellerDiamond') - const lendingToken = await tokens.get(assetSym) - - // Fund the market - let amountToFundLP: BigNumberish - if (amount) { - const decimals = await lendingToken.decimals() - amountToFundLP = toBN(amount, decimals) - } else { - amountToFundLP = await diamond.getMaxTVLAmount(lendingToken.address) - } - - const funder = await getNamedSigner('funder') - await getFunds({ - to: funder, - tokenSym: assetSym, - amount: amountToFundLP, - hre, - }) - await lendingToken.connect(funder).approve(diamond.address, amountToFundLP) - await diamond - .connect(funder) - .lendingPoolDeposit(lendingToken.address, amountToFundLP) - return { - diamond, - lendingToken, - } +export const fundedMarket = async ( + hre: HardhatRuntimeEnvironment, + opts?: FundedMarketArgs +): Promise => { + const { contracts, deployments, getNamedSigner, toBN, tokens } = hre + const { assetSym = 'DAI', amount, tags = [] } = opts ?? {} + + tags.push('markets') + await deployments.fixture(tags, { + keepExistingDeployments: true, + }) + + const diamond = await contracts.get('TellerDiamond') + const lendingToken = await tokens.get(assetSym) + + // Fund the market + let amountToFundLP: BigNumberish + if (amount) { + const decimals = await lendingToken.decimals() + amountToFundLP = toBN(amount, decimals) + } else { + amountToFundLP = await diamond.getMaxTVLAmount(lendingToken.address) } -) + + const funder = await getNamedSigner('funder') + await getFunds({ + to: funder, + tokenSym: assetSym, + amount: amountToFundLP, + hre, + }) + await lendingToken.connect(funder).approve(diamond.address, amountToFundLP) + await diamond + .connect(funder) + .lendingPoolDeposit(lendingToken.address, amountToFundLP) + return { + diamond, + lendingToken, + } +} +// ) diff --git a/test/helpers/chai-helpers.ts b/test/helpers/chai-helpers.ts deleted file mode 100644 index 97b7f840c..000000000 --- a/test/helpers/chai-helpers.ts +++ /dev/null @@ -1,18 +0,0 @@ -import chai from 'chai' -import { ethers } from 'hardhat' - -chai.Assertion.overwriteMethod( - 'eql', - (_super) => - function (this: any, ...args: any[]) { - const obj = chai.util.flag(this, 'object') - if (ethers.BigNumber.isBigNumber(obj)) { - const expected = ethers.BigNumber.isBigNumber(args[0]) - ? args[0].toString() - : args[0] - new chai.Assertion(obj.toString()).to.eql(expected, ...args.slice(1)) - } else { - _super.apply(this, args) - } - } -) diff --git a/test/helpers/get-funds.ts b/test/helpers/get-funds.ts index 345633587..bf58e9ac5 100644 --- a/test/helpers/get-funds.ts +++ b/test/helpers/get-funds.ts @@ -4,7 +4,10 @@ import { HardhatRuntimeEnvironment } from 'hardhat/types' import { getTokens } from '../../config' import { Address, TokenSymbol } from '../../types/custom/config-types' import { ERC20, IUniswapV2Router } from '../../types/typechain' -import { UNISWAP_ROUTER_V2_ADDRESS } from '../../utils/consts' +import { + SUSHISWAP_ROUTER_V2_ADDRESS_POLYGON, + UNISWAP_ROUTER_V2_ADDRESS, +} from '../../utils/consts' export interface SwapArgs { to: Address | Signer @@ -14,42 +17,68 @@ export interface SwapArgs { } export const getFunds = async (args: SwapArgs): Promise => { - const { getNamedSigner, ethers, tokens, contracts } = args.hre + const { getNamedSigner, ethers, contracts } = args.hre const funder = await getNamedSigner('funder') + // Tokens + const { all: tokenAddresses } = getTokens(args.hre.network) + + let routerAddress: string + const path: string[] = [] + // If the forked network is polygon (or something other than L1 eth) + // Use the Sushiswap router Polygon address instead of Mainnet Uniswap + switch (process.env.FORKING_NETWORK) { + case 'mainnet': + case 'kovan': + case 'rinkeby': + case 'ropsten': + routerAddress = UNISWAP_ROUTER_V2_ADDRESS + path.push(tokenAddresses.WETH) + break + case 'polygon': + case 'polygon_mumbai': + routerAddress = SUSHISWAP_ROUTER_V2_ADDRESS_POLYGON + path.push(tokenAddresses.WMATIC) + if (args.tokenSym !== 'WETH') { + path.push(tokenAddresses.WETH) + } + break + default: + throw new Error( + `Forking network is invalid: ${process.env.FORKING_NETWORK}` + ) + } + // Uniswap - https://uniswap.org/docs/v2/smart-contracts/router02/ the Router V2 instance const swapper = await contracts.get('IUniswapV2Router', { - at: UNISWAP_ROUTER_V2_ADDRESS, + at: routerAddress, from: funder, }) - // Tokens - const { all: tokenAddresses } = getTokens(args.hre.network) - const toAddress = Signer.isSigner(args.to) ? await args.to.getAddress() : args.to - if (args.tokenSym === 'ETH') { + if (args.tokenSym === 'ETH' || args.tokenSym === 'MATIC') { await funder.sendTransaction({ to: toAddress, value: args.amount, }) } else { - // ETH balance - const deployerETHBalance = await ethers.provider.getBalance( + // ETH/MATIC balance + const deployerBalance = await ethers.provider.getBalance( funder.getAddress() ) - const ethToSend = deployerETHBalance.mul('1').div('10') + const balanceToSend = deployerBalance.mul('1').div('10') - // Swap ETH for given token + // Swap ETH/WMATIC for given token await swapper.swapETHForExactTokens( args.amount, - [tokenAddresses.WETH, tokenAddresses[args.tokenSym]], + [...path, tokenAddresses[args.tokenSym]], toAddress, Date.now() + 10000, - { value: ethToSend } + { value: balanceToSend } ) } } diff --git a/test/helpers/lending-pool.ts b/test/helpers/lending-pool.ts index 76f162a33..9335d990d 100644 --- a/test/helpers/lending-pool.ts +++ b/test/helpers/lending-pool.ts @@ -1,7 +1,7 @@ import chai from 'chai' import { solidity } from 'ethereum-waffle' import { BigNumber, Signer } from 'ethers' -import { evm } from 'hardhat' +import { HardhatRuntimeEnvironment } from 'hardhat/types' import { ERC20, ITellerDiamond, ITToken } from '../../types/typechain' @@ -11,15 +11,25 @@ export interface LPHelperArgs { diamond: ITellerDiamond lendingToken: ERC20 tToken: ITToken + amount: BigNumber | null +} + +export interface LPHelpersReturn { + deposit: ReturnType + withdraw: ReturnType } /** * Creates all LP test helper functions. + * @param hre {HardhatRuntimeEnvironment} * @param args {LPHelperArgs} */ -export const getLPHelpers = (args: LPHelperArgs) => ({ - deposit: depositWithArgs(args), - withdraw: withdrawWithArgs(args), +export const getLPHelpers = ( + hre: HardhatRuntimeEnvironment, + args: LPHelperArgs +): LPHelpersReturn => ({ + deposit: depositWithArgs(hre, args), + withdraw: withdrawWithArgs(hre, args), // createLoan: creatLoanWithArgs(args), // repay: repayWithArgs(args), }) @@ -27,9 +37,11 @@ export const getLPHelpers = (args: LPHelperArgs) => ({ /** * Factory function to create a test LP helper to easily deposit and verify * state changes. + * @param hre {HardhatRuntimeEnvironment} * @param args {LPHelperArgs} */ -export const depositWithArgs = (args: LPHelperArgs) => +export const depositWithArgs = + (hre: HardhatRuntimeEnvironment, args: LPHelperArgs) => /** * LendingPool helper function for testing the deposit functionality. * - Approves the lending token amount for the lender. @@ -39,8 +51,15 @@ export const depositWithArgs = (args: LPHelperArgs) => * @param lender {Signer} Signer to call the LP as. * @param amount {BigNumber} An amount of tokens to deposit. */ - async (lender: Signer, amount: BigNumber): Promise => { + async (): Promise => { + const { getNamedSigner } = hre + const lender = await getNamedSigner('lender') + const lenderAddress = await lender.getAddress() // Approve amount to loan + const amount = + args.amount == null + ? await args.lendingToken.balanceOf(lenderAddress) + : args.amount await args.lendingToken .connect(lender) .approve(args.diamond.address, amount) @@ -55,9 +74,11 @@ export const depositWithArgs = (args: LPHelperArgs) => /** * Factory function to create a test LP helper to easily withdraw and verify * state changes. + * @param hre {HardhatRuntimeEnvironment} * @param args {LPHelperArgs} */ -export const withdrawWithArgs = (args: LPHelperArgs) => +export const withdrawWithArgs = + (hre: HardhatRuntimeEnvironment, args: LPHelperArgs) => /** * LendingPool helper function for testing the withdraw functionality. * - Estimates the exact amount of tokens to be withdrawn/burned. @@ -67,11 +88,13 @@ export const withdrawWithArgs = (args: LPHelperArgs) => * @param lender {Signer} Signer to call the LP as. * @param amount {BigNumber} Optional amount to withdraw. Defaults to withdraw all. */ - async (lender: Signer, amount?: BigNumber): Promise => { + async (): Promise => { + const { getNamedSigner } = hre + const lender = await getNamedSigner('lender') const lenderAddress = await lender.getAddress() // Withdraw - if (amount == null) { + if (args.amount == null) { await args.tToken .connect(lender) .redeem(await args.tToken.balanceOf(lenderAddress)) @@ -79,7 +102,7 @@ export const withdrawWithArgs = (args: LPHelperArgs) => } else { await args.tToken .connect(lender) - .redeemUnderlying(amount) + .redeemUnderlying(args.amount) .should.emit(args.tToken, 'Redeem') } } diff --git a/test/helpers/loans.ts b/test/helpers/loans.ts index 541dfdbc7..974e31b60 100644 --- a/test/helpers/loans.ts +++ b/test/helpers/loans.ts @@ -9,45 +9,32 @@ import { PayableOverrides, Signer, } from 'ethers' -import hre from 'hardhat' +import { HardhatRuntimeEnvironment } from 'hardhat/types' import moment from 'moment' -import { ConsoleLogger } from 'ts-generator/dist/logger' - // zkcra imports import { - initialize, - ZoKratesProvider, CompilationArtifacts, ComputationResult, + initialize, Proof, SetupKeypair, - //@ts-ignore + ZoKratesProvider, + // @ts-expect-error: because we are looking for the /node pkg } from 'zokrates-js/node' -import fetch from 'node-fetch' -// import zkcra from '../fixtures/zkcra.json' -// const out = 'https://ipfs.io/ipfs/QmeWAsv22oPBK2Rk8Jdj49CGjpz8fMivSzozmvARWGVqY8?filename=out' + const zkcraJson = `https://ipfs.io/ipfs/QmPRctNbW2q1TdrJAp2E1CkafJuCEzDKYtrqpYoHDkpXuR?filename=zkcra.json` -import scores from '../fixtures/zk-scores' +import { JsonRpcBatchProvider } from '@ethersproject/providers' +import { readFileSync, writeFile, writeFileSync } from 'fs' +import { join } from 'path' // teller files -import { getNFT } from '../../config' +import { getNativeToken } from '../../config' import { claimNFT, getPrice } from '../../tasks' import { ERC20, ITellerDiamond, TellerNFT } from '../../types/typechain' +import scores from '../fixtures/zk-scores' +import { getFunds } from './get-funds' import { mockCRAResponse } from './mock-cra-response' -import { readFileSync, writeFile, writeFileSync } from 'fs' -import { join } from 'path' -import { JsonRpcBatchProvider } from '@ethersproject/providers' -const { - getNamedSigner, - getNamedAccounts, - contracts, - tokens, - ethers, - toBN, - evm, -} = hre - export enum LoanType { ZERO_COLLATERAL, UNDER_COLLATERALIZED, @@ -76,10 +63,12 @@ export interface LoanHelpersReturn { } export const loanHelpers = async ( + hre: HardhatRuntimeEnvironment, loanID: string ): Promise => { + const { contracts } = hre const diamond = await contracts.get('TellerDiamond') - const details = await loanDetails(loanID) + const details = await loanDetails(hre, loanID) return { diamond, details, @@ -91,7 +80,7 @@ export const loanHelpers = async ( needed: () => collateralNeeded({ diamond, details }), current: () => collateralCurrent({ diamond, details }), deposit: (amount: BigNumberish, from?: Signer) => - depositCollateral({ diamond, details, amount, from }), + depositCollateral(hre, { diamond, details, amount, from }), withdraw: (amount: BigNumberish, from?: Signer) => withdrawCollateral({ diamond, details, amount, from }), }, @@ -105,7 +94,7 @@ interface CreateLoanWithNftArgs { amountBN?: BigNumberish duration?: moment.Duration } -interface CreateLoanArgs { +export interface CreateLoanArgs { lendToken: string | ERC20 collToken: string | ERC20 loanType: LoanType @@ -135,6 +124,7 @@ export interface CreateLoanReturn { getHelpers: () => Promise } export const createLoan = async ( + hre: HardhatRuntimeEnvironment, args: CreateLoanArgs ): Promise => { const { @@ -145,15 +135,18 @@ export const createLoan = async ( amountBN, duration = moment.duration(1, 'day'), } = args + const { contracts, tokens, getNamedAccounts, toBN } = hre const diamond = await contracts.get('TellerDiamond') const lendingToken = typeof lendToken === 'string' ? await tokens.get(lendToken) : lendToken + const collateralToken = typeof collToken === 'string' ? await tokens.get(collToken) : collToken const borrower = args.borrower ?? (await getNamedAccounts()).borrower const loanAmount = amountBN ?? toBN(amount, await lendingToken.decimals()) // Set up collateral let collateralRatio = 0 + switch (loanType) { case LoanType.ZERO_COLLATERAL: break @@ -165,7 +158,7 @@ export const createLoan = async ( break } // Get mock cra request and response - const craReturn = await mockCRAResponse({ + const craReturn = await mockCRAResponse(hre, { lendingToken: lendingToken.address, loanAmount, loanTermLength: duration.asSeconds(), @@ -175,7 +168,7 @@ export const createLoan = async ( }) // Create loan with terms const tx = diamond - .connect(ethers.provider.getSigner(borrower)) + .connect(hre.ethers.provider.getSigner(borrower)) .createLoanWithTerms( craReturn.request, [craReturn.responses], @@ -188,99 +181,7 @@ export const createLoan = async ( await tx const allBorrowerLoans = await diamond.getBorrowerLoans(borrower) const loanID = allBorrowerLoans[allBorrowerLoans.length - 1].toString() - return await loanHelpers(loanID) - }, - } -} - -/** - * @description: function helper that sets the collateral token and ratio and creates a mock CRA - * response to plug into the newly merged create loan function that: - * - sets the terms - * - deposits collateral - * - takes out the loan - * - * @param args: CreateLoanArgs parameters to create the loan - * @returns: Promise helper variables to help run our tests - */ -export const takeOutLoanWithoutNfts = async ( - args: CreateLoanArgs -): Promise => { - const { - lendToken, - collToken, - loanType, - amount = 100, - amountBN, - duration = moment.duration(1, 'day'), - } = args - - // define diamond contract - const diamond = await contracts.get('TellerDiamond') - - // lending token - const lendingToken = - typeof lendToken === 'string' ? await tokens.get(lendToken) : lendToken - - // collateral token - const collateralToken = - typeof collToken === 'string' ? await tokens.get(collToken) : collToken - - // set borrower and loan amount - const borrower = args.borrower ?? (await getNamedAccounts()).borrower - const loanAmount = amountBN ?? toBN(amount, await lendingToken.decimals()) - - // depending on the loan type, we set a different collateral ratio. 10000 = 100% - let collateralRatio = 0 - switch (loanType) { - case LoanType.ZERO_COLLATERAL: - break - case LoanType.UNDER_COLLATERALIZED: - collateralRatio = 5000 - break - case LoanType.OVER_COLLATERALIZED: - collateralRatio = 15000 - break - } - - // create our mock CRA response - const craReturn = await mockCRAResponse({ - lendingToken: lendingToken.address, - loanAmount, - loanTermLength: duration.asSeconds(), - collateralRatio: collateralRatio, - interestRate: '400', - borrower, - }) - - const { value: collValue } = await getPrice( - { - src: await lendingToken.symbol(), - dst: await collateralToken.symbol(), - amount: hre.fromBN(loanAmount, await lendingToken.decimals()), - }, - hre - ) - const collAmount = hre.toBN(collValue, await collateralToken.decimals()) - - // call the takeOutLoan function from the diamond - const tx = diamond - .connect(ethers.provider.getSigner(borrower)) - .takeOutLoan( - { request: craReturn.request, responses: craReturn.responses }, - collateralToken.address, - collAmount, - { value: collAmount.toString() } - ) - - // return our transaction and our helper variable - return { - tx, - getHelpers: async (): Promise => { - await tx - const allBorrowerLoans = await diamond.getBorrowerLoans(borrower) - const loanID = allBorrowerLoans[allBorrowerLoans.length - 1].toString() - return await loanHelpers(loanID) + return await loanHelpers(hre, loanID) }, } } @@ -291,22 +192,17 @@ export const takeOutLoanWithoutNfts = async ( * @returns Promise that gives us data to help run our tests */ export const takeOutLoanWithNfts = async ( + hre: HardhatRuntimeEnvironment, args: CreateLoanWithNftArgs ): Promise => { + const { contracts, tokens, toBN, getNamedSigner } = hre const { lendToken, amount = 100, duration = moment.duration(1, 'day') } = args // diamond contract const diamond = await contracts.get('TellerDiamond') - // lending token - const lendingToken = - typeof lendToken === 'string' ? await tokens.get(lendToken) : lendToken - - // amount in loan - const loanAmount = toBN(amount, await lendingToken.decimals()) - // get the borrower, deployer and borrower's signer - const deployer = await getNamedSigner('deployer') + // const deployer = await getNamedSigner('deployer') const borrower = '0x86a41524cb61edd8b115a72ad9735f8068996688' const { signer: borrowerSigner } = await hre.evm.impersonate(borrower) @@ -327,23 +223,15 @@ export const takeOutLoanWithNfts = async ( // Stake NFTs by transferring from the msg.sender (borrower) to the diamond await diamond.connect(borrowerSigner).stakeNFTs(ownedNFTs) - // Create mockCRAResponse - const craReturn = await mockCRAResponse({ - lendingToken: lendingToken.address, - loanAmount, - loanTermLength: duration.asSeconds(), - collateralRatio: 0, - interestRate: '400', - borrower, - }) - // plug it in the takeOutLoanWithNfts function along with the proofs to apply to the loan! - const tx = diamond - .connect(borrowerSigner) - .takeOutLoanWithNFTs( - { request: craReturn.request, responses: craReturn.responses }, - ownedNFTs - ) + const tx = diamond.connect(borrowerSigner).takeOutLoanNFTs( + { + borrower, + assetAddress: '0x6b175474e89094c44da98b954eedeac495271d0f', + duration: moment.duration(1, 'day').asSeconds(), + }, + ownedNFTs + ) // return our transaction and our helper variables return { @@ -352,15 +240,18 @@ export const takeOutLoanWithNfts = async ( await tx const allBorrowerLoans = await diamond.getBorrowerLoans(borrower) const loanID = allBorrowerLoans[allBorrowerLoans.length - 1].toString() - return await loanHelpers(loanID) + return await loanHelpers(hre, loanID) }, } } // we fill zkCRAConfigInfo before we sign export const fillZKCRAConfigInfo = async ( + hre: HardhatRuntimeEnvironment, args: ZKCRAConfigArgs ): Promise => { + const { getNamedAccounts, getNamedSigner, contracts } = hre + const diamond = await contracts.get('TellerDiamond') // get signers (providers) @@ -405,14 +296,16 @@ export const fillZKCRAConfigInfo = async ( } export const outputCraValues = async ( + hre: HardhatRuntimeEnvironment, goodScore: boolean ): Promise => { + const { getNamedAccounts, contracts } = hre // local variables let zokratesProvider: ZoKratesProvider - let compilationArtifacts: CompilationArtifacts + let compilationArtifacts: CompilationArtifacts = null let keyPair: SetupKeypair let computation: ComputationResult - let proof: Proof + let proof: Proof = null // set provider after initialization const provider: ZoKratesProvider = await initialize() console.log('provider initialized') @@ -429,42 +322,10 @@ export const outputCraValues = async ( endfor return MARKET_SCORE,commitments` - // const uint8Array = new Uint8Array(JSON.parse(JSON.stringify(zkcra)).program) - // console.log('fetching zkcra json') - // let zkcra: any - // try { - // zkcra = await fetch(zkcraJson) - // } catch (err) { - // console.log('error found: ' + err) - // } - // console.log('fetched') - // const response = await zkcra.json() - // console.log(response) - // const uint8Array = new Uint8Array(response.program.data) - // const abi = response.abi - // const compArtifact = { program: uint8Array, abi: abi } - // console.log(compArtifact) - // compile into circuit console.log('about to compile source') compilationArtifacts = provider.compile(source) console.log('compiled source') - // const programArray = compilationArtifacts.program - // const programBuffer = programArray.buffer - // const objectToAdd = { - // program: Buffer.from(programBuffer), - // abi: compilationArtifacts.abi, - // } - // // console.log(JSON.stringify(objectToAdd)) - // // writeFileSync( - // // join(__dirname, '../fixtures/zkcra.json'), - // // JSON.stringify(objectToAdd), - // // { encoding: 'utf-8' } - // // ) - - // generate keypair - // keyPair = provider.setup(compilationArtifacts.program) - // console.log('got keypair') // get borrower nonce and identifier const diamond = await contracts.get('TellerDiamond') @@ -508,34 +369,40 @@ export const outputCraValues = async ( } // take out function with zkcra implemented export const borrowWithZKCRA = async ( + hre: HardhatRuntimeEnvironment, args: CreateLoanWithZKCRA ): Promise => { // get proof and witness from args + const { getNamedAccounts, getNamedSigner, contracts, ethers, tokens, toBN } = + hre + const { proof, computation, providerAddresses } = args const diamond = await contracts.get('TellerDiamond') // cutting the proof inputs and concatenating them into our input variables - const firstInput = - '0x' + - proof.inputs - .slice(2, 10) - .map((input: string) => input.substr(2).substr(56)) - .join('') - - const secondInput = - '0x' + - proof.inputs - .slice(10, 18) - .map((input: string) => input.substr(2).substr(56)) - .join('') - - const thirdInput = - '0x' + - proof.inputs - .slice(18, 26) - .map((input: string) => input.substr(2).substr(56)) - .join('') + const firstProofSlice: string = proof.inputs + .slice(2, 10) + .map((input: string) => input.substr(2).substr(56)) + .join('') + + const secondProofSlice: string = proof.inputs + .slice(10, 18) + .map((input: string) => input.substr(2).substr(56)) + .join('') + + const thirdProofSlice: string = proof.inputs + .slice(18, 26) + .map((input: string) => input.substr(2).substr(56)) + .join('') + + const firstInput = '0x' + firstProofSlice + + const secondInput = '0x' + secondProofSlice + + const thirdInput = '0x' + thirdProofSlice + + console.log('Third input made') // get the signer const signer = await getNamedSigner('craSigner') // get the time stamp @@ -581,6 +448,7 @@ export const borrowWithZKCRA = async ( } // third signature + console.log('about to sign third signature') const timestampThree = moment().unix() const messageThree = ethers.BigNumber.from(thirdInput) .xor(timestampThree) @@ -597,6 +465,7 @@ export const borrowWithZKCRA = async ( }, signedAt: timestampThree, } + console.log('signed all data') // all borrow variables const proof_ = proof.proof @@ -616,6 +485,7 @@ export const borrowWithZKCRA = async ( // collateral amount const collAmount = '100000' + console.log('coll amount ') // create loan user request object const request_ = { borrower: borrower, @@ -623,8 +493,9 @@ export const borrowWithZKCRA = async ( assetAmount: assetAmount, collateralAsset: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2', collateralAmount: collAmount, - collateralRatio: 500, + collateralRatio: 5000, duration: moment.duration(1, 'day').asSeconds(), + code: 2, } // teller market address @@ -645,7 +516,7 @@ export const borrowWithZKCRA = async ( } const tx = diamond .connect(ethers.provider.getSigner(borrower)) - .takeOutLoan(loanRequest, collToken, collAmount) + .takeOutLoanSnark(loanRequest, collToken, collAmount) return { tx, @@ -653,7 +524,7 @@ export const borrowWithZKCRA = async ( await tx const allBorrowerLoans = await diamond.getBorrowerLoans(borrower) const loanID = allBorrowerLoans[allBorrowerLoans.length - 1].toString() - return await loanHelpers(loanID) + return await loanHelpers(hre, loanID) }, } } @@ -672,8 +543,10 @@ interface LoanDetailsReturn { refresh: () => ReturnType } const loanDetails = async ( + hre: HardhatRuntimeEnvironment, loanID: BigNumberish ): Promise => { + const { contracts, tokens } = hre const diamond = await contracts.get('TellerDiamond') const loan = await diamond.getLoan(loanID) const lendingToken = await tokens.get(loan.lendingToken) @@ -681,7 +554,7 @@ const loanDetails = async ( const debt = await diamond.getDebtOwed(loan.id) const totalOwed = debt.principalOwed.add(debt.interestOwed) const terms = await diamond.getLoanTerms(loan.id) - const signer = await ethers.provider.getSigner(loan.borrower) + const signer = await hre.ethers.provider.getSigner(loan.borrower) return { loan, lendingToken, @@ -690,7 +563,7 @@ const loanDetails = async ( totalOwed, terms, borrower: { address: loan.borrower, signer }, - refresh: () => loanDetails(loanID), + refresh: () => loanDetails(hre, loanID), } } @@ -705,6 +578,7 @@ interface DepositCollateralArgs extends CommonLoanArgs { } const depositCollateral = async ( + hre: HardhatRuntimeEnvironment, args: DepositCollateralArgs ): Promise => { const { @@ -713,12 +587,13 @@ const depositCollateral = async ( amount = await collateralNeeded({ diamond, details }), from = details.borrower.signer, } = args + const { tokens } = hre const weth = await tokens.get('WETH') const collateralToken = await tokens.get(details.loan.collateralToken) const options: PayableOverrides = {} if ( - ethers.utils.getAddress(details.loan.collateralToken) == - ethers.utils.getAddress(weth.address) + hre.ethers.utils.getAddress(details.loan.collateralToken) == + hre.ethers.utils.getAddress(weth.address) ) { options.value = amount } else { @@ -742,9 +617,8 @@ const collateralNeeded = async ( args: CollateralNeededArgs ): Promise => { const { diamond, details } = args - const { neededInCollateralTokens } = await diamond.getCollateralNeededInfo( - details.loan.id - ) + const { neededInCollateralTokens } = + await diamond.callStatic.getCollateralNeededInfo(details.loan.id) return neededInCollateralTokens } interface CollateralCurrentArgs extends CommonLoanArgs {} @@ -754,10 +628,12 @@ const collateralCurrent = async ( const { diamond, details } = args return await diamond.getLoanCollateral(details.loan.id) } -interface RepayLoanArgs extends CommonLoanArgs { +export interface RepayLoanArgs extends CommonLoanArgs { amount: BigNumberish } -const repayLoan = async (args: RepayLoanArgs): Promise => { +export const repayLoan = async ( + args: RepayLoanArgs +): Promise => { const { diamond, details: { loan, borrower }, @@ -766,7 +642,7 @@ const repayLoan = async (args: RepayLoanArgs): Promise => { } = args return await diamond.connect(from).repayLoan(loan.id, amount) } -const escrowRepayLoan = async ( +export const escrowRepayLoan = async ( args: RepayLoanArgs ): Promise => { const { diff --git a/test/helpers/mock-cra-response.ts b/test/helpers/mock-cra-response.ts index ee582d4a6..17312304f 100644 --- a/test/helpers/mock-cra-response.ts +++ b/test/helpers/mock-cra-response.ts @@ -1,12 +1,11 @@ import { BytesLike } from '@ethersproject/bytes' -import { BigNumberish, Signature } from 'ethers' -import hre from 'hardhat' +import { BigNumberish } from 'ethers' +// import hre from 'hardhat' +import { HardhatRuntimeEnvironment } from 'hardhat/types' import { ITellerDiamond } from '../../types/typechain' import { NULL_ADDRESS } from '../../utils/consts' -const { contracts, getNamedSigner, ethers } = hre - interface CRAArgs { lendingToken: string loanAmount: BigNumberish @@ -46,14 +45,20 @@ export interface CRAReturn { responses: CRAResponse[] } -export const mockCRAResponse = async (args: CRAArgs): Promise => { +export const mockCRAResponse = async ( + hre: HardhatRuntimeEnvironment, + args: CRAArgs +): Promise => { + const { contracts, getNamedSigner, ethers } = hre const network = await ethers.provider.getNetwork() const chainId = network.chainId.toString() const diamond = await contracts.get('TellerDiamond') const { length: nonce } = await diamond.getBorrowerLoans(args.borrower) - const requestTime = ethers.BigNumber.from(Date.now()).div(1000) + const { timestamp: currentTimestamp } = await ethers.provider.getBlock( + 'latest' + ) const request: CRARequest = { borrower: args.borrower, recipient: args.recipient ?? NULL_ADDRESS, @@ -61,7 +66,7 @@ export const mockCRAResponse = async (args: CRAArgs): Promise => { requestNonce: nonce, amount: args.loanAmount, duration: args.loanTermLength, - requestTime, + requestTime: currentTimestamp, } const requestHash = ethers.utils.keccak256( ethers.utils.defaultAbiCoder.encode( @@ -80,13 +85,12 @@ export const mockCRAResponse = async (args: CRAArgs): Promise => { request.amount, nonce, request.duration, - requestTime, + currentTimestamp, chainId, ] ) ) - const responseTime = ethers.BigNumber.from(Date.now()).div(1000) const responseHash = ethers.utils.keccak256( ethers.utils.defaultAbiCoder.encode( [ @@ -102,7 +106,7 @@ export const mockCRAResponse = async (args: CRAArgs): Promise => { args.lendingToken, args.loanAmount, requestHash, - responseTime, + currentTimestamp, args.interestRate, args.collateralRatio, chainId, @@ -118,7 +122,7 @@ export const mockCRAResponse = async (args: CRAArgs): Promise => { responses.push({ signer: await signer.getAddress(), assetAddress: args.lendingToken, - responseTime, + responseTime: currentTimestamp, interestRate: args.interestRate, collateralRatio: args.collateralRatio, maxLoanAmount: args.loanAmount, diff --git a/test/helpers/story/drivers/dapp-story-test-driver.ts b/test/helpers/story/drivers/dapp-story-test-driver.ts new file mode 100644 index 000000000..650b16ed5 --- /dev/null +++ b/test/helpers/story/drivers/dapp-story-test-driver.ts @@ -0,0 +1,157 @@ +import chai from 'chai' +import { solidity } from 'ethereum-waffle' +import { HardhatRuntimeEnvironment } from 'hardhat/types' +import { Test } from 'mocha' + +import { TestAction, TestScenario } from '../story-helpers' +import { aaveLendTest } from './dapp-utils/aave.utils' +import { + compoundClaimTest, + compoundLendTest, +} from './dapp-utils/compound.utils' +import { poolTogetherLendTest } from './dapp-utils/poolTogether.utils' +import { sushiswapSwapTest } from './dapp-utils/sushiswap.utils' +import { uniswapSwapTest } from './dapp-utils/uniswap.utils' +import { yearnLendTest } from './dapp-utils/yearn.utils' +import StoryTestDriver from './story-test-driver' +chai.should() +chai.use(solidity) + +/* +We will read state data from the chaindata to determine whether or not each 'action' should pass or fail at the current moment +Then we will expect that +*/ + +export default class DappStoryTestDriver extends StoryTestDriver { + static generateDomainSpecificTestsForScenario( + hre: HardhatRuntimeEnvironment, + scenario: TestScenario, + parentSuite: Mocha.Suite + ): Mocha.Suite { + const scenarioActions = scenario.actions + + for (const action of scenarioActions) { + const testsForAction: Test[] = DappStoryTestDriver.generateTestsForAction( + hre, + action, + parentSuite + ) + for (const test of testsForAction) { + parentSuite.addTest(test) + } + } + return parentSuite + } + + static generateTestsForAction( + hre: HardhatRuntimeEnvironment, + action: TestAction, + testSuite: Mocha.Suite + ): Test[] { + // const _ = testSuite.tests + const tests: Test[] = [] + const actionParentType = action.actionParentType + switch (actionParentType) { + case 'LEND': { + DappStoryTestDriver.generateTestsForLend(hre, action, tests) + break + } + case 'SWAP': { + void DappStoryTestDriver.generateTestsForSwap(hre, action, tests) + break + } + case 'CLAIM': { + void DappStoryTestDriver.generateTestsForClaim(hre, action, tests) + break + } + } + + return tests + } + + static generateTestsForLend( + hre: HardhatRuntimeEnvironment, + action: TestAction, + tests: Test[] + ): void { + const actionType = action.actionType + switch (actionType) { + case 'AAVE': { + const newTest = new Test('AAVE Lend DAPP', async () => { + await aaveLendTest(hre) + }) + tests.push(newTest) + break + } + case 'YEARN': { + const newTest = new Test('YEARN Lend DAPP', async () => { + await yearnLendTest(hre) + }) + tests.push(newTest) + break + } + case 'COMPOUND': { + const newTest = new Test('COMPOUND Lend DAPP', async () => { + await compoundLendTest(hre) + }) + tests.push(newTest) + break + } + case 'POOL_TOGETHER': { + const newTest = new Test('POOL_TOGETHER Lend DAPP', async () => { + await poolTogetherLendTest(hre) + }) + tests.push(newTest) + break + } + default: + break + } + } + + static async generateTestsForSwap( + hre: HardhatRuntimeEnvironment, + action: TestAction, + tests: Test[] + ): Promise { + const { getNamedSigner } = hre + const dapp = action.actionType + switch (dapp) { + case 'UNISWAP': { + const newTest = new Test('UNISWAP Swap DAPP', async () => { + await uniswapSwapTest(hre) + }) + tests.push(newTest) + break + } + case 'SUSHISWAP': { + const newTest = new Test('SUSHISWAP Swap DAPP', async () => { + await sushiswapSwapTest(hre) + }) + tests.push(newTest) + break + } + default: + break + } + } + + static async generateTestsForClaim( + hre: HardhatRuntimeEnvironment, + action: TestAction, + tests: Test[] + ): Promise { + const dapp = action.actionType + switch (dapp) { + case 'COMPOUND': { + const newTest = new Test('COMPOUND Claim COMP', async () => { + await compoundClaimTest(hre) + }) + tests.push(newTest) + break + } + default: + break + } + } +} diff --git a/test/helpers/story/drivers/dapp-utils/aave.utils.ts b/test/helpers/story/drivers/dapp-utils/aave.utils.ts new file mode 100644 index 000000000..7fe86b4e1 --- /dev/null +++ b/test/helpers/story/drivers/dapp-utils/aave.utils.ts @@ -0,0 +1,82 @@ +import chai, { expect } from 'chai' +import { solidity } from 'ethereum-waffle' +import { HardhatRuntimeEnvironment } from 'hardhat/types' + +import { IAToken } from '../../../../../types/typechain' +import { LoanHelpersReturn } from '../../../loans' +import LoanStoryTestDriver from '../loan-story-test-driver' +chai.should() +chai.use(solidity) + +async function lendAave( + hre: HardhatRuntimeEnvironment, + loan: LoanHelpersReturn +): Promise { + const { contracts } = hre + const { details, diamond } = loan + const aToken = await contracts.get('IAToken', { + at: await diamond.getAssetAToken(details.lendingToken.address), + }) + await diamond + .connect(details.borrower.signer) + .aaveDeposit( + details.loan.id, + details.loan.lendingToken, + details.loan.borrowedAmount + ) + + const escrowAddress = await diamond.getLoanEscrow(details.loan.id) + + const aDaiBalance = await aToken.balanceOf(escrowAddress) + + aDaiBalance.eq(details.loan.borrowedAmount).should.eql(true, '') + + const tokenAddresses = await diamond.getEscrowTokens(details.loan.id) + tokenAddresses.should.include(aToken.address) +} + +async function withdrawAave( + hre: HardhatRuntimeEnvironment, + loan: LoanHelpersReturn +): Promise { + const { contracts } = hre + const { details, diamond } = loan + const aToken = await contracts.get('IAToken', { + at: await diamond.getAssetAToken(details.lendingToken.address), + }) + await diamond + .connect(details.borrower.signer) + .aaveWithdrawAll(details.loan.id, details.lendingToken.address) + + const escrowAddress = await diamond.getLoanEscrow(details.loan.id) + + const tokenAddresses = await diamond.getEscrowTokens(details.loan.id) + tokenAddresses.should.not.include(aToken.address) + + const aDaiBalance = await aToken.balanceOf(escrowAddress) + aDaiBalance.eq(0).should.eql(true, '') +} + +export const aaveLendTest = async ( + hre: HardhatRuntimeEnvironment +): Promise => { + const { getNamedSigner } = hre + const borrower = await getNamedSigner('borrower') + const loan = await LoanStoryTestDriver.getLoan(hre, borrower) + const { details } = loan + const borrowedAmount = await details.lendingToken.balanceOf( + details.borrower.address + ) + let shouldPass = true + if (!loan) { + shouldPass = false + } + if (borrowedAmount.gt(details.loan.borrowedAmount)) shouldPass = false + if (shouldPass) { + await lendAave(hre, loan) + } else { + await lendAave(hre, loan).catch((error) => { + expect(error).to.exist + }) + } +} diff --git a/test/helpers/story/drivers/dapp-utils/compound.utils.ts b/test/helpers/story/drivers/dapp-utils/compound.utils.ts new file mode 100644 index 000000000..6057c7d32 --- /dev/null +++ b/test/helpers/story/drivers/dapp-utils/compound.utils.ts @@ -0,0 +1,143 @@ +import { BigNumber } from '@ethersproject/bignumber' +import chai, { expect } from 'chai' +import { solidity } from 'ethereum-waffle' +import { HardhatRuntimeEnvironment } from 'hardhat/types' + +import { getDappAddresses } from '../../../../../config' +import { ICErc20, IComptroller } from '../../../../../types/typechain' +import { getFunds } from '../../../get-funds' +import { LoanHelpersReturn } from '../../../loans' +import LoanStoryTestDriver from '../loan-story-test-driver' +chai.should() +chai.use(solidity) + +async function lendCompound( + hre: HardhatRuntimeEnvironment, + loan: LoanHelpersReturn +): Promise { + const { contracts } = hre + const { details, diamond } = loan + await details.lendingToken + .connect(details.borrower.signer) + .approve( + diamond.address, + BigNumber.from(details.loan.borrowedAmount).mul(2) + ) + const cToken = await contracts.get('ICErc20', { + at: await diamond.getAssetCToken(details.lendingToken.address), + }) + await diamond + .connect(details.borrower.signer) + .compoundLend( + details.loan.id, + details.loan.lendingToken, + details.loan.borrowedAmount + ) + const escrowAddress = await diamond.getLoanEscrow(details.loan.id) + const cDaiBalance = await cToken.balanceOf(escrowAddress) + cDaiBalance.eq(0).should.eql(false, '') + + const tokenAddresses = await diamond.getEscrowTokens(details.loan.id) + tokenAddresses.should.include(cToken.address) +} + +async function withdrawCompound( + hre: HardhatRuntimeEnvironment, + loan: LoanHelpersReturn +): Promise { + const { contracts } = hre + const { details, diamond } = loan + await details.lendingToken + .connect(details.borrower.signer) + .approve( + diamond.address, + BigNumber.from(details.loan.borrowedAmount).mul(2) + ) + const cToken = await contracts.get('ICErc20', { + at: await diamond.getAssetCToken(details.lendingToken.address), + }) + await diamond + .connect(details.borrower.signer) + .compoundRedeemAll(details.loan.id, details.lendingToken.address) + const escrowAddress = await diamond.getLoanEscrow(details.loan.id) + + const tokenAddresses = await diamond.getEscrowTokens(details.loan.id) + tokenAddresses.should.not.include(cToken.address) + + const cDaiBalance = await cToken.balanceOf(escrowAddress) + cDaiBalance.eq(0).should.eql(true, 'cDaiBalance should equal zero') +} + +async function claimComp( + hre: HardhatRuntimeEnvironment, + loan: LoanHelpersReturn +): Promise { + const { contracts, network } = hre + const { details, diamond } = loan + const dappAddresses = getDappAddresses(network) + const Comptroller = await contracts.get('IComptroller', { + at: dappAddresses.compoundComptrollerAddress, + }) + const escrowAddress = await diamond.getLoanEscrow(details.loan.id) + const compBefore = await Comptroller.compAccrued(escrowAddress) + expect(BigNumber.from(compBefore).gt(0)).to.equal(true) + await diamond + .connect(details.borrower.signer) + .compoundClaimComp(details.loan.id) + const compafter = await Comptroller.compAccrued(escrowAddress) + expect(compafter.toString()).to.equal('0') +} + +export const compoundLendTest = async ( + hre: HardhatRuntimeEnvironment +): Promise => { + const { getNamedSigner } = hre + const borrower = await getNamedSigner('borrower') + const loan = await LoanStoryTestDriver.getLoan(hre, borrower) + const { details, diamond } = loan + let shouldPass = true + if (!loan) { + shouldPass = false + } + if (shouldPass) { + await getFunds({ + to: await borrower.getAddress(), + tokenSym: await details.lendingToken.symbol(), + amount: BigNumber.from(details.loan.borrowedAmount).mul(2), + hre, + }) + await lendCompound(hre, loan) + } else { + await lendCompound(hre, loan).catch((error) => { + expect(error).to.exist + }) + } +} + +export const compoundClaimTest = async ( + hre: HardhatRuntimeEnvironment +): Promise => { + const { getNamedSigner, contracts, network } = hre + const borrower = await getNamedSigner('borrower') + const loan = await LoanStoryTestDriver.getLoan(hre, borrower) + const { details, diamond } = loan + let shouldPass = true + await hre.evm.advanceTime(details.loan.duration) + const dappAddresses = getDappAddresses(network) + const Comptroller = await contracts.get('IComptroller', { + at: dappAddresses.compoundComptrollerAddress, + }) + const escrowAddress = await diamond.getLoanEscrow(details.loan.id) + const compBefore = await Comptroller.compAccrued(escrowAddress) + + //read the state and determine if this should pass + if (!loan) shouldPass = false + if (compBefore.lte(0)) shouldPass = false + if (shouldPass) { + await claimComp(hre, loan) + } else { + await claimComp(hre, loan).catch((error) => { + expect(error).to.exist + }) + } +} diff --git a/test/helpers/story/drivers/dapp-utils/poolTogether.utils.ts b/test/helpers/story/drivers/dapp-utils/poolTogether.utils.ts new file mode 100644 index 000000000..f51c20d6d --- /dev/null +++ b/test/helpers/story/drivers/dapp-utils/poolTogether.utils.ts @@ -0,0 +1,79 @@ +import chai, { expect } from 'chai' +import { solidity } from 'ethereum-waffle' +import { HardhatRuntimeEnvironment } from 'hardhat/types' + +import { IERC20 } from '../../../../../types/typechain' +import { LoanHelpersReturn } from '../../../loans' +import LoanStoryTestDriver from '../loan-story-test-driver' +chai.should() +chai.use(solidity) + +async function lendPoolTogether( + hre: HardhatRuntimeEnvironment, + loan: LoanHelpersReturn +): Promise { + const { contracts } = hre + const { details, diamond } = loan + const poolTicket = await contracts.get('IERC20', { + at: await diamond.getAssetPPoolTicket(details.lendingToken.address), + }) + await diamond + .connect(details.borrower.signer) + .poolTogetherDepositTicket( + details.loan.id, + details.loan.lendingToken, + details.loan.borrowedAmount + ) + + const escrowAddress = await diamond.getLoanEscrow(details.loan.id) + + const daiBalance = await details.lendingToken.balanceOf(escrowAddress) + daiBalance.eq(details.loan.borrowedAmount).should.eql(false, '') + + const tokenAddresses = await diamond.getEscrowTokens(details.loan.id) + tokenAddresses.should.include(poolTicket.address) +} + +async function withdrawPoolTogether( + hre: HardhatRuntimeEnvironment, + loan: LoanHelpersReturn +): Promise { + const { contracts } = hre + const { details, diamond } = loan + const poolTicket = await contracts.get('IERC20', { + at: await diamond.getAssetPPoolTicket(details.lendingToken.address), + }) + await diamond + .connect(details.borrower.signer) + .poolTogetherWithdrawAll(details.loan.id, details.lendingToken.address) + + const tokenAddresses = await diamond.getEscrowTokens(details.loan.id) + tokenAddresses.should.not.include(poolTicket.address) + const escrowAddress = await diamond.getLoanEscrow(details.loan.id) + const daiBalance = await details.lendingToken.balanceOf(escrowAddress) + daiBalance.should.be.gt('0') +} + +export const poolTogetherLendTest = async ( + hre: HardhatRuntimeEnvironment +): Promise => { + const { getNamedSigner } = hre + const borrower = await getNamedSigner('borrower') + const loan = await LoanStoryTestDriver.getLoan(hre, borrower) + const { details, diamond } = loan + let shouldPass = true + const borrowedAmount = ( + await details.lendingToken.balanceOf( + await diamond.getLoanEscrow(details.loan.id) + ) + ).toString() + if (borrowedAmount != details.loan.borrowedAmount.toString()) + shouldPass = false + if (shouldPass) { + await lendPoolTogether(hre, loan) + } else { + await lendPoolTogether(hre, loan).catch((error) => { + expect(error).to.exist + }) + } +} diff --git a/test/helpers/story/drivers/dapp-utils/sushiswap.utils.ts b/test/helpers/story/drivers/dapp-utils/sushiswap.utils.ts new file mode 100644 index 000000000..6feabe4f4 --- /dev/null +++ b/test/helpers/story/drivers/dapp-utils/sushiswap.utils.ts @@ -0,0 +1,73 @@ +import chai, { expect } from 'chai' +import { solidity } from 'ethereum-waffle' +import { HardhatRuntimeEnvironment } from 'hardhat/types' + +import { LoanHelpersReturn } from '../../../loans' +import LoanStoryTestDriver from '../loan-story-test-driver' +chai.should() +chai.use(solidity) + +async function swapSushiSwap( + hre: HardhatRuntimeEnvironment, + loan: LoanHelpersReturn +): Promise { + const { tokens } = hre + const { details, diamond } = loan + const escrowAddress = await diamond.getLoanEscrow(details.loan.id) + + const lendingBalBefore = await details.lendingToken.balanceOf(escrowAddress) + lendingBalBefore + .gt(0) + .should.eql(true, 'Loan escrow should have a lending token balance') + const link = await tokens.get('LINK') + const swapBalBefore = await link.balanceOf(escrowAddress) + swapBalBefore + .eq(0) + .should.eql(true, 'Loan escrow should not have a token balance before swap') + + await diamond + .connect(details.borrower.signer) + .sushiswapSwap( + details.loan.id, + [details.lendingToken.address, link.address], + lendingBalBefore, + '0' + ) + .should.emit(diamond, 'SushiswapSwapped') + + const swapBalAfter = await link.balanceOf(escrowAddress) + swapBalAfter + .gt(0) + .should.eql(true, 'Swap token balance not positive after swap') + + const lendingBalAfter = await details.lendingToken.balanceOf(escrowAddress) + lendingBalAfter + .eq(0) + .should.eql( + true, + 'Loan escrow has lending token balance after swapping full amount' + ) +} + +export const sushiswapSwapTest = async ( + hre: HardhatRuntimeEnvironment +): Promise => { + const { getNamedSigner } = hre + const borrower = await getNamedSigner('borrower') + const loan = await LoanStoryTestDriver.getLoan(hre, borrower) + let shouldPass = true + //read the state and determine if this should pass + if (!loan) shouldPass = false + const { details, diamond } = loan + const escrowAddress = await diamond.getLoanEscrow(details.loan.id) + const lendingBalBefore = await details.lendingToken.balanceOf(escrowAddress) + + if (lendingBalBefore.lte(0)) shouldPass = false + if (shouldPass) { + await swapSushiSwap(hre, loan) + } else { + await swapSushiSwap(hre, loan).catch((error) => { + expect(error).to.exist + }) + } +} diff --git a/test/helpers/story/drivers/dapp-utils/uniswap.utils.ts b/test/helpers/story/drivers/dapp-utils/uniswap.utils.ts new file mode 100644 index 000000000..e96761aa2 --- /dev/null +++ b/test/helpers/story/drivers/dapp-utils/uniswap.utils.ts @@ -0,0 +1,74 @@ +import chai, { expect } from 'chai' +import { solidity } from 'ethereum-waffle' +import { HardhatRuntimeEnvironment } from 'hardhat/types' + +import { LoanHelpersReturn } from '../../../loans' +import LoanStoryTestDriver from '../loan-story-test-driver' +chai.should() +chai.use(solidity) + +async function swapUniSwap( + hre: HardhatRuntimeEnvironment, + loan: LoanHelpersReturn +): Promise { + const { tokens } = hre + const { details, diamond } = loan + const link = await tokens.get('LINK') + const escrowAddress = await diamond.getLoanEscrow(details.loan.id) + + const lendingBalBefore = await details.lendingToken.balanceOf(escrowAddress) + lendingBalBefore + .gt(0) + .should.eql(true, 'Loan escrow should have a lending token balance') + + const swapBalBefore = await link.balanceOf(escrowAddress) + swapBalBefore + .eq(0) + .should.eql(true, 'Loan escrow should not have a token balance before swap') + + await diamond + .connect(details.borrower.signer) + .uniswapSwap( + details.loan.id, + [details.lendingToken.address, link.address], + lendingBalBefore, + '0' + ) + .should.emit(diamond, 'UniswapSwapped') + + const swapBalAfter = await link.balanceOf(escrowAddress) + swapBalAfter + .gt(0) + .should.eql(true, 'Swap token balance not positive after swap') + + const lendingBalAfter = await details.lendingToken.balanceOf(escrowAddress) + lendingBalAfter + .eq(0) + .should.eql( + true, + 'Loan escrow has lending token balance after swapping full amount' + ) +} + +export const uniswapSwapTest = async ( + hre: HardhatRuntimeEnvironment +): Promise => { + const { getNamedSigner } = hre + const borrower = await getNamedSigner('borrower') + const loan = await LoanStoryTestDriver.getLoan(hre, borrower) + const { details, diamond } = loan + let shouldPass = true + const escrowAddress = await diamond.getLoanEscrow(details.loan.id) + const lendingBalBefore = await details.lendingToken.balanceOf(escrowAddress) + + //read the state and determine if this should pass + if (!loan) shouldPass = false + if (lendingBalBefore.lte(0)) shouldPass = false + if (shouldPass) { + await swapUniSwap(hre, loan) + } else { + await swapUniSwap(hre, loan).catch((error) => { + expect(error).to.exist + }) + } +} diff --git a/test/helpers/story/drivers/dapp-utils/yearn.utils.ts b/test/helpers/story/drivers/dapp-utils/yearn.utils.ts new file mode 100644 index 000000000..c5f54d247 --- /dev/null +++ b/test/helpers/story/drivers/dapp-utils/yearn.utils.ts @@ -0,0 +1,67 @@ +import chai, { expect } from 'chai' +import { solidity } from 'ethereum-waffle' +import { HardhatRuntimeEnvironment } from 'hardhat/types' + +import { LoanHelpersReturn } from '../../../loans' +import LoanStoryTestDriver from '../loan-story-test-driver' +chai.should() +chai.use(solidity) + +async function lendYearn( + hre: HardhatRuntimeEnvironment, + loan: LoanHelpersReturn +): Promise { + const { details, diamond } = loan + await diamond + .connect(details.borrower.signer) + .yearnDeposit( + details.loan.id, + details.loan.lendingToken, + details.loan.borrowedAmount + ) + + const escrowAddress = await diamond.getLoanEscrow(details.loan.id) + const daiBalance = await details.lendingToken.balanceOf(escrowAddress) + daiBalance.should.eq(details.loan.borrowedAmount) + + const tokenAddresses = await diamond.getEscrowTokens(details.loan.id) + // tokenAddresses.should.include(aToken.address) +} + +async function withdrawYearn( + hre: HardhatRuntimeEnvironment, + loan: LoanHelpersReturn +): Promise { + const { contracts } = hre + const { details, diamond } = loan + await diamond + .connect(details.borrower.signer) + .yearnWithdrawAll(details.loan.id, details.lendingToken.address) + + const escrowAddress = await diamond.getLoanEscrow(details.loan.id) + + const tokenAddresses = await diamond.getEscrowTokens(details.loan.id) + // tokenAddresses.should.not.include(aToken.address) + + const daiBalance = await details.lendingToken.balanceOf(escrowAddress) + daiBalance.should.eql(0) +} + +export const yearnLendTest = async ( + hre: HardhatRuntimeEnvironment +): Promise => { + const { getNamedSigner } = hre + const borrower = await getNamedSigner('borrower') + const loan = await LoanStoryTestDriver.getLoan(hre, borrower) + let shouldPass = true + if (!loan) { + shouldPass = false + } + if (shouldPass) { + await lendYearn(hre, loan) + } else { + await lendYearn(hre, loan).catch((error) => { + expect(error).to.exist + }) + } +} diff --git a/test/helpers/story/drivers/lending-pool-story-test-driver.ts b/test/helpers/story/drivers/lending-pool-story-test-driver.ts new file mode 100644 index 000000000..9304e4a95 --- /dev/null +++ b/test/helpers/story/drivers/lending-pool-story-test-driver.ts @@ -0,0 +1,145 @@ +import chai, { expect } from 'chai' +import { solidity } from 'ethereum-waffle' +import { BigNumber } from 'ethers' +import { HardhatRuntimeEnvironment } from 'hardhat/types' +import { Test } from 'mocha' + +import { getNetworkName } from '../../../../config' +import { ITellerDiamond, ITToken } from '../../../../types/typechain' +import { fundLender, getFunds } from '../../get-funds' +import { getLPHelpers } from '../../lending-pool' +import { TestAction, TestScenario } from '../story-helpers' +import LoanStoryTestDriver from './loan-story-test-driver' +import StoryTestDriver from './story-test-driver' +chai.should() +chai.use(solidity) +/* +We will read state data from the chaindata to determine whether or not each 'action' should pass or fail at the current moment +Then we will expect that +*/ + +export default class LPStoryTestDriver extends StoryTestDriver { + static generateDomainSpecificTestsForScenario( + hre: HardhatRuntimeEnvironment, + scenario: TestScenario, + parentSuite: Mocha.Suite + ): Mocha.Suite { + const scenarioActions = scenario.actions + + for (const action of scenarioActions) { + const testsForAction: Test[] = LPStoryTestDriver.generateTestsForAction( + hre, + action, + parentSuite + ) + + //allTests = allTests.concat(testsForAction) + + for (const test of testsForAction) { + parentSuite.addTest(test) + } + } + + return parentSuite + } + + static generateTestsForAction( + hre: HardhatRuntimeEnvironment, + action: TestAction, + testSuite: Mocha.Suite + ): Test[] { + const tests: Test[] = [] + const { getNamedSigner, ethers } = hre + const { actionType, args } = action + + switch (actionType) { + case 'LEND': { + const newTest = new Test(action.suiteName, async () => { + const helpers: ReturnType = + await LPStoryTestDriver.createLPArgs(hre) + let shouldPass = true + const borrower = await getNamedSigner('borrower') + const loan = await LoanStoryTestDriver.getLoan(hre, borrower) + const { details, diamond } = loan + //read the state and determine if this should pass + if ( + getNetworkName(hre.network) != 'polygon' && + getNetworkName(hre.network) != 'polygon_mumbai' + ) { + const maxTVL = await diamond.getAssetMaxTVL( + details.lendingToken.address + ) + const fotmattedMaxTVL = ethers.utils.formatEther(maxTVL) + if ( + BigNumber.from(Number(fotmattedMaxTVL)).gte( + BigNumber.from(100000) + ) + ) + shouldPass = false + } + // check if we're at the max tvl + if (shouldPass) { + await helpers.deposit() + } else { + await helpers.deposit().catch((error) => { + expect(error).to.exist + }) + } + }) + + tests.push(newTest) + break + } + case 'WITHDRAW': { + const newTest = new Test(action.suiteName, async () => { + const helpers: ReturnType = + await LPStoryTestDriver.createLPArgs(hre) + const borrower = await getNamedSigner('borrower') + const loan = await LoanStoryTestDriver.getLoan(hre, borrower) + const { details, diamond } = loan + let shouldPass = true + //read the state and determine if this should pass + // if() + const lendingBal = await details.lendingToken.balanceOf( + await borrower.getAddress() + ) + if (lendingBal.eq(0)) shouldPass = false + if (shouldPass) { + await helpers.withdraw() + } else { + await helpers.withdraw().catch((error) => { + expect(error).to.exist + }) + } + }) + tests.push(newTest) + break + } + } + return tests + } + + static createLPArgs = async ( + hre: HardhatRuntimeEnvironment + ): Promise> => { + const { getNamedSigner, contracts } = hre + const borrower = await getNamedSigner('borrower') + const loan = await LoanStoryTestDriver.getLoan(hre, borrower) + const { details, diamond } = loan + const tToken: ITToken = await contracts.get('ITToken', { + at: await diamond.getTTokenFor(details.lendingToken.address), + }) + await fundLender({ + token: details.lendingToken, + amount: BigNumber.from(100), + hre, + }) + const helpers = getLPHelpers(hre, { + diamond, + lendingToken: details.lendingToken, + tToken, + amount: null, + }) + return helpers + } +} diff --git a/test/helpers/story/drivers/loan-story-test-driver.ts b/test/helpers/story/drivers/loan-story-test-driver.ts new file mode 100644 index 000000000..812f36789 --- /dev/null +++ b/test/helpers/story/drivers/loan-story-test-driver.ts @@ -0,0 +1,281 @@ +import chai, { expect } from 'chai' +import { solidity } from 'ethereum-waffle' +import { BigNumber, ContractTransaction, Signer } from 'ethers' +import { HardhatRuntimeEnvironment } from 'hardhat/types' +import { Test } from 'mocha' +import moment from 'moment' +import Prando from 'prando' + +import { getMarkets } from '../../../../config' +import { getPlatformSetting, updatePlatformSetting } from '../../../../tasks' +import { ITellerDiamond } from '../../../../types/typechain' +import { fundedMarket } from '../../../fixtures' +import { getFunds } from '../../get-funds' +import { + loanHelpers, + LoanHelpersReturn, + LoanType, + repayLoan, + RepayLoanArgs, + takeOutLoanWithNfts, +} from '../../loans' +import { TestAction, TestArgs, TestScenario } from '../story-helpers' +import StoryTestDriver from './story-test-driver' +const rng = new Prando('teller') + +chai.should() +chai.use(solidity) +/* +We will read state data from the chaindata to determine whether or not each 'action' should pass or fail at the current moment +Then we will expect that +*/ + +export default class LoanStoryTestDriver extends StoryTestDriver { + static generateDomainSpecificTestsForScenario( + hre: HardhatRuntimeEnvironment, + scenario: TestScenario, + parentSuite: Mocha.Suite + ): Mocha.Suite { + const scenarioActions = scenario.actions + + for (const action of scenarioActions) { + const testsForAction: Test[] = LoanStoryTestDriver.generateTestsForAction( + hre, + action, + parentSuite + ) + for (const test of testsForAction) { + parentSuite.addTest(test) + } + } + + return parentSuite + } + + static generateTestsForAction( + hre: HardhatRuntimeEnvironment, + action: TestAction, + testSuite: Mocha.Suite + ): Test[] { + testSuite.tests + const tests: Test[] = [] + const { actionType, args } = action + switch (actionType) { + case 'TAKE_OUT': { + const newTest = new Test(action.suiteName, async () => { + let shouldPass = true + //read the state and determine if this should pass + const borrower = await hre.getNamedSigner('borrower') + const diamond = await hre.contracts.get( + 'TellerDiamond' + ) + const allBorrowerLoans = await diamond.getBorrowerLoans( + await borrower.getAddress() + ) + if (allBorrowerLoans.length > 1) { + shouldPass = false + } + if (shouldPass) { + await LoanStoryTestDriver.takeOutLoan(hre, args) + } else { + args.loanType = LoanType.OVER_COLLATERALIZED + await LoanStoryTestDriver.takeOutLoan(hre, args).catch((error) => { + expect(error).to.exist + }) + } + }) + tests.push(newTest) + break + } + case 'REPAY': { + const newTest = new Test(action.suiteName, async () => { + const shouldPass = true + //read the state and determine if this should pass + + if (shouldPass) { + const tx = await LoanStoryTestDriver.repayLoan(hre) + expect(tx).to.exist + } else { + await expect(await LoanStoryTestDriver.repayLoan(hre)).to.be + .reverted + } + }) + tests.push(newTest) + break + } + case 'LIQUIDATE': { + const newTest = new Test(action.suiteName, async () => { + // expect(1).to.equal(1) + const shouldPass = true + //read the state and determine if this should pass + + if (shouldPass) { + const tx = await LoanStoryTestDriver.liquidateLoan(hre) + expect(tx).to.exist + } else { + await expect(await LoanStoryTestDriver.liquidateLoan(hre)).to.be + .reverted + } + }) + tests.push(newTest) + break + } + } + return tests + } + + // static createLoanArgs = ( + // hre: HardhatRuntimeEnvironment, + // borrower: string + // ): CreateLoanArgs => { + // const { network } = hre + // const markets = getMarkets(network) + // const randomMarket = rng.nextInt(0, markets.length - 1) + // const market = markets[randomMarket] + // const randomCollateralToken = rng.nextInt( + // 0, + // market.collateralTokens.length - 1 + // ) + // const randomLoanType = rng.nextInt( + // 0, + // Object.values(LoanType).length / 2 - 1 + // ) + // return { + // lendToken: market.lendingToken, + // collToken: market.collateralTokens[randomCollateralToken], + // loanType: randomLoanType, + // } + // } + + static takeOutLoan = async ( + hre: HardhatRuntimeEnvironment, + args: TestArgs + ): Promise => { + const markets = getMarkets(hre.network) + const market = markets[0] + switch (process.env.FORKING_NETWORK) { + case 'mainnet': + case 'kovan': + case 'rinkeby': + case 'ropsten': + const tags: string[] = [] + tags.push('markets') + const { deployments } = hre + await deployments.fixture(tags, { + keepExistingDeployments: true, + }) + const percentageSubmission = { + name: 'RequiredSubmissionsPercentage', + value: 0, + } + await updatePlatformSetting(percentageSubmission, hre) + break + case 'polygon': + case 'polygon_mumbai': + const { diamond } = await fundedMarket(hre, { + assetSym: market.lendingToken, + amount: 100000, + }) + break + default: + throw new Error( + `Forking network is invalid: ${process.env.FORKING_NETWORK}` + ) + } + // Advance time + const { value: rateLimit } = await getPlatformSetting( + 'RequestLoanTermsRateLimit', + hre + ) + const loanType = args.loanType + ? args.loanType + : LoanType.UNDER_COLLATERALIZED + await hre.evm.advanceTime(rateLimit) + const funcToRun = takeOutLoanWithNfts(hre, { + amount: 100, + lendToken: market.lendingToken, + }) + const { tx, getHelpers } = await funcToRun + const helpers = await getHelpers() + // borrower data from our helpers + if (loanType != LoanType.ZERO_COLLATERAL) { + const { collateral } = helpers + const amount = await collateral.current() + // check if collateral is > 0 + amount.gt(0).should.eq(true, 'Loan must have collateral') + } + // check if loan exists + expect(helpers.details.loan).to.exist + const loanStatus = helpers.details.loan.status + expect(loanStatus).to.equal(2) + return await tx + } + + static getLoan = async ( + hre: HardhatRuntimeEnvironment, + borrower: Signer + ): Promise => { + const diamond = await hre.contracts.get('TellerDiamond') + const allBorrowerLoans = await diamond.getBorrowerLoans( + await borrower.getAddress() + ) + expect( + allBorrowerLoans.length, + 'allBorrowerLoans must be greater than 0' + ).to.be.greaterThan(0) + if (allBorrowerLoans.length == 0) throw Error('No borrower loans') + const loanID = allBorrowerLoans[allBorrowerLoans.length - 1].toString() + return await loanHelpers(hre, loanID) + } + + static liquidateLoan = async ( + hre: HardhatRuntimeEnvironment + ): Promise => { + const borrowerAddress = (await hre.getNamedAccounts()).borrower + const borrower = await hre.ethers.provider.getSigner(borrowerAddress) + const loan = await LoanStoryTestDriver.getLoan(hre, borrower) + const { details, diamond } = loan + await hre.evm.advanceTime(details.loan.duration + 3600) + const liquidator = await hre.getNamedSigner('liquidator') + const borrowedAmount = details.loan.borrowedAmount + await getFunds({ + to: await liquidator.getAddress(), + tokenSym: await details.lendingToken.symbol(), + amount: BigNumber.from(borrowedAmount).mul(2), + hre, + }) + await details.lendingToken + .connect(liquidator) + .approve(diamond.address, BigNumber.from(borrowedAmount).mul(2)) + const tx = await diamond.connect(liquidator).liquidateLoan(details.loan.id) + return tx + } + + static repayLoan = async ( + hre: HardhatRuntimeEnvironment + ): Promise => { + const borrower = await hre.getNamedSigner('borrower') + const loan = await LoanStoryTestDriver.getLoan(hre, borrower) + const { details, diamond } = loan + const borrowedAmount = details.loan.borrowedAmount + const repayLoanArgs: RepayLoanArgs = { + amount: details.loan.borrowedAmount, + from: details.borrower.signer, + diamond, + details, + } + await hre.evm.advanceTime(moment.duration(10, 'minutes')) + const borrowerAddress = await borrower.getAddress() + await getFunds({ + to: borrowerAddress, + tokenSym: await details.lendingToken.symbol(), + amount: BigNumber.from(borrowedAmount).mul(2), + hre, + }) + await details.lendingToken + .connect(borrower) + .approve(diamond.address, BigNumber.from(borrowedAmount).mul(2)) + const tx = await repayLoan(repayLoanArgs) + return tx + } +} diff --git a/test/helpers/story/drivers/story-test-driver.ts b/test/helpers/story/drivers/story-test-driver.ts new file mode 100644 index 000000000..70324e2eb --- /dev/null +++ b/test/helpers/story/drivers/story-test-driver.ts @@ -0,0 +1,40 @@ +import { HardhatRuntimeEnvironment } from 'hardhat/types' +import { Test } from 'mocha' + +import { TestAction, TestScenario } from '../story-helpers' + +/* +export default class StoryTestDriver { + static generateDomainSpecificTestsForScenario( + hre: HardhatRuntimeEnvironment, + scenario: TestScenario + ): Array { + return [] + } + + static generateTestsForAction( + hre: HardhatRuntimeEnvironment, + action: TestAction + ): Array { + return [] + } +} +*/ + +export default class StoryTestDriver { + static generateDomainSpecificTestsForScenario( + hre: HardhatRuntimeEnvironment, + scenario: TestScenario, + parentSuite: Mocha.Suite + ): Mocha.Suite { + return parentSuite + } + + static generateTestsForAction( + hre: HardhatRuntimeEnvironment, + action: TestAction, + testSuite: Mocha.Suite + ): Test[] { + return [] + } +} diff --git a/test/helpers/story/generator/story-generator.ts b/test/helpers/story/generator/story-generator.ts new file mode 100644 index 000000000..6dcc7f1c0 --- /dev/null +++ b/test/helpers/story/generator/story-generator.ts @@ -0,0 +1,89 @@ +import { HardhatRuntimeEnvironment } from 'hardhat/types' + +import { + STORY_NETWORKS, + StoryValues, + TestAction, + TestScenario, + TestScenarioDomain, + TREE_STRUCTURE, +} from '../story-helpers' + +export const generateStoryDomains = (): TestScenarioDomain[] => { + const proceduralScenarioDomains: TestScenarioDomain[] = [] + + for (const [key, value] of Object.entries(TREE_STRUCTURE)) { + const scenarioArray = generateDomainScenarios(key, value) + const newSDomain: TestScenarioDomain = { + domainName: key, + scenarios: scenarioArray, + } + proceduralScenarioDomains.push(newSDomain) + } + return proceduralScenarioDomains +} + +const generateDomainScenarios = ( + key: string, + value: StoryValues +): TestScenario[] => { + const testCases: TestScenario[] = [] + let network: string + switch (process.env.FORKING_NETWORK) { + case 'mainnet': + case 'kovan': + case 'rinkeby': + case 'ropsten': + network = STORY_NETWORKS.MAINNET + break + case 'polygon': + case 'polygon_mumbai': + network = STORY_NETWORKS.POLYGON + break + default: + throw new Error( + `Forking network is invalid: ${process.env.FORKING_NETWORK}` + ) + } + if (value.network !== STORY_NETWORKS.ALL && value.network !== network) + return testCases + const splitStructure: string[] = key.split('.') + const domain = splitStructure[0] + const actions: TestAction[] = [] + + const action = splitStructure[splitStructure.length - 1] + const test: TestAction = { + actionParentType: domain == 'DAPP' ? splitStructure[1] : undefined, + actionType: action, + suiteName: `${domain} ${action} test`, + args: {}, + } + actions.unshift(test) + testCases.push({ domain, actions }) + if (value.parents) { + value.parents.map((value) => { + parseParents(value, testCases) + }) + testCases.push({ domain, actions: actions }) + } + return testCases +} + +const parseParents = ( + structure: string, + testCases: TestScenario[] +): TestAction => { + const parentactions: TestAction[] = [] + const structureSplit = structure.split('.') + const domain = structureSplit[0] + const action = structureSplit[structureSplit.length - 1] + const test: TestAction = { + actionParentType: domain == 'DAPP' ? structureSplit[1] : undefined, + actionType: action, + suiteName: `${domain} ${action} test`, + args: {}, + } + parentactions.push(test) + testCases.push({ domain, actions: parentactions }) + return test +} diff --git a/test/helpers/story/story-helpers.ts b/test/helpers/story/story-helpers.ts new file mode 100644 index 000000000..d15ef20f1 --- /dev/null +++ b/test/helpers/story/story-helpers.ts @@ -0,0 +1,126 @@ +import { HardhatRuntimeEnvironment } from 'hardhat/types' + +import DappStoryTestDriver from './drivers/dapp-story-test-driver' +import LPStoryTestDriver from './drivers/lending-pool-story-test-driver' +import LoanStoryTestDriver from './drivers/loan-story-test-driver' + +export const LoanSnapshots: { [key: number]: () => Promise } = {} + +// export const STORY_DOMAINS = { +// LOAN: { TAKE_OUT: 0, REPAY: 1, LIQUIDATE: 2 }, +// LENDING_POOL: { LEND: 0, WITHDRAW: 1 }, +// DAPP: { LEND: 0, SWAP: 1 }, +// } + +export const STORY_NETWORKS = { + POLYGON: 'polygon', + MAINNET: 'mainnet', + ALL: 'all', +} + +export const TREE_STRUCTURE = { + 'LOAN.TAKE_OUT': { network: STORY_NETWORKS.ALL }, + 'LOAN.REPAY': { network: STORY_NETWORKS.ALL, parents: ['LOAN.TAKE_OUT'] }, + 'LOAN.LIQUIDATE': { + network: STORY_NETWORKS.ALL, + parents: ['LOAN.TAKE_OUT'], + }, + 'LENDING_POOL.LEND': { + network: STORY_NETWORKS.ALL, + parents: ['LOAN.TAKE_OUT'], + }, + 'LENDING_POOL.WITHDRAW': { + network: STORY_NETWORKS.ALL, + parents: ['LOAN.TAKE_OUT', 'LENDING_POOL.LEND'], + }, + 'DAPP.LEND.COMPOUND': { + network: STORY_NETWORKS.MAINNET, + parents: ['LOAN.TAKE_OUT'], + }, + 'DAPP.CLAIM.COMPOUND': { + network: STORY_NETWORKS.MAINNET, + parents: ['LOAN.TAKE_OUT', 'DAPP.LEND.COMPOUND'], + }, + 'DAPP.LEND.AAVE': { + network: STORY_NETWORKS.ALL, + parents: ['LOAN.TAKE_OUT'], + }, + // 'DAPP.LEND.YEARN': { + // network: STORY_NETWORKS.MAINNET, + // parents: ['LOAN.TAKE_OUT'], + // }, + 'DAPP.LEND.POOL_TOGETHER': { + network: STORY_NETWORKS.ALL, + parents: ['LOAN.TAKE_OUT'], + }, + 'DAPP.SWAP.UNISWAP': { + network: STORY_NETWORKS.MAINNET, + parents: ['LOAN.TAKE_OUT'], + }, + 'DAPP.SWAP.SUSHISWAP': { + network: STORY_NETWORKS.POLYGON, + parents: ['LOAN.TAKE_OUT'], + }, +} + +export interface StoryValues { + network: string + parents?: string[] +} + +export interface TestScenarioDomain { + domainName: string + scenarios: TestScenario[] +} + +export interface TestScenario { + domain: string + actions: TestAction[] +} + +export interface TestAction { + actionParentType?: string + actionType: string + suiteName: string + args: TestArgs +} + +export interface TestArgs { + actionTarget?: number + dappAction?: number + loanType?: number + nft?: boolean +} + +export const generateTests = ( + hre: HardhatRuntimeEnvironment, + scenario: TestScenario, + parentSuite: Mocha.Suite +): Mocha.Suite => { + switch (scenario.domain) { + case 'LOAN': + return LoanStoryTestDriver.generateDomainSpecificTestsForScenario( + hre, + scenario, + parentSuite + ) + break + case 'LENDING_POOL': + return LPStoryTestDriver.generateDomainSpecificTestsForScenario( + hre, + scenario, + parentSuite + ) + break + case 'DAPP': + return DappStoryTestDriver.generateDomainSpecificTestsForScenario( + hre, + scenario, + parentSuite + ) + break + default: + return parentSuite + break + } +} diff --git a/test/integration/dictionary.test.ts b/test/integration/dictionary.test.ts index cb9b6bf40..d8f7ae33b 100644 --- a/test/integration/dictionary.test.ts +++ b/test/integration/dictionary.test.ts @@ -155,11 +155,6 @@ describe('NFT Dictionary', () => { const tokenTier = await nftDictionary.getTokenTierIndex( lastOwnedTokenId ) - - //console.log(`token tier for ${lastOwnedTokenId} is ${tokenTier}`) - - //console.log(`merkleData.tierIndex was ${merkleData.tierIndex}`) - tokenTier.should.equal(merkleData.tierIndex) } }) diff --git a/test/integration/escrow/dapps/compound.test.ts b/test/integration/escrow/dapps/compound.test.ts deleted file mode 100644 index f4d023f9a..000000000 --- a/test/integration/escrow/dapps/compound.test.ts +++ /dev/null @@ -1,103 +0,0 @@ -// import chai from 'chai' -// import { solidity } from 'ethereum-waffle' -// import hre from 'hardhat' -// -// import { getMarkets } from '../../../../config' -// import { getPlatformSetting } from '../../../../tasks' -// import { Market } from '../../../../types/custom/config-types' -// import { ERC20, ICErc20, ITellerDiamond } from '../../../../types/typechain' -// import { fundedMarket } from '../../../fixtures' -// import { LoanType, takeOut } from '../../../helpers/loans' -// -// chai.should() -// chai.use(solidity) -// -// const { getNamedSigner, contracts, evm } = hre -// -// describe('CompoundDapp', () => { -// getMarkets(hre.network).forEach(testCompound) -// -// function testCompound(market: Market): void { -// describe(`${market.lendingToken} lending token`, () => { -// let diamond: ITellerDiamond -// let lendingToken: ERC20 -// let cToken: ICErc20 -// -// before(async () => { -// ;({ diamond, lendingToken } = await fundedMarket({ -// assetSym: market.lendingToken, -// amount: 100000, -// })) -// -// cToken = await contracts.get('ICErc20', { -// at: await diamond.getAssetCToken(lendingToken.address), -// }) -// }) -// -// beforeEach(async () => { -// // Advance time -// const { value: rateLimit } = await getPlatformSetting( -// 'RequestLoanTermsRateLimit', -// hre -// ) -// await evm.advanceTime(rateLimit) -// }) -// -// describe('lend, redeemAll', () => { -// it('Should be able to lend and then redeem successfully from Compound', async () => { -// const { details } = await takeOut({ -// lendToken: market.lendingToken, -// collToken: market.collateralTokens[0], -// loanType: LoanType.UNDER_COLLATERALIZED, -// }) -// -// await diamond -// .connect(details.borrower.signer) -// .compoundLend( -// details.loan.id, -// details.loan.lendingToken, -// details.loan.borrowedAmount -// ) -// -// const escrowAddress = await diamond.getLoanEscrow(details.loan.id) -// -// let cDaiBalance = await cToken.balanceOf(escrowAddress) -// -// cDaiBalance.eq(0).should.eql(false, '') -// -// let tokenAddresses: string[] -// tokenAddresses = await diamond.getEscrowTokens(details.loan.id) -// tokenAddresses.should.include(cToken.address) -// -// await diamond -// .connect(details.borrower.signer) -// .compoundRedeemAll(details.loan.id, lendingToken.address) -// -// tokenAddresses = await diamond.getEscrowTokens(details.loan.id) -// tokenAddresses.should.not.include(cToken.address) -// -// cDaiBalance = await cToken.balanceOf(escrowAddress) -// cDaiBalance.eq(0).should.eql(true, '') -// }) -// -// it('Should not be able to lend into Compound as not the loan borrower', async () => { -// const { details } = await takeOut({ -// lendToken: market.lendingToken, -// collToken: market.collateralTokens[0], -// loanType: LoanType.UNDER_COLLATERALIZED, -// }) -// -// const rando = await getNamedSigner('lender') -// await diamond -// .connect(rando) -// .compoundLend( -// details.loan.id, -// details.loan.lendingToken, -// details.loan.borrowedAmount -// ) -// .should.rejectedWith('Teller: dapp not loan borrower') -// }) -// }) -// }) -// } -// }) diff --git a/test/integration/escrow/dapps/uniswap.test.ts b/test/integration/escrow/dapps/uniswap.test.ts deleted file mode 100644 index a61b88217..000000000 --- a/test/integration/escrow/dapps/uniswap.test.ts +++ /dev/null @@ -1,131 +0,0 @@ -// import chai from 'chai' -// import { solidity } from 'ethereum-waffle' -// import hre from 'hardhat' -// -// import { getMarkets } from '../../../../config' -// import { getPlatformSetting } from '../../../../tasks' -// import { Market } from '../../../../types/custom/config-types' -// import { ERC20, ITellerDiamond } from '../../../../types/typechain' -// import { fundedMarket } from '../../../fixtures' -// import { LoanType, takeOut } from '../../../helpers/loans' -// -// chai.should() -// chai.use(solidity) -// -// const { tokens, getNamedSigner, evm } = hre -// -// describe('UniswapDapp', () => { -// let diamond: ITellerDiamond -// let lendingToken: ERC20 -// let link: ERC20 -// -// getMarkets(hre.network).forEach(testUniswap) -// -// function testUniswap(market: Market): void { -// describe(`${market.lendingToken} lending token`, () => { -// before(async () => { -// ;({ diamond, lendingToken } = await fundedMarket({ -// assetSym: market.lendingToken, -// amount: 100000, -// })) -// -// link = await tokens.get('LINK') -// }) -// -// beforeEach(async () => { -// // Advance time -// const { value: rateLimit } = await getPlatformSetting( -// 'RequestLoanTermsRateLimit', -// hre -// ) -// await evm.advanceTime(rateLimit) -// }) -// -// describe('swap', () => { -// it('Should be able to swap using Uniswap', async () => { -// const { details } = await takeOut({ -// lendToken: market.lendingToken, -// collToken: market.collateralTokens[0], -// loanType: LoanType.UNDER_COLLATERALIZED, -// }) -// -// const escrowAddress = await diamond.getLoanEscrow(details.loan.id) -// -// const lendingBalBefore = await lendingToken.balanceOf(escrowAddress) -// lendingBalBefore -// .gt(0) -// .should.eql(true, 'Loan escrow should have a lending token balance') -// -// const swapBalBefore = await link.balanceOf(escrowAddress) -// swapBalBefore -// .eq(0) -// .should.eql( -// true, -// 'Loan escrow should not have a token balance before swap' -// ) -// -// await diamond -// .connect(details.borrower.signer) -// .uniswapSwap( -// details.loan.id, -// [lendingToken.address, link.address], -// lendingBalBefore, -// '0' -// ) -// .should.emit(diamond, 'UniswapSwapped') -// -// const swapBalAfter = await link.balanceOf(escrowAddress) -// swapBalAfter -// .gt(0) -// .should.eql(true, 'Swap token balance not positive after swap') -// -// const lendingBalAfter = await lendingToken.balanceOf(escrowAddress) -// lendingBalAfter -// .eq(0) -// .should.eql( -// true, -// 'Loan escrow has lending token balance after swapping full amount' -// ) -// }) -// -// it('Should NOT be able to swap using Uniswap as not the loan borrower', async () => { -// const { details } = await takeOut({ -// lendToken: market.lendingToken, -// collToken: market.collateralTokens[0], -// loanType: LoanType.UNDER_COLLATERALIZED, -// amount: 100, -// }) -// -// await diamond -// .connect(await getNamedSigner('deployer')) -// .uniswapSwap( -// details.loan.id, -// [lendingToken.address, link.address], -// details.loan.borrowedAmount, -// '0' -// ) -// .should.rejectedWith('Teller: dapp not loan borrower') -// }) -// -// it('Should NOT be able to swap using Uniswap with an unsecured loan', async () => { -// const { details } = await takeOut({ -// lendToken: market.lendingToken, -// collToken: market.collateralTokens[0], -// loanType: LoanType.ZERO_COLLATERAL, -// amount: 100, -// }) -// -// await diamond -// .connect(details.borrower.signer) -// .uniswapSwap( -// details.loan.id, -// [lendingToken.address, link.address], -// details.loan.borrowedAmount, -// '0' -// ) -// .should.rejectedWith('Teller: dapp loan not secured') -// }) -// }) -// }) -// } -// }) diff --git a/test/integration/full.test.ts b/test/integration/full.test.ts index 561fc58f6..d8bc9e216 100644 --- a/test/integration/full.test.ts +++ b/test/integration/full.test.ts @@ -2,39 +2,39 @@ // import { solidity } from 'ethereum-waffle' // import { BigNumber, Signer } from 'ethers' // import hre from 'hardhat' -// + // import { getMarkets } from '../../config' // import { Market } from '../../types/custom/config-types' // import { ERC20, ITellerDiamond, ITToken } from '../../types/typechain' // import { LoanStatus } from '../../utils/consts' // import { fundLender, getFunds } from '../helpers/get-funds' // import { LoanType, takeOut } from '../helpers/loans' -// + // chai.should() // chai.use(solidity) -// + // const { contracts, tokens, deployments, getNamedSigner, network, evm, toBN } = // hre -// + // describe('Full Integration', () => { // // Run tests for all markets // getMarkets(network).forEach(testLP) -// + // function testLP(market: Market): void { // let diamond: ITellerDiamond // let lendingToken: ERC20 // let tToken: ITToken -// + // let deployer: Signer // let lender: Signer // let lender2: Signer -// + // before(async () => { // // Get a fresh market // await deployments.fixture('markets', { // keepExistingDeployments: true, // }) -// + // diamond = await contracts.get('TellerDiamond') // lender = await getNamedSigner('lender') // lender2 = await getNamedSigner('lender2') @@ -43,34 +43,34 @@ // at: await diamond.getTTokenFor(lendingToken.address), // }) // }) -// + // describe(`${market.lendingToken} Market`, () => { // describe('TToken', () => { // let depositAmount1: BigNumber // let depositAmount2: BigNumber -// + // before(async () => { // // // Get a fresh market // // await deployments.fixture('markets', { // // keepExistingDeployments: true, // // }) -// + // // Turn off the Teller Token restriction // await tToken.connect(deployer).restrict(false) -// + // // Fund the lender // depositAmount1 = await fundLender({ // token: lendingToken, // amount: 1000, // hre, // }) -// + // // Approve amount to loan // await lendingToken // .connect(lender) // .approve(tToken.address, depositAmount1) // }) -// + // it(`mint - should be able to deposit ${market.lendingToken} and mint equivalent LP TToken amount as first lender`, async () => { // const balBefore = await tToken.balanceOf(await lender.getAddress()) // balBefore @@ -79,10 +79,10 @@ // true, // 'Lender should not have a TToken balance before lending' // ) -// + // // Deposit tokens and mint TTokens // await tToken.connect(lender).mint(depositAmount1) -// + // const balAfter = await tToken.balanceOf(await lender.getAddress()) // balAfter // .eq(depositAmount1) @@ -91,7 +91,7 @@ // 'Lender TToken balance should equal deposit amount as first lender' // ) // }) -// + // it('rebalance - should use the TTokenStrategy to move funds into another protocol to earn interest', async () => { // const lendingBalBefore = await lendingToken.balanceOf(tToken.address) // lendingBalBefore @@ -100,23 +100,23 @@ // true, // 'TToken was not supplied token balance in last test' // ) -// + // await tToken // .rebalance() // .should.emit( // await contracts.get('ITTokenStrategy', { at: tToken.address }), // 'StrategyRebalanced' // ) -// + // const lendingBalAfter = await lendingToken.balanceOf(tToken.address) // lendingBalAfter // .lt(lendingBalBefore) // .should.eql(true, 'TToken lending balance not rebalanced') // }) -// + // it('totalUnderlyingSupply - should return a value that is grater that the initial deposit after 1 block', async () => { // await evm.advanceBlocks(10) -// + // const totalUnderlyingSupply = // await tToken.callStatic.totalUnderlyingSupply() // totalUnderlyingSupply @@ -126,27 +126,27 @@ // 'TToken strategy did not make any interest on deposit' // ) // }) -// + // it('exchangeRate - should return a rate that is grater than 1e18 (1-1 default rate)', async () => { // const exchangeRate = await tToken.callStatic.exchangeRate() // exchangeRate // .gt(toBN(1, 18)) // .should.eql(true, 'Exchange rate should be greater than 1-1') // }) -// + // it('should be able to take out and repay an under collateralized loan', async () => { // await evm.advanceTime(10000) -// + // // Create loan // const { details, escrowRepay } = await takeOut({ // lendToken: market.lendingToken, // collToken: market.collateralTokens[0], // loanType: LoanType.UNDER_COLLATERALIZED, // }) -// + // // Repay full amount // const amountToRepay = details.totalOwed -// + // // Get the funds to pay back the interest // await getFunds({ // tokenSym: market.lendingToken, @@ -154,12 +154,12 @@ // amount: details.debt.interestOwed, // hre, // }) -// + // // Approve loan repayment // await details.lendingToken // .connect(details.borrower.signer) // .approve(diamond.address, amountToRepay) -// + // // Repay loan // await escrowRepay(amountToRepay) // .should.emit(diamond, 'LoanRepaid') @@ -170,24 +170,24 @@ // details.borrower.address, // '0' // ) -// + // const { loan: repaidLoan } = await details.refresh() // repaidLoan.status.should.eq(LoanStatus.Closed) // }) -// + // it('should be able to take out and repay an under collateralized loan', async () => { // await evm.advanceTime(10000) -// + // // Create loan // const { details, escrowRepay } = await takeOut({ // lendToken: market.lendingToken, // collToken: market.collateralTokens[0], // loanType: LoanType.UNDER_COLLATERALIZED, // }) -// + // // Repay full amount // const amountToRepay = details.totalOwed -// + // // Get the funds to pay back the interest // await getFunds({ // tokenSym: market.lendingToken, @@ -195,12 +195,12 @@ // amount: details.debt.interestOwed, // hre, // }) -// + // // Approve loan repayment // await details.lendingToken // .connect(details.borrower.signer) // .approve(diamond.address, amountToRepay) -// + // // Repay loan // await escrowRepay(amountToRepay) // .should.emit(diamond, 'LoanRepaid') @@ -211,11 +211,11 @@ // details.borrower.address, // '0' // ) -// + // const { loan: repaidLoan } = await details.refresh() // repaidLoan.status.should.eq(LoanStatus.Closed) // }) -// + // it('mint, rebalance - should be able to add an additional lender', async () => { // // Fund the lender // depositAmount2 = toBN(10000, await lendingToken.decimals()) @@ -225,27 +225,27 @@ // amount: depositAmount2, // hre, // }) -// + // // Approve amount to loan // await lendingToken // .connect(lender2) // .approve(tToken.address, depositAmount2) -// + // // Deposit tokens and mint TTokens // await tToken.connect(lender2).mint(depositAmount2) -// + // // Rebalance funds // await tToken.rebalance() -// + // // Mine blocks to generate interest // await evm.advanceBlocks(1000) // }) -// + // it('redeem - should be able to redeem 2nd lender supply for more than deposited', async () => { // // Redeem lenders balance // const tSupply = await tToken.balanceOf(await lender2.getAddress()) // await tToken.connect(lender2).redeem(tSupply) -// + // const balance = await lendingToken.balanceOf( // await lender2.getAddress() // ) @@ -253,12 +253,12 @@ // .gt(depositAmount2) // .should.eql(true, 'Lender lost value from their initial deposit') // }) -// + // it('redeem - should be able to redeem 1st lender supply for more than deposited', async () => { // // Redeem lenders balance // const tSupply = await tToken.balanceOf(await lender.getAddress()) // await tToken.connect(lender).redeem(tSupply) -// + // const balance = await lendingToken.balanceOf( // await lender.getAddress() // ) diff --git a/test/integration/lending.test.ts b/test/integration/lending.test.ts index 1a1c83b46..2e17025d4 100644 --- a/test/integration/lending.test.ts +++ b/test/integration/lending.test.ts @@ -24,7 +24,7 @@ const { toBN, } = hre -describe('Lending', () => { +describe.skip('Lending', () => { // Run tests for all markets getMarkets(network).forEach(testLP) @@ -59,10 +59,11 @@ describe('Lending', () => { let helpers: ReturnType before(async () => { - helpers = getLPHelpers({ + helpers = getLPHelpers(hre, { diamond, lendingToken, tToken, + amount: null, }) }) @@ -72,7 +73,7 @@ describe('Lending', () => { const depositAmount = await fundLender({ token: lendingToken, - amount: 100, + amount: 1, hre, }) await tToken @@ -94,7 +95,7 @@ describe('Lending', () => { // Fund the lender const depositAmount = await fundLender({ token: lendingToken, - amount: 1000, + amount: 1, hre, }) @@ -117,7 +118,7 @@ describe('Lending', () => { .withArgs(LENDING_ID, await deployer.getAddress()) }) - it('should NOT be able to deposit more than the max TVL setting', async () => { + it.skip('should NOT be able to deposit more than the max TVL setting', async () => { const maxTVL = await diamond.getAssetMaxTVL(lendingToken.address) const depositAmount = maxTVL.add(1) @@ -155,10 +156,11 @@ describe('Lending', () => { // Fund the market const depositAmount = await fundLender({ token: lendingToken, - amount: 1000, + amount: 1, hre, }) - await helpers.deposit(lender, depositAmount) + + await helpers.deposit() const tTokenBalAfter = await tToken.balanceOf( await lender.getAddress() @@ -179,9 +181,9 @@ describe('Lending', () => { before(async () => { // Get a fresh market - // await deployments.fixture('markets', { - // keepExistingDeployments: RUN_EXISTING, - // }) + await deployments.fixture('markets', { + keepExistingDeployments: RUN_EXISTING, + }) // Turn off the Teller Token restriction await tToken.connect(deployer).restrict(false) @@ -189,7 +191,7 @@ describe('Lending', () => { // Fund the lender depositAmount1 = await fundLender({ token: lendingToken, - amount: 1000, + amount: 10, hre, }) @@ -235,7 +237,6 @@ describe('Lending', () => { await contracts.get('ITTokenStrategy', { at: tToken.address }), 'StrategyRebalanced' ) - const lendingBalAfter = await lendingToken.balanceOf(tToken.address) lendingBalAfter .lt(lendingBalBefore) @@ -264,7 +265,7 @@ describe('Lending', () => { it('mint, rebalance - should be able to add an additional lender', async () => { // Fund the lender - depositAmount2 = toBN(10000, await lendingToken.decimals()) + depositAmount2 = toBN(10, await lendingToken.decimals()) await getFunds({ to: await lender2.getAddress(), tokenSym: market.lendingToken, @@ -281,13 +282,13 @@ describe('Lending', () => { await tToken.connect(lender2).mint(depositAmount2) // Rebalance funds - await tToken.rebalance() + await tToken.connect(deployer).rebalance() // Mine blocks to generate interest await evm.advanceBlocks(1000) }) - it('redeem - should be able to redeem 2nd lender supply for more than deposited', async () => { + it.skip('redeem - should be able to redeem 2nd lender supply for more than deposited', async () => { // Redeem lenders balance const tSupply = await tToken.balanceOf(await lender2.getAddress()) await tToken.connect(lender2).redeem(tSupply) @@ -300,7 +301,7 @@ describe('Lending', () => { .should.eql(true, 'Lender lost value from their initial deposit') }) - it('redeem - should be able to redeem 1st lender supply for more than deposited', async () => { + it.skip('redeem - should be able to redeem 1st lender supply for more than deposited', async () => { // Redeem lenders balance const tSupply = await tToken.balanceOf(await lender.getAddress()) await tToken.connect(lender).redeem(tSupply) diff --git a/test/integration/liquidate.test.ts b/test/integration/liquidate.test.ts index 077fd0570..bc25993d9 100644 --- a/test/integration/liquidate.test.ts +++ b/test/integration/liquidate.test.ts @@ -3,7 +3,7 @@ // import { BigNumber, BigNumberish, Signer } from 'ethers' // import hre from 'hardhat' // import moment from 'moment' -// + // import { getMarkets } from '../../config' // import { getPlatformSetting } from '../../tasks' // import { Market } from '../../types/custom/config-types' @@ -17,21 +17,21 @@ // LoanType, // takeOut, // } from '../helpers/loans' -// + // chai.should() // chai.use(solidity) -// + // const { getNamedSigner, evm, contracts } = hre -// + // describe('Liquidate Loans', () => { // getMarkets(hre.network).forEach(testLoans) -// + // function testLoans(market: Market): void { // let liquidator: { signer: Signer; address: string } // let diamond: ITellerDiamond // let nft: TellerNFT // let liquidateRewardPercent: BigNumber -// + // before(async () => { // // Get funded market // ;({ diamond } = await fundedMarket({ @@ -40,7 +40,7 @@ // tags: ['nft'], // })) // nft = await contracts.get('TellerNFT') -// + // const liquidatorSigner = await getNamedSigner('liquidator') // liquidator = { // signer: liquidatorSigner, @@ -51,7 +51,7 @@ // hre // ).then(({ value }) => value) // }) -// + // enum LiqLoanStatus { // Expired, // } @@ -72,14 +72,14 @@ // nft: args.nft, // }) // const { details } = helpers -// + // // Get required amount of tokens to repay loan // let neededAmount = details.totalOwed // const tokenBal = await details.lendingToken.balanceOf(liquidator.address) // if (tokenBal.lt(neededAmount)) { // neededAmount = tokenBal.add(neededAmount.sub(tokenBal)) // } -// + // // Fund lender account // if (neededAmount.gt(0)) { // await getFunds({ @@ -93,23 +93,23 @@ // await details.lendingToken // .connect(liquidator.signer) // .approve(diamond.address, details.totalOwed) -// + // switch (args.status) { // case LiqLoanStatus.Expired: // // Advance time // await evm.advanceTime(details.loan.duration) // } -// + // return helpers // } -// + // describe('reward', () => { // it('should calculate correct liquidation reward for a zero collateral loan', async () => { // const { details } = await testSetup({ // loanType: LoanType.ZERO_COLLATERAL, // status: LiqLoanStatus.Expired, // }) -// + // // Expected reward amount right after taking out loan w/ 0 collateral should be the amount owed // const expectedReward = await diamond.getLoanEscrowValue(details.loan.id) // const reward = await diamond.getLiquidationReward(details.loan.id) @@ -118,13 +118,13 @@ // 'Invalid zero collateral liquidation reward calculated' // ) // }) -// + // it('should calculate correct liquidation reward for an under collateralized loan', async () => { // const { details } = await testSetup({ // loanType: LoanType.UNDER_COLLATERALIZED, // status: LiqLoanStatus.Expired, // }) -// + // // Get the expected reward amount // const expectedReward = details.totalOwed.add( // details.totalOwed.mul(liquidateRewardPercent).div(HUNDRED_PERCENT) @@ -135,13 +135,13 @@ // 'Invalid under collateralized liquidation reward calculated' // ) // }) -// + // it('should calculate correct liquidation reward for an over collateralized loan', async () => { // const { details } = await testSetup({ // loanType: LoanType.OVER_COLLATERALIZED, // status: LiqLoanStatus.Expired, // }) -// + // // Get the expected reward amount // const expectedReward = details.totalOwed.add( // details.totalOwed.mul(liquidateRewardPercent).div(HUNDRED_PERCENT) @@ -156,14 +156,14 @@ // .should.eql(true, 'Reward less than liquidation payment') // }) // }) -// + // describe('expired', () => { // it('should be able to liquidate an expired zero collateral loan', async () => { // const { details } = await testSetup({ // loanType: LoanType.ZERO_COLLATERAL, // status: LiqLoanStatus.Expired, // }) -// + // const liquidatorLendBefore = await details.lendingToken.balanceOf( // liquidator.address // ) @@ -171,18 +171,18 @@ // liquidator.address // ) // const reward = await diamond.getLiquidationReward(details.loan.id) -// + // await diamond // .connect(liquidator.signer) // .liquidateLoan(details.loan.id) // .should.emit(diamond, 'LoanLiquidated') -// + // await details // .refresh() // .then(({ loan: { status } }) => // status.should.eq(LoanStatus.Liquidated, 'Loan not liquidated') // ) -// + // const liquidatorLendAfter = await details.lendingToken.balanceOf( // liquidator.address // ) @@ -193,7 +193,7 @@ // reward.inLending_, // 'Expected liquidator to be paid by loan escrow in lending token' // ) -// + // const liquidatorCollAfter = await details.collateralToken.balanceOf( // liquidator.address // ) @@ -205,61 +205,61 @@ // 'Liquidator collateral token balance should not increase' // ) // }) -// + // it('should be able to liquidate an expired under collateralized loan', async () => { // const { details, collateral } = await testSetup({ // loanType: LoanType.UNDER_COLLATERALIZED, // status: LiqLoanStatus.Expired, // }) -// + // const loanCollateral = await collateral.current() // const liquidatorCollBefore = await details.collateralToken.balanceOf( // liquidator.address // ) -// + // await diamond // .connect(liquidator.signer) // .liquidateLoan(details.loan.id) // .should.emit(diamond, 'LoanLiquidated') -// + // await details // .refresh() // .then(({ loan: { status } }) => // status.should.eq(LoanStatus.Liquidated, 'Loan not liquidated') // ) -// + // const liquidatorCollAfter = await details.collateralToken.balanceOf( // liquidator.address // ) // const collDiff = liquidatorCollAfter.sub(liquidatorCollBefore) -// + // collDiff.gt(0).should.eql(true, 'Collateral reward not positive') // collDiff.should.eql(loanCollateral, 'Incorrect collateral reward paid') // }) -// + // it('should be able to liquidate an expired over collateralized loan', async () => { // const { details } = await testSetup({ // loanType: LoanType.OVER_COLLATERALIZED, // status: LiqLoanStatus.Expired, // nft: true, // }) -// + // const liquidatorCollBefore = await details.collateralToken.balanceOf( // liquidator.address // ) // const reward = await diamond.getLiquidationReward(details.loan.id) -// + // await diamond // .connect(liquidator.signer) // .liquidateLoan(details.loan.id) // .should.emit(diamond, 'LoanLiquidated') -// + // await details // .refresh() // .then(({ loan: { status } }) => // status.should.eq(LoanStatus.Liquidated, 'Loan not liquidated') // ) -// + // const liquidatorCollAfter = await details.collateralToken.balanceOf( // liquidator.address // ) @@ -271,14 +271,14 @@ // .sub(liquidatorCollBefore) // .should.eql(reward.inCollateral_, 'Incorrect collateral reward paid') // }) -// + // it('should be able to liquidate an expired loan with an NFT', async () => { // const { details } = await testSetup({ // loanType: LoanType.ZERO_COLLATERAL, // status: LiqLoanStatus.Expired, // nft: true, // }) -// + // const liquidatorLendBefore = await details.lendingToken.balanceOf( // liquidator.address // ) @@ -286,22 +286,22 @@ // liquidator.address // ) // const reward = await diamond.getLiquidationReward(details.loan.id) -// + // const nftBefore = await nft.getOwnedTokens( // '0x95143890162bd671d77ae9b771881a1cb76c29a4' // ) // Liq controller -// + // await diamond // .connect(liquidator.signer) // .liquidateLoan(details.loan.id) // .should.emit(diamond, 'LoanLiquidated') -// + // await details // .refresh() // .then(({ loan: { status } }) => // status.should.eq(LoanStatus.Liquidated, 'Loan not liquidated') // ) -// + // const liquidatorLendAfter = await details.lendingToken.balanceOf( // liquidator.address // ) @@ -312,7 +312,7 @@ // reward.inLending_, // 'Expected liquidator to be paid by loan escrow in lending token' // ) -// + // const liquidatorCollAfter = await details.collateralToken.balanceOf( // liquidator.address // ) @@ -323,11 +323,10 @@ // true, // 'Liquidator collateral token balance should not increase' // ) -// + // const nftAfter = await nft.getOwnedTokens( // '0x95143890162bd671d77ae9b771881a1cb76c29a4' // ) -// console.log({ nftBefore, nftAfter, liquidatorLendBefore }) // nftAfter.length.should.greaterThan(nftBefore.length) // }) // }) diff --git a/test/integration/loans.test.ts b/test/integration/loans.test.ts index d7790220a..c0e4a2cd7 100644 --- a/test/integration/loans.test.ts +++ b/test/integration/loans.test.ts @@ -1,215 +1,230 @@ -import chai, { expect } from 'chai' -import { solidity } from 'ethereum-waffle' -import { Signer } from 'ethers' -import { - ComputationResult, - Proof, - // @ts-ignore -} from 'zokrates-js/node' -import { defaultMaxListeners } from 'events' -import hre from 'hardhat' - -import { getMarkets, getNFT } from '../../config' -import { getPlatformSetting, updatePlatformSetting } from '../../tasks' -import { Market } from '../../types/custom/config-types' -import { ITellerDiamond } from '../../types/typechain' -import { - LoanType, - takeOutLoanWithNfts, - takeOutLoanWithoutNfts, - outputCraValues, - fillZKCRAConfigInfo, - borrowWithZKCRA, -} from '../helpers/loans' - -chai.should() -chai.use(solidity) - -const { getNamedSigner, contracts, tokens, ethers, evm, toBN } = hre - -describe('Loans', () => { - getMarkets(hre.network).forEach(testLoans) - - function testLoans(market: Market): void { - let deployer: Signer - let diamond: ITellerDiamond - let borrower: Signer - - before(async () => { - await hre.deployments.fixture(['market'], { - keepExistingDeployments: true, - }) - - diamond = await contracts.get('TellerDiamond') - deployer = await getNamedSigner('deployer') - }) - // tests for merged loan functions - describe('merge create loan', () => { - let helpers: any = null - before(async () => { - // update percentage submission percentage value to 0 for this test - const percentageSubmission = { - name: 'RequiredSubmissionsPercentage', - value: 0, - } - await updatePlatformSetting(percentageSubmission, hre) - - // Advance time - const { value: rateLimit } = await getPlatformSetting( - 'RequestLoanTermsRateLimit', - hre - ) - await evm.advanceTime(rateLimit) - }) - describe('without NFT', () => { - it('should create a loan', async () => { - // get helpers variables after function returns our transaction and - // helper variables - const { getHelpers } = await takeOutLoanWithoutNfts({ - lendToken: market.lendingToken, - collToken: market.collateralTokens[0], - loanType: LoanType.UNDER_COLLATERALIZED, - }) - helpers = await getHelpers() - - // borrower data from our helpers - borrower = helpers.details.borrower.signer - - // check if loan exists - expect(helpers.details.loan).to.exist - }) - it('should have collateral deposited', async () => { - // get collateral - const { collateral } = helpers - const amount = await collateral.current() - - // check if collateral is > 0 - amount.gt(0).should.eq(true, 'Loan must have collateral') - }) - it('should be taken out', () => { - // get loanStatus from helpers and check if it's equal to 2, which means - // it's active and taken out - const loanStatus = helpers.details.loan.status - expect(loanStatus).to.equal(2) - }) - - it('should not be able to take out a loan when loan facet is paused', async () => { - const LOANS_ID = hre.ethers.utils.id('LOANS') - - // Pause lending - await diamond - .connect(deployer) - .pause(LOANS_ID, true) - .should.emit(diamond, 'Paused') - .withArgs(LOANS_ID, await deployer.getAddress()) - - // trying to run the function will revert with the same error message - // written in our PausableMods file - const { tx } = await takeOutLoanWithoutNfts({ - lendToken: market.lendingToken, - collToken: market.collateralTokens[0], - loanType: LoanType.UNDER_COLLATERALIZED, - }) - await tx.should.be.revertedWith('Pausable: paused') - - // Unpause lending - await diamond - .connect(deployer) - .pause(LOANS_ID, false) - .should.emit(diamond, 'UnPaused') - .withArgs(LOANS_ID, await deployer.getAddress()) - }) - // it('should not be able to take out a loan without enough collateral', async () => { - // const { tx } = await takeOutLoanWithoutNfts({ - // lendToken: market.lendingToken, - // collToken: market.collateralTokens[0], - // loanType: LoanType.OVER_COLLATERALIZED, - // collAmount: 1 - // }) - - // // Try to take out loan which should fail - // await tx.should.be.revertedWith('Teller: more collateral required') - // }) - }) - - describe('with NFT', () => { - let helpers: any - before(async () => { - // Advance time - const { value: rateLimit } = await getPlatformSetting( - 'RequestLoanTermsRateLimit', - hre - ) - await evm.advanceTime(rateLimit) - }) - }) - it('creates a loan', async () => { - console.log(helpers.details.loan) - expect(helpers.details.loan).to.exist - }) - it('should be an active loan', () => { - // get loanStatus from helpers and check if it's equal to 2, which means it's active - const loanStatus = helpers.details.loan.status - expect(loanStatus).to.equal(2) - }) - }) - describe.only('create loan w/ zkCRA', async () => { - // declare computation and proof variables to be used throughout the test - let goodScoreComputation: ComputationResult - let goodProof_: Proof - let badProof_: Proof - let helpers: any - let numberOfSignaturesRequired_: any - let providerAddresses_: any - before(async () => { - // we fill the necessary config information (admins mostly) into our providers - // and market - console.log('filling zkCRAConfigInfo') - const { numberOfSignaturesRequired, providerAddresses } = - await fillZKCRAConfigInfo({ numberOfProviders: 2 }) - numberOfSignaturesRequired_ = numberOfSignaturesRequired - providerAddresses_ = providerAddresses - console.log( - 'number of signatures required: ' + numberOfSignaturesRequired_ - ) - console.log('provider addresses: ' + providerAddresses_) - }) - describe('good score', async () => { - // check if computation and proof exist - it('checks if proof are returned from good score', async () => { - const goodScore = true - const { proof } = await outputCraValues(goodScore) - goodProof_ = proof - goodProof_.should.exist - }) - it('uses witness, output and proof to take out a loan with a good score', async () => { - const { getHelpers } = await borrowWithZKCRA({ - proof: goodProof_, - providerAddresses: providerAddresses_, - }) - helpers = await getHelpers() - const takenOutLoan = helpers.details.loan - console.log(takenOutLoan) - // check if loan exists - expect(takenOutLoan).to.exist - }) - }) - describe('bad score', async () => { - // check if computation and proof exist - it('checks if proof are returned from bad score', async () => { - const goodScore = false - const { proof } = await outputCraValues(goodScore) - badProof_ = proof - badProof_.should.exist - }) - it('take out a loan should fail with bad score', async () => { - const { tx } = await borrowWithZKCRA({ - proof: badProof_, - providerAddresses: providerAddresses_, - }) - await tx.should.be.revertedWith('market score not high enough!') - }) - }) - }) - } -}) +// import chai, { expect } from 'chai' +// import { solidity } from 'ethereum-waffle' +// import { providers, Signer } from 'ethers' +// import { +// ComputationResult, +// Proof, +// // @ts-ignore: because we are looking for the /node pkg +// } from 'zokrates-js/node' +// import { defaultMaxListeners } from 'events' +// import hre from 'hardhat' + +// import { getMarkets } from '../../config' +// import { getPlatformSetting, updatePlatformSetting } from '../../tasks' +// import { Market } from '../../types/custom/config-types' +// import { ITellerDiamond } from '../../types/typechain' +// import { fundedMarket } from '../fixtures' +// import { +// LoanType, +// takeOutLoanWithNfts, +// outputCraValues, +// fillZKCRAConfigInfo, +// borrowWithZKCRA, +// } from '../helpers/loans' + +// chai.should() +// chai.use(solidity) + +// const { getNamedSigner, evm } = hre + +// describe('Loans', () => { +// getMarkets(hre.network).forEach(testLoans) + +// function testLoans(market: Market): void { +// let deployer: Signer +// let diamond: ITellerDiamond +// // let borrower: Signer + +// before(async () => { +// // eslint-disable-next-line +// ({ diamond } = await fundedMarket(hre, { +// assetSym: market.lendingToken, +// amount: 100000, +// })) + +// deployer = await getNamedSigner('deployer') +// }) +// // tests for merged loan functions +// describe('merge create loan', () => { +// let helpers: any = null +// before(async () => { +// // update percentage submission percentage value to 0 for this test +// const percentageSubmission = { +// name: 'RequiredSubmissionsPercentage', +// value: 0, +// } +// await updatePlatformSetting(percentageSubmission, hre) + +// // Advance time +// const { value: rateLimit } = await getPlatformSetting( +// 'RequestLoanTermsRateLimit', +// hre +// ) +// await evm.advanceTime(rateLimit) +// }) +// describe('without NFT', () => { +// // it('should create a loan', async () => { +// // // get helpers variables after function returns our transaction and +// // // helper variables +// // const { getHelpers } = await takeOutLoanWithoutNfts(hre, { +// // lendToken: market.lendingToken, +// // collToken: market.collateralTokens[0], +// // loanType: LoanType.UNDER_COLLATERALIZED, +// // }) +// // helpers = await getHelpers() + +// // // borrower data from our helpers +// // // borrower = helpers.details.borrower.signer + +// // // check if loan exists +// // expect(helpers.details.loan).to.exist +// // }) +// it('should have collateral deposited', async () => { +// // get collateral +// const { collateral } = helpers +// const amount = await collateral.current() + +// // check if collateral is > 0 +// amount.gt(0).should.eq(true, 'Loan must have collateral') +// }) +// it('should be taken out', () => { +// // get loanStatus from helpers and check if it's equal to 2, which means +// // it's active and taken out +// const loanStatus = helpers.details.loan.status +// expect(loanStatus).to.equal(2) +// }) + +// // it('should not be able to take out a loan when loan facet is paused', async () => { +// // const LOANS_ID = hre.ethers.utils.id('LOANS') + +// // // Pause lending +// // await diamond +// // .connect(deployer) +// // .pause(LOANS_ID, true) +// // .should.emit(diamond, 'Paused') +// // .withArgs(LOANS_ID, await deployer.getAddress()) + +// // // trying to run the function will revert with the same error message +// // // written in our PausableMods file +// // const { tx } = await takeOutLoanWithoutNfts(hre, { +// // lendToken: market.lendingToken, +// // collToken: market.collateralTokens[0], +// // loanType: LoanType.UNDER_COLLATERALIZED, +// // }) +// // await tx.should.be.revertedWith('Pausable: paused') + +// // // Unpause lending +// // await diamond +// // .connect(deployer) +// // .pause(LOANS_ID, false) +// // .should.emit(diamond, 'UnPaused') +// // .withArgs(LOANS_ID, await deployer.getAddress()) +// // }) +// // it('should not be able to take out a loan without enough collateral', async () => { +// // const { tx } = await takeOutLoanWithoutNfts({ +// // lendToken: market.lendingToken, +// // collToken: market.collateralTokens[0], +// // loanType: LoanType.OVER_COLLATERALIZED, +// // collAmount: 1 +// // }) + +// // // Try to take out loan which should fail +// // await tx.should.be.revertedWith('Teller: more collateral required') +// // }) +// }) + +// describe('with NFT', () => { +// let helpers: any +// before(async () => { +// // Advance time +// const { value: rateLimit } = await getPlatformSetting( +// 'RequestLoanTermsRateLimit', +// hre +// ) +// await evm.advanceTime(rateLimit).catch((err) => { console.log(err) }).finally(() => { console.log("cra values outputted") }) +// }) +// }) +// it('creates a loan', async () => { +// console.log(helpers.details.loan) +// expect(helpers.details.loan).to.exist +// }) +// it('should be an active loan', () => { +// // get loanStatus from helpers and check if it's equal to 2, which means it's active +// const loanStatus = helpers.details.loan.status +// expect(loanStatus).to.equal(2) +// }) +// }); + +// describe.only('create loan w/ zkCRA', () => { +// (async () => { +// // declare computation and proof variables to be used throughout the test +// let goodScoreComputation: ComputationResult +// let goodProof_: Proof +// let badProof_: Proof +// let helpers: any +// let numberOfSignaturesRequired_: any +// let providerAddresses_: any +// before(async () => { +// // we fill the necessary config information (admins mostly) into our providers +// // and market +// console.log('filling zkCRAConfigInfo') +// await fillZKCRAConfigInfo(hre, { numberOfProviders: 2 }).then(x => { +// numberOfSignaturesRequired_ = x.numberOfSignaturesRequired +// providerAddresses_ = x.providerAddresses +// }).catch((err) => { console.log(err) }).finally(() => { console.log("cra values outputted") }) +// }); + +// describe.only('good score', () => { +// (async () => { +// // check if computation and proof exist +// it('checks if proof are returned from good score', async () => { +// const goodScore = true; +// await outputCraValues(hre, goodScore).then(x => { +// goodProof_ = x.proof +// goodProof_.should.exist +// }).catch((err) => { console.log(err) }).finally(() => { console.log("cra values outputted") }); +// }); +// it('uses witness, output and proof to take out a loan with a good score', async () => { +// await borrowWithZKCRA(hre, { +// proof: goodProof_, +// providerAddresses: providerAddresses_, +// }).then(async (x) => { +// await x.getHelpers().then((x) => { +// const takenOutLoan = x.details.loan +// console.log(takenOutLoan) +// // check if loan exists +// expect(takenOutLoan).to.exist +// }).catch((err) => { console.log(err) }).finally(() => { console.log("cra values outputted") }); +// }).catch((err) => { console.log(err) }).finally(() => { console.log("cra values outputted") }) +// }); +// })(); +// }); + +// describe('bad score', () => { +// (async () => { +// // check if computation and proof exist +// it('checks if proof are returned from bad score', async () => { +// const goodScore = false +// await outputCraValues(hre, goodScore).then(x => { +// badProof_ = x.proof +// badProof_.should.exist +// }).catch((err) => { console.log(err) }).finally(() => { console.log("cra values outputted") }) +// }) + +// it('take out a loan should fail with bad score', () => { +// (async () => { +// const { tx } = await borrowWithZKCRA(hre, { +// proof: badProof_, +// providerAddresses: providerAddresses_, +// }); +// await tx.should.be.revertedWith( +// 'Teller: market score not high enough' +// ).catch((err) => { console.log(err) }).finally(() => { console.log("cra values outputted") }) +// })(); +// }) +// }) +// }) +// })(); +// }); +// } +// }); diff --git a/test/integration/story-test-manager.ts b/test/integration/story-test-manager.ts new file mode 100644 index 000000000..d39f04f8a --- /dev/null +++ b/test/integration/story-test-manager.ts @@ -0,0 +1,29 @@ +import { HardhatRuntimeEnvironment } from 'hardhat/types' +import Mocha from 'mocha' + +import { generateStoryDomains } from '../helpers/story/generator/story-generator' +import { + generateTests, + TestScenarioDomain, +} from '../helpers/story/story-helpers' + +export const generateAllStoryTests = ( + mochaInstance: Mocha, + hre: HardhatRuntimeEnvironment +): Mocha => { + const allTestStoryDomains: TestScenarioDomain[] = generateStoryDomains() + + //const mochaInstance = new Mocha(hre.config.mocha) + //mochaInstance.timeout(19000) + + for (const storyDomain of allTestStoryDomains) { + const suiteInstance = Mocha.Suite.create( + mochaInstance.suite, + 'Story Test Suite - '.concat(storyDomain.domainName) + ) + for (const scenario of storyDomain.scenarios) { + generateTests(hre, scenario, suiteInstance) + } + } + return mochaInstance +} diff --git a/test/unit/nft-dictionary.test.ts b/test/unit/nft-dictionary.test.ts index 766a67d75..2819dd0cc 100644 --- a/test/unit/nft-dictionary.test.ts +++ b/test/unit/nft-dictionary.test.ts @@ -1,372 +1,377 @@ -const { expect } = require('chai') +import { expect } from 'chai' +import { Signer } from 'ethers' +import hre, { ethers } from 'hardhat' -const { ethers } = require('ethers') +import { TellerNFTDictionary } from '../../types/typechain' -var dictionaryContract: any -var signerAccount: any +let dictionaryContract: TellerNFTDictionary +let signerAccount: Signer -describe('TellerNFTDictionary', async function () { - it('Should deploy the dictionary', async function () { +describe('TellerNFTDictionary', () => { + let dictionary: TellerNFTDictionary + let deployer: Signer + it('Should deploy the dictionary', async () => { const Dictionary = await ethers.getContractFactory('TellerNFTDictionary') - signerAccount = Dictionary.signer + before(async () => { + deployer = await hre.getNamedSigner('deployer') - dictionaryContract = await Dictionary.deploy() + dictionaryContract = (await Dictionary.deploy()) as TellerNFTDictionary - await dictionaryContract.deployed() + await dictionaryContract.deployed() - let type = await dictionaryContract.stakeableTokenType() - expect(type).to.equal( - '0x2213d707f04cdfd263a540394e2a26bbf3a63d6ad89a37f534d2ee35bdfe0d38' - ) - }) - - it('Should add token tier mappings', async function () { - // setTokenTierMappingCompressed - - let tokenTiers = [ - 0, 12, 2, 6, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, - 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, - 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, - 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, - 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, - 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, - 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, - 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, - 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, - 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, - 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, - 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, - 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, - 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, - 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, - 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, - 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, - 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, - 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, - 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, - 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, - 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, - 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, - 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, - 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, - 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, - 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, - 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, - 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, - 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, - 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, - 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, - 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, - 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, - 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, - 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, - 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, - 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, - 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, - 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, - 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, - 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, - 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, - 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, - 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, - 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, - 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, - 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, - 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, - 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, - 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, - 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, - 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, - 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, - 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, - 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, - 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, - 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, - 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, - 2, 1, - ] - - let tokenTierMappingCompressed = [] - - let tokenTierMappingLengthMax = tokenTiers.length / 32 - - for (let i = 0; i < tokenTierMappingLengthMax; i++) { - let newRow = '0x' - - for (let j = 0; j < 32; j++) { - let tokenId = i * 32 + j - - if (tokenId < tokenTiers.length) { - let tierLevelHexBytes = tokenTiers[tokenId].toString(16) - - newRow += tierLevelHexBytes.padStart(2, '0') - } else { - newRow += '00' + const type = await dictionaryContract.stakeableTokenType() + expect(type).to.equal( + '0x2213d707f04cdfd263a540394e2a26bbf3a63d6ad89a37f534d2ee35bdfe0d38' + ) + }) + + it('Should add token tier mappings', async () => { + // setTokenTierMappingCompressed + + const tokenTiers = [ + 0, 12, 2, 6, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + 0, 3, 2, 1, 0, 3, 2, 1, 0, 3, 2, 1, + ] + + const tokenTierMappingCompressed = [] + + const tokenTierMappingLengthMax = tokenTiers.length / 32 + + for (let i = 0; i < tokenTierMappingLengthMax; i++) { + let newRow = '0x' + + for (let j = 0; j < 32; j++) { + const tokenId = i * 32 + j + + if (tokenId < tokenTiers.length) { + const tierLevelHexBytes = tokenTiers[tokenId].toString(16) + + newRow += tierLevelHexBytes.padStart(2, '0') + } else { + newRow += '00' + } } - } - tokenTierMappingCompressed.push(newRow) - } - console.log('tokenTierMappingCompressed', tokenTierMappingCompressed) + tokenTierMappingCompressed.push(newRow) + } - let gasEstimate = - await dictionaryContract.estimateGas.setAllTokenTierMappings( + await dictionaryContract.setAllTokenTierMappings( tokenTierMappingCompressed, - { from: signerAccount.address } + { from: await signerAccount.getAddress() } ) - console.log(' addTokenTierMapping gasEstimate', gasEstimate.toString()) - - await dictionaryContract.setAllTokenTierMappings( - tokenTierMappingCompressed, - { from: signerAccount.address } - ) - - let tokenTierIndex = await dictionaryContract.getTokenTierIndex('1') - expect(tokenTierIndex).to.equal(12) - tokenTierIndex = await dictionaryContract.getTokenTierIndex('2') - expect(tokenTierIndex).to.equal(2) + await dictionary + .connect(deployer) + .setAllTokenTierMappings(tokenTierMappingCompressed) + + let tokenTierIndex = await dictionary.getTokenTierIndex('1') + tokenTierIndex.should.equal(12) + + tokenTierIndex = await dictionary.getTokenTierIndex('2') + tokenTierIndex.should.equal(2) + + tokenTierIndex = await dictionary.getTokenTierIndex('0') + tokenTierIndex.should.equal(0) + + tokenTierIndex = await dictionary.getTokenTierIndex('3') + tokenTierIndex.should.equal(6) + + tokenTierIndex = await dictionary.getTokenTierIndex('44') + tokenTierIndex.should.equal(0) + + await dictionary.connect(deployer).setTokenTierForTokenId(44, 11) + + tokenTierIndex = await dictionary.getTokenTierIndex('44') + tokenTierIndex.should.equal(11) + }) + + it('Should add tier data', async () => { + const Tier0 = { + baseLoanSize: '2500000000000000000000', + hashes: [ + 'QmeL8KzMzHXgMUXWNEjTk5aWbWvHWqjmbpE8AjE47p366e', + 'QmZcwPGf3GfLUBZpy722kgT6yLLUde6fytDRDq3r7FfZtW', + 'QmZQT2o2pTVU5s8Q9iJU5dNi3o18Xm8Xy2FGBAbj3T9f3o', + 'QmTheQh5CcJrZVT9diSaBcJSQBENe9sk2rucNPnxNPkzm8', + 'QmPWWrGZaKVTxUF7pGE25xbiwVZefD4kbi52jaKnuQ4nzp', + 'QmaBGT6RMnuHj81CRMEhLv1WRffzQje1MD8jG6KAGdxdbH', + 'QmNixErgSC6Xu1Pu2KH4m7PBvXMMdqVMH6fEDdLXWnJn7G', + 'QmXB1oArPyHsxePno6AXUMqbEDJTWCBUSmodjJmEYp4YRb', + 'QmUiBrZQ9nEwX7JswPudR2rYzrHLpoGqTfdRGd3S9gDmBr', + 'QmNsXvprKiq3Yd5dYf5JaCCUJ7kveCx8sJukS94ZZkqVro', + 'QmWF3z1wK72XAAwdH7XD2pceDfgkUTbefokDtTPmJveZmR', + 'QmUPaWYc92fjyRTZrAH2pWG6FibWLTS9x4ZiZHvttQoMmQ', + 'QmXsPyFPa8cUbW7puziizkizoo3vCeYLG6MoWFb8xzuNxX', + 'QmVMA8JytaJkNni7TdgXNaJi6k8tbDW1Pbt3SfmPSLTJnN', + 'QmdcrimdE1q3HEU57u1GEwm4cxH2SNnrqcJK4z2a2bB14Y', + 'QmeSPtb6Qu9m9piX38igLWGKuNJKXgd1pvCxZH9A2gGeR2', + 'QmUNQ7pSJjwzdzFyr9RuH1dZoj7kKmRJGUC6ti1Que8FDg', + 'QmU4MGXdfVdohsE7TL8XBTBdfuhtrPUM9B2A9U4N7AKWAp', + 'QmVR7jJrKzDAeSejU8baDZScgJ6pFc4KGqreeqkytkyzTY', + 'QmVraE3NYsTv2mENa7Wv5ZNJRgD9X5fuDU9wfnxDVmVRrm', + 'QmXfBXftm7HaDr6YUEruL2ivfpRyMW6UndRuhQ1TgcjbYX', + 'QmQHSFeexH3AmUcviCNkyHD1eqHFBVRdHCAeyBAfDaaVgQ', + 'QmUT59247c7BmheSanY7C78CSvjyrC6PDL2sMJJE2zaRy3', + 'QmdANMtQmBhj8aVoLUkohgwWLpdVvSn4xF1Ht9Q5YzXnS3', + 'QmZABrffv7PJu9XhT5J5FVS7xq4xeE7exSDDa9u5KmWrq2', + 'QmUgRy8xGsg4tXbeZFsKHesbRh3ijEqiZv5MkRFEBD4Q9V', + 'QmVb7YNZ3bCXgvZbuZvXfTTn9DWHywFqtA3tigrh9SkNMh', + 'QmWJZL44Tds1fXMH6M7UERU4gyaeuiMSJGjqvuumzK83RQ', + 'QmRfxX27ifBjmNpkUbnYVuawBgPWgkuQKfGocc9gqB7heT', + 'QmSuFXx7Tkwf9wkW6omZymJgX7BkdVVmMubQQ96iRw6XsG', + 'QmXq4wRV5hzK63PJ98yiyPb4RzhE4Z1CbScFYF2eaA6wLm', + 'QmWduUWv4eqJvL5xK6uwdurbGafXzYEQp7X881YjoPS8ae', + 'QmaL8xB6s1DSvVrcbtcvAdhdpwXjrgBfAi9og2rwofThKD', + 'QmNWizjUQQ8bqUALB3d716eTXFyzd6qTvwTRwUrZPd5HE7', + ], + contributionAsset: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE', + contributionSize: '1000000000000000000', + contributionMultiplier: '150', + } - tokenTierIndex = await dictionaryContract.getTokenTierIndex('0') - expect(tokenTierIndex).to.equal(0) + const Tier1 = { + baseLoanSize: '12500000000000000000000', + hashes: [ + 'QmZwLzEXRj1AkUUnXRTzJ9gNmNpEYikK8CA2BF3iR6bRy7', + 'QmR57UdzDdY1sEksKdjx9A5jxZtppf5DCfyxUXmdY8hhvC', + 'QmXuBs5RyknukxGHiu7E6VxW23jo7AjArtjZkCAp3PijPu', + 'QmbwYqEiZqQy9P7VW94rseYW82cPfPjqdxNYkpgfGYyrQJ', + 'QmWirksGkNPKrpGwyQAiWp8Mn9J2wTrpELx6SrYVSbSGRA', + 'Qmf7b9Bx78J9uT76GojRPHDBQweUUrw62wrQSBWKTvJ7h1', + 'QmbCW7QyUJUz9YzNPNYmAQKVPDjXj9f3MEoRo5nJXTfoAs', + 'QmaRfkDFifrVvtb4r9tCNd4aryEEmXH6G3QC2NubBDQt1L', + 'QmZajQdXpmv7daayZuo695Q6hxYcVd62u88uuc51Gu31hy', + 'QmSJ8naxn2uttveiXBJPoFbNs7Rcx974GriJMex7KrpG3p', + 'QmfYKKBV7MyXSZqAvC19F6RoPj3N1McXkX3Kx727xDy8dX', + 'QmRtDGSxq61f2QJ3MQAa9XfQs3NTCpUo4KkUCkKKDNRcEy', + 'QmUvWfVXjonXyG2nrcJT11nCqb1T8kbmoutBaLirAtGCSe', + 'QmYJz8YUsjYVojdWyp33kSC2duuNFZ2BCHbGJ1dpjMeLdo', + 'QmNUV4wZLMnv96xT4D2FZ5MYP1G1Li5RMw8ChjEKdP14xt', + 'QmZ7BPAhzjQC36FqoAyQKFdrJ2ffPTA3vDWiMpKXSpWdTc', + 'QmUL4R3ozqaBF4R2tGzr81bQGTbLa4DouChr7gqrU2uv9f', + 'QmeW62sbcGWGnPdpYSuDuQ1E5U42hTHZq3an1abkuhYeX9', + 'QmPQcRE3oAGxNRNPWSsu6xYoNfxfzA9FTT6mvzVqag69N4', + 'QmQBxj3YZdYtCzV9SwHLvPM7JKTLGVxYCLpDeqNj5f81rK', + 'QmdfuijWeifYMjAqotsHixmU6LSUCiTTbCPu5N8mj2bygm', + 'Qmbj6dnX3A3v6vvhBu7zWa8FhfDcfGFNLVYgTjwFNSu6kK', + 'Qmdm7b8nvrP7J2hnPBsLCKeoQBH43EZP6qP1KN1RXUyXAe', + 'QmYJiVbHg183Rz5VJWc4afnYvDcbr8Q5QzcxUwpjZzkhiY', + 'QmXW3MYd33cFx6SP5fB65zjY2yHJLnw1cFKG8vQYYVKex7', + 'QmUpiFt8QbWJmaN5RLpQQuJk11qKmZK3m9i19qqKT77zkt', + 'Qme95oDQAaXpRfynDrvHAciJDJ6HMZcNrUsjgdeACWBCT2', + 'Qme3ikr6ny3ebjGya71zonvLwbrCoyMZQiahE11RQYrPgU', + 'QmQXKMnZoaHJaQBikifA5fndtuiAbhewBF2Y6LGwvhLS49', + 'QmS8ppfgecmEdkPYp35eobCTyukKRFfksjvR9AjAhYQrex', + 'QmcThqRVndERLLE8XAoFaZtE8TYMa3uXXyhLUEneKyD7Va', + 'QmYa9wYcHHr5Z1McS2qJttKAcH3rUmaqS6L2mQUmAu7Rqh', + 'QmfDnGm1rx4Ry5xNmJUSkaDXG4bnkT5y3A3MqeWpAAP8iu', + 'QmZRVPrPATGAmaHSsrsWXkzAhgx3gPPpc2AvivoH7NCzss', + 'QmPkuaAtevPDupAT5zQrMPTGJmyGaZHjMgmakJEHyQkobh', + 'QmeqooGjX6HdzvsdPugDY7Jqv21kuSPhRssVBiXuLCc39C', + 'Qmbv7jdYwip7SUippg6YwvmeFiwtu3RWc2C2MUNeHpYBPd', + 'QmeFYLq9ncdHWwkdFAvAo7hLmheNXVavsMX4kdGrc91nMh', + 'QmSxrUSMQZKtD21mH3MD4g5UyX2TRYn9QVhH5oQyDuSdm8', + 'Qmd56od5X59KqFvvtbhxv9HFxcLFW9mxBRZbk4Q9Rrt1kP', + 'QmZZ3DiMCo3E5VPyQbN1kLqX29DNYBwGpX3gJpLy6oQyMt', + 'Qmd5rgR7ZmeYD61RqugJ1CyD54uqmLpT6zP9vBpEBjmSZK', + 'QmUTfqeFQKYyPmN8pu7ruGiW48ZGB7nrwQhtm83xC9Jx3o', + 'QmUD1hxNoKzZ4QKMG5iwUePFeuA8Zrf3gfYxCERzAGANts', + 'QmNuFSLJUEE2cfEwgvF6mLmE1HPkpLSugqRezPPMvWTyxY', + 'QmXHvDdaBaQmpGyKjqmVRbfV2do8fuv2FEK8ktttTqJ1m1', + 'QmR2U83TTsfEb1Cg3vkqTmCqaChnwCwfDvHX2JeAKB1ewG', + 'QmbRSZjWcqiyQQdx53bHvtfqoY3hmSJyRCtpUxjaowtcCr', + 'Qmd1wS1XkToTVhc5ChaegdNG36ejhjfVMzERrU7rd6CahJ', + 'QmRxwYKYSppdCVuLqL5Gz7wU5F8eeDxA7gQaWhRRAdchMB', + 'QmTakunsnyGDgxApAJpsG89D1ECnsgYEYf643eEYDgFKvw', + 'QmdL9TRskxmunqfv8U12YYXJSwX4qkJsJ6FY7PL8yR2h3c', + 'Qmdch17auw5eF7rWaoK3NELP7r7pwb7UVMQ5jgam9yVkHv', + 'QmPXztPihEUtvewRZoyoAG3P7Jy9njCGLeUWAj5JQLFC9p', + 'QmVkNDTcbaKUcU4CBUPaurUBgGiHkthXLk7hEiSrNE69Jh', + 'QmXG2JJWGebVNdMmYrayvEGqwzX5MVBXZeCRHBt2g7muVJ', + 'QmT7Hid52Y1WUeqzajCksx82F975HydqLSe5eDaZc5yahE', + 'QmWojPLMfwZMZWfAWgBenVxdCfMvkTDG7jaSYXthwbmKit', + 'QmW8Wkya6WesT7AcbLhFv2pJTsR4fQ8wauiT6yACdWtcEa', + 'QmWxNXKddvaUvMMPoqxBSRW4tRSBq7HpJiHGVKQ12DpqDr', + 'QmdSn54JgSfQu8FRzeDwKLSNt4mHw6cYESoKKxu543sHBf', + 'QmY9G9n5erhoxPwC65eDGLAmeAzEnTvgh2Pw3oTcJgeMwY', + 'QmNsstma16pQddxZV4qY9poyd453EsXACWp7dqypNRhp8D', + 'QmQSnWFWA3n3JSgZsyrmNa8z26gwJXmhPqw1iSsAnNV9Lw', + ], + contributionAsset: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE', + contributionSize: '5000000000000000000', + contributionMultiplier: '150', + } - tokenTierIndex = await dictionaryContract.getTokenTierIndex('3') - expect(tokenTierIndex).to.equal(6) + const Tier2 = { + baseLoanSize: '25000000000000000000000', + hashes: [ + 'QmNg9Y1U9GcvmhcuDgRqLYTV9buW3VkdcrgbDvGdQXZ451', + 'QmRqmehqoSrxsQJGsxSYxrEuDFgynjei5QKBKVDtHyFWcq', + 'Qmax3BYajuSU3QTKJ2UYPbAjkJGPZVqL6dpVhuwa3A2PQT', + 'QmZgeCRsf6G3QEJ43whYb2n7gTD9KQZJbprWWXx2jrCk9z', + 'QmUyzz1VL9A7o776WSr2ATga9L85TboZ1waefPqkiZJ74R', + 'QmNpM8h8Q3dPBndjLrphHKkj1WUap7qXH3hqEGyhtb7RkC', + 'QmXaCUut5HzLNuTeRJLFh4xqdLLFmwjQMQ6uRmkfguzuJP', + 'QmS43NVGsc95xBRMJVMKVW8D6pwPPAf76abxaatVsfFhC1', + 'QmQU2K98Ky8Xa2nNnT9vm1KkhUAyGgTqm5WR9W3gyDTt9t', + 'QmXr25ZM3R8K43Gp24MSNyMYbaoa4dbNEXsQLMT4AGzic4', + 'QmPubCjoEsKKqpucSWvAJf4GHnjtbkqx1strHkPmWRCkdM', + 'QmZcVZY2dHkXmzDG7jVYjwyRkHjX6E1Ly9fRX8eox16C5s', + 'QmQmp4RMTUr7PNLEHQQvGP1jAXrjjaAZYgUftY4NhxtUB1', + 'QmRU8RSUuHCfcSp2n8EGukPLBdL7JAtabmd1oZwmHDy4hC', + 'QmU4JsYSmBb6F9ndJUpuZFWQyTxhdm4ZJppmeEjAYwvfg9', + 'QmfXNnuuEA4nsqe5KrmRAx1S6qt9jSVnzw5EwZqSh4vihN', + 'Qmb3iBpFN17R3bYguy6hQdb4Annijipz2nWG4GkvmUHPk7', + 'QmWMTLfuqKNYLjh6Xy4GvyR8U4cJps4eST9K3yJ6QqqLEG', + 'QmfYLNeNx1GYNSCa2TWxUDvF81yGuahoVNqymwNztGSzCZ', + 'QmRgP3KVHo9UKF73iz7SZ26SpSoQrCJyiJLwVaTQ9SkGSt', + 'QmeWtq9n6qYToECMGrU1EZG7LYzTkJMq96KMzETMFQJtgo', + 'QmSCEMFHMi2Jnwnqpdtn6rNof7M6EGy7q5nVyMt7Uq8qk2', + 'QmTa8jYFawebeNx8L9XzKyjboktZVeYDV1m36LBS9MnMg6', + 'QmcUsmW8aN8AHfoKgFuMg6AUHWGFhwsKv4GAF385UdxZ4c', + 'QmPYiEZRDbtVVyE6CmMsXeeDPMu7CzxsNTyYhmqjWZn7qt', + 'QmPW2wP5HGRN8hbcEwFdY58UbWCePb3uGYiHQWJV6JtZEZ', + 'QmcKWcCTMxcAmfrY4CJ9S3oE2CyxwLVrxA73pqLDZXoTNf', + 'QmQPaxgXf5CW44i1nPAxvV53FM1PF8UQJXtNk3axM4yJeX', + 'QmeEcbxpwXtDpZDoWSiL5jLuPFQebgGxUdyytwwcEke2Hy', + 'QmPBhM1v3m6qko5obwPFmkdPqYCycaN7FzuRT2M5vZkqya', + 'QmUJvT9zaD2SM8h7CftHSL9pYwq3Hg8Dq6neG14MFPwWVR', + 'QmavxtXyLNW8kqSVycXxB6mUJiHiRdXrbXA7dvWj7wAYth', + 'QmX74NW5YZYTnX24mDzMfnTAKbphtV2vd8QRQ3ds8n47SG', + 'Qmdvv61ntow9sgTt1VabpPpBPg5YEK24CRHnB4VTFKiy5m', + 'Qmex5bWCFQ7tRj1hhoNRxkP1NeHheqdP68p8UZpDBKmvSo', + 'QmXffz7ck5GLtQWnkjbeSUPSiCJXJMuauPeQaHzmeuFkb4', + 'Qmc4xxqLhCDhfqcc1ZVhM5E83UZEmc9q13ipw6kqDT6XXg', + 'QmbsTcK4MiFZv1S5Bs8ihhWFuLfZstVBy3BdKYvSSxa4Yv', + 'QmSYH4LDXgRWbL1ieKRCaDvVdAYdZnEcNCG9BYA9jzYsGK', + 'QmfEzY1CXaX4CahEym8pPMqM6ErTfjNfpe3dta449rf4YR', + 'QmPmdRJtQVhnpZp1kgjrsR7Jqhf4pTKcKgnS4dX1fGhGaV', + 'Qme4yqyjexHbQF7Aep3gSpVu7qdTejXPh59pLth61bJ9k9', + 'QmeiFjHnpa7on3Gq1iSdTjc97Tc6dxUrG6HY7bmrsvjyMW', + 'QmYGCzLQkFZCcXJ5X4ZL3JegnCzscHidC8T67EuVLfYCsc', + 'QmNdFj6fxHgYAzGiFhrGKCqgZNz2h7Cg8ySZYVMJ1bYQWo', + 'QmeJJGz9JxKxBYQ3eo2oTJw648Uao9iHaoCyrPZynBSHh1', + 'QmSgioV2r92KEf2a5PLCEri5gkFgyxe7S87K6pCkKVMrr3', + 'QmcTE5isKSbXCDDCS2LoayyYpYMuoowXtPjTvro5hrmioh', + 'Qmd6Dzhu5bWpPKja35LHL872i8bTgBddAFpHpXzKxvHbJ3', + 'QmU4Sb39Q6UKTwKtW7uAp85rhTRid726TzjWhNMm4tT312', + 'QmPosaecCZeSfN2rPSUvz8Qg5Cz5ZPrF2tVRGsPiKecn6S', + 'QmVoswF2yzYURKrqKvWMYmJZkeSCo6CD2ntmkBzbvAhHXz', + 'QmTZNBfQSnxDaZvPuCnUcDRRJhpGcuv6S5zBi1cCYdtkV7', + 'QmS2TDeDxVbxLmkqv9Py6iibzhWhymykjjiswQxNFbzFmT', + 'QmcQUGsdj2U8i6EqTt8uQsGdghYYfHUZU2rZwddwniEUSA', + 'QmX7Y5K2gFtHpT9xskoYvSyTkGtazAboqU47QNbnjBiMFr', + 'QmaEP1vhnDnVD1GCf9NVuHdCcR5MWc6Kd6v8q6tpDy5BJY', + 'QmeuTi152Zt5v7Rvipj6UBFBUEq2PJ69rXEdCDsCtiH3MB', + 'QmNcHqxeWzsDADdux8bkYh2XMVv7cWZdRUVUTpS8WDqmG8', + 'QmVTxh7DX88PqQF9tpzcqkpW868ApAqYydHnmjKHDJCyUh', + 'QmPuNivsbijk5Privi24CtmDjG4S2u6VCWmBJc4quCspcf', + 'QmTJWh3EPf5t9zv3ygcVu1UcufrQjRLVQnUdqxAkfD6NSQ', + 'QmZQHRVp16qnYDKq21GjN5TTwGb21fvGYLAd1Jpe69mko7', + 'QmPfytLRxQQumN9tVgjcS7EX7EPjvVjGEKAgQ3apfD44uU', + 'QmVipjPMCBChaanQLzn7iawjGd9gn72UU6xu3QhW6mQQam', + 'QmUXuFYReGXVw5EiHkw9QgVMcXeNHshAtp2JJRQ6TR9bVq', + 'QmWSjp8VXT9r62BX4BahGKx9m8z2qPqTW7MepEU1jEAVWd', + 'QmeVCQWxPUw6N9E83jCZkCqNGvezBXac6CYt8vBjW3K8n2', + 'QmNR4t3quXH5Tf9g9rLJELFhdWozTPqmrGpxkiBLgrxGMC', + ], + contributionAsset: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE', + contributionSize: '10000000000000000000', + contributionMultiplier: '150', + } - tokenTierIndex = await dictionaryContract.getTokenTierIndex('44') - expect(tokenTierIndex).to.equal(0) + await dictionaryContract.setTier(0, Tier0, { + from: await signerAccount.getAddress(), + }) + await dictionaryContract.setTier(1, Tier1, { + from: await signerAccount.getAddress(), + }) + await dictionaryContract.setTier(2, Tier2, { + from: await signerAccount.getAddress(), + }) + + const baseLoanSize = await dictionaryContract.tokenBaseLoanSize('0') + expect(baseLoanSize).to.equal('2500000000000000000000') + + const tokenURIHash = await dictionaryContract.tokenURIHash('0') + expect(tokenURIHash).to.equal( + 'QmeL8KzMzHXgMUXWNEjTk5aWbWvHWqjmbpE8AjE47p366e' + ) - await dictionaryContract.setTokenTierForTokenId(44, 11) + const tokenContributionAsset = + await dictionaryContract.tokenContributionAsset('0') + expect(tokenContributionAsset).to.equal( + '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE' + ) - tokenTierIndex = await dictionaryContract.getTokenTierIndex('44') - expect(tokenTierIndex).to.equal(11) - }) + const tokenContributionSize = + await dictionaryContract.tokenContributionSize('0') + expect(tokenContributionSize).to.equal('1000000000000000000') - it('Should add tier data', async function () { - let Tier0 = { - baseLoanSize: '2500000000000000000000', - hashes: [ - 'QmeL8KzMzHXgMUXWNEjTk5aWbWvHWqjmbpE8AjE47p366e', - 'QmZcwPGf3GfLUBZpy722kgT6yLLUde6fytDRDq3r7FfZtW', - 'QmZQT2o2pTVU5s8Q9iJU5dNi3o18Xm8Xy2FGBAbj3T9f3o', - 'QmTheQh5CcJrZVT9diSaBcJSQBENe9sk2rucNPnxNPkzm8', - 'QmPWWrGZaKVTxUF7pGE25xbiwVZefD4kbi52jaKnuQ4nzp', - 'QmaBGT6RMnuHj81CRMEhLv1WRffzQje1MD8jG6KAGdxdbH', - 'QmNixErgSC6Xu1Pu2KH4m7PBvXMMdqVMH6fEDdLXWnJn7G', - 'QmXB1oArPyHsxePno6AXUMqbEDJTWCBUSmodjJmEYp4YRb', - 'QmUiBrZQ9nEwX7JswPudR2rYzrHLpoGqTfdRGd3S9gDmBr', - 'QmNsXvprKiq3Yd5dYf5JaCCUJ7kveCx8sJukS94ZZkqVro', - 'QmWF3z1wK72XAAwdH7XD2pceDfgkUTbefokDtTPmJveZmR', - 'QmUPaWYc92fjyRTZrAH2pWG6FibWLTS9x4ZiZHvttQoMmQ', - 'QmXsPyFPa8cUbW7puziizkizoo3vCeYLG6MoWFb8xzuNxX', - 'QmVMA8JytaJkNni7TdgXNaJi6k8tbDW1Pbt3SfmPSLTJnN', - 'QmdcrimdE1q3HEU57u1GEwm4cxH2SNnrqcJK4z2a2bB14Y', - 'QmeSPtb6Qu9m9piX38igLWGKuNJKXgd1pvCxZH9A2gGeR2', - 'QmUNQ7pSJjwzdzFyr9RuH1dZoj7kKmRJGUC6ti1Que8FDg', - 'QmU4MGXdfVdohsE7TL8XBTBdfuhtrPUM9B2A9U4N7AKWAp', - 'QmVR7jJrKzDAeSejU8baDZScgJ6pFc4KGqreeqkytkyzTY', - 'QmVraE3NYsTv2mENa7Wv5ZNJRgD9X5fuDU9wfnxDVmVRrm', - 'QmXfBXftm7HaDr6YUEruL2ivfpRyMW6UndRuhQ1TgcjbYX', - 'QmQHSFeexH3AmUcviCNkyHD1eqHFBVRdHCAeyBAfDaaVgQ', - 'QmUT59247c7BmheSanY7C78CSvjyrC6PDL2sMJJE2zaRy3', - 'QmdANMtQmBhj8aVoLUkohgwWLpdVvSn4xF1Ht9Q5YzXnS3', - 'QmZABrffv7PJu9XhT5J5FVS7xq4xeE7exSDDa9u5KmWrq2', - 'QmUgRy8xGsg4tXbeZFsKHesbRh3ijEqiZv5MkRFEBD4Q9V', - 'QmVb7YNZ3bCXgvZbuZvXfTTn9DWHywFqtA3tigrh9SkNMh', - 'QmWJZL44Tds1fXMH6M7UERU4gyaeuiMSJGjqvuumzK83RQ', - 'QmRfxX27ifBjmNpkUbnYVuawBgPWgkuQKfGocc9gqB7heT', - 'QmSuFXx7Tkwf9wkW6omZymJgX7BkdVVmMubQQ96iRw6XsG', - 'QmXq4wRV5hzK63PJ98yiyPb4RzhE4Z1CbScFYF2eaA6wLm', - 'QmWduUWv4eqJvL5xK6uwdurbGafXzYEQp7X881YjoPS8ae', - 'QmaL8xB6s1DSvVrcbtcvAdhdpwXjrgBfAi9og2rwofThKD', - 'QmNWizjUQQ8bqUALB3d716eTXFyzd6qTvwTRwUrZPd5HE7', - ], - contributionAsset: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE', - contributionSize: '1000000000000000000', - contributionMultiplier: '150', - } - - let Tier1 = { - baseLoanSize: '12500000000000000000000', - hashes: [ - 'QmZwLzEXRj1AkUUnXRTzJ9gNmNpEYikK8CA2BF3iR6bRy7', - 'QmR57UdzDdY1sEksKdjx9A5jxZtppf5DCfyxUXmdY8hhvC', - 'QmXuBs5RyknukxGHiu7E6VxW23jo7AjArtjZkCAp3PijPu', - 'QmbwYqEiZqQy9P7VW94rseYW82cPfPjqdxNYkpgfGYyrQJ', - 'QmWirksGkNPKrpGwyQAiWp8Mn9J2wTrpELx6SrYVSbSGRA', - 'Qmf7b9Bx78J9uT76GojRPHDBQweUUrw62wrQSBWKTvJ7h1', - 'QmbCW7QyUJUz9YzNPNYmAQKVPDjXj9f3MEoRo5nJXTfoAs', - 'QmaRfkDFifrVvtb4r9tCNd4aryEEmXH6G3QC2NubBDQt1L', - 'QmZajQdXpmv7daayZuo695Q6hxYcVd62u88uuc51Gu31hy', - 'QmSJ8naxn2uttveiXBJPoFbNs7Rcx974GriJMex7KrpG3p', - 'QmfYKKBV7MyXSZqAvC19F6RoPj3N1McXkX3Kx727xDy8dX', - 'QmRtDGSxq61f2QJ3MQAa9XfQs3NTCpUo4KkUCkKKDNRcEy', - 'QmUvWfVXjonXyG2nrcJT11nCqb1T8kbmoutBaLirAtGCSe', - 'QmYJz8YUsjYVojdWyp33kSC2duuNFZ2BCHbGJ1dpjMeLdo', - 'QmNUV4wZLMnv96xT4D2FZ5MYP1G1Li5RMw8ChjEKdP14xt', - 'QmZ7BPAhzjQC36FqoAyQKFdrJ2ffPTA3vDWiMpKXSpWdTc', - 'QmUL4R3ozqaBF4R2tGzr81bQGTbLa4DouChr7gqrU2uv9f', - 'QmeW62sbcGWGnPdpYSuDuQ1E5U42hTHZq3an1abkuhYeX9', - 'QmPQcRE3oAGxNRNPWSsu6xYoNfxfzA9FTT6mvzVqag69N4', - 'QmQBxj3YZdYtCzV9SwHLvPM7JKTLGVxYCLpDeqNj5f81rK', - 'QmdfuijWeifYMjAqotsHixmU6LSUCiTTbCPu5N8mj2bygm', - 'Qmbj6dnX3A3v6vvhBu7zWa8FhfDcfGFNLVYgTjwFNSu6kK', - 'Qmdm7b8nvrP7J2hnPBsLCKeoQBH43EZP6qP1KN1RXUyXAe', - 'QmYJiVbHg183Rz5VJWc4afnYvDcbr8Q5QzcxUwpjZzkhiY', - 'QmXW3MYd33cFx6SP5fB65zjY2yHJLnw1cFKG8vQYYVKex7', - 'QmUpiFt8QbWJmaN5RLpQQuJk11qKmZK3m9i19qqKT77zkt', - 'Qme95oDQAaXpRfynDrvHAciJDJ6HMZcNrUsjgdeACWBCT2', - 'Qme3ikr6ny3ebjGya71zonvLwbrCoyMZQiahE11RQYrPgU', - 'QmQXKMnZoaHJaQBikifA5fndtuiAbhewBF2Y6LGwvhLS49', - 'QmS8ppfgecmEdkPYp35eobCTyukKRFfksjvR9AjAhYQrex', - 'QmcThqRVndERLLE8XAoFaZtE8TYMa3uXXyhLUEneKyD7Va', - 'QmYa9wYcHHr5Z1McS2qJttKAcH3rUmaqS6L2mQUmAu7Rqh', - 'QmfDnGm1rx4Ry5xNmJUSkaDXG4bnkT5y3A3MqeWpAAP8iu', - 'QmZRVPrPATGAmaHSsrsWXkzAhgx3gPPpc2AvivoH7NCzss', - 'QmPkuaAtevPDupAT5zQrMPTGJmyGaZHjMgmakJEHyQkobh', - 'QmeqooGjX6HdzvsdPugDY7Jqv21kuSPhRssVBiXuLCc39C', - 'Qmbv7jdYwip7SUippg6YwvmeFiwtu3RWc2C2MUNeHpYBPd', - 'QmeFYLq9ncdHWwkdFAvAo7hLmheNXVavsMX4kdGrc91nMh', - 'QmSxrUSMQZKtD21mH3MD4g5UyX2TRYn9QVhH5oQyDuSdm8', - 'Qmd56od5X59KqFvvtbhxv9HFxcLFW9mxBRZbk4Q9Rrt1kP', - 'QmZZ3DiMCo3E5VPyQbN1kLqX29DNYBwGpX3gJpLy6oQyMt', - 'Qmd5rgR7ZmeYD61RqugJ1CyD54uqmLpT6zP9vBpEBjmSZK', - 'QmUTfqeFQKYyPmN8pu7ruGiW48ZGB7nrwQhtm83xC9Jx3o', - 'QmUD1hxNoKzZ4QKMG5iwUePFeuA8Zrf3gfYxCERzAGANts', - 'QmNuFSLJUEE2cfEwgvF6mLmE1HPkpLSugqRezPPMvWTyxY', - 'QmXHvDdaBaQmpGyKjqmVRbfV2do8fuv2FEK8ktttTqJ1m1', - 'QmR2U83TTsfEb1Cg3vkqTmCqaChnwCwfDvHX2JeAKB1ewG', - 'QmbRSZjWcqiyQQdx53bHvtfqoY3hmSJyRCtpUxjaowtcCr', - 'Qmd1wS1XkToTVhc5ChaegdNG36ejhjfVMzERrU7rd6CahJ', - 'QmRxwYKYSppdCVuLqL5Gz7wU5F8eeDxA7gQaWhRRAdchMB', - 'QmTakunsnyGDgxApAJpsG89D1ECnsgYEYf643eEYDgFKvw', - 'QmdL9TRskxmunqfv8U12YYXJSwX4qkJsJ6FY7PL8yR2h3c', - 'Qmdch17auw5eF7rWaoK3NELP7r7pwb7UVMQ5jgam9yVkHv', - 'QmPXztPihEUtvewRZoyoAG3P7Jy9njCGLeUWAj5JQLFC9p', - 'QmVkNDTcbaKUcU4CBUPaurUBgGiHkthXLk7hEiSrNE69Jh', - 'QmXG2JJWGebVNdMmYrayvEGqwzX5MVBXZeCRHBt2g7muVJ', - 'QmT7Hid52Y1WUeqzajCksx82F975HydqLSe5eDaZc5yahE', - 'QmWojPLMfwZMZWfAWgBenVxdCfMvkTDG7jaSYXthwbmKit', - 'QmW8Wkya6WesT7AcbLhFv2pJTsR4fQ8wauiT6yACdWtcEa', - 'QmWxNXKddvaUvMMPoqxBSRW4tRSBq7HpJiHGVKQ12DpqDr', - 'QmdSn54JgSfQu8FRzeDwKLSNt4mHw6cYESoKKxu543sHBf', - 'QmY9G9n5erhoxPwC65eDGLAmeAzEnTvgh2Pw3oTcJgeMwY', - 'QmNsstma16pQddxZV4qY9poyd453EsXACWp7dqypNRhp8D', - 'QmQSnWFWA3n3JSgZsyrmNa8z26gwJXmhPqw1iSsAnNV9Lw', - ], - contributionAsset: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE', - contributionSize: '5000000000000000000', - contributionMultiplier: '150', - } - - let Tier2 = { - baseLoanSize: '25000000000000000000000', - hashes: [ - 'QmNg9Y1U9GcvmhcuDgRqLYTV9buW3VkdcrgbDvGdQXZ451', - 'QmRqmehqoSrxsQJGsxSYxrEuDFgynjei5QKBKVDtHyFWcq', - 'Qmax3BYajuSU3QTKJ2UYPbAjkJGPZVqL6dpVhuwa3A2PQT', - 'QmZgeCRsf6G3QEJ43whYb2n7gTD9KQZJbprWWXx2jrCk9z', - 'QmUyzz1VL9A7o776WSr2ATga9L85TboZ1waefPqkiZJ74R', - 'QmNpM8h8Q3dPBndjLrphHKkj1WUap7qXH3hqEGyhtb7RkC', - 'QmXaCUut5HzLNuTeRJLFh4xqdLLFmwjQMQ6uRmkfguzuJP', - 'QmS43NVGsc95xBRMJVMKVW8D6pwPPAf76abxaatVsfFhC1', - 'QmQU2K98Ky8Xa2nNnT9vm1KkhUAyGgTqm5WR9W3gyDTt9t', - 'QmXr25ZM3R8K43Gp24MSNyMYbaoa4dbNEXsQLMT4AGzic4', - 'QmPubCjoEsKKqpucSWvAJf4GHnjtbkqx1strHkPmWRCkdM', - 'QmZcVZY2dHkXmzDG7jVYjwyRkHjX6E1Ly9fRX8eox16C5s', - 'QmQmp4RMTUr7PNLEHQQvGP1jAXrjjaAZYgUftY4NhxtUB1', - 'QmRU8RSUuHCfcSp2n8EGukPLBdL7JAtabmd1oZwmHDy4hC', - 'QmU4JsYSmBb6F9ndJUpuZFWQyTxhdm4ZJppmeEjAYwvfg9', - 'QmfXNnuuEA4nsqe5KrmRAx1S6qt9jSVnzw5EwZqSh4vihN', - 'Qmb3iBpFN17R3bYguy6hQdb4Annijipz2nWG4GkvmUHPk7', - 'QmWMTLfuqKNYLjh6Xy4GvyR8U4cJps4eST9K3yJ6QqqLEG', - 'QmfYLNeNx1GYNSCa2TWxUDvF81yGuahoVNqymwNztGSzCZ', - 'QmRgP3KVHo9UKF73iz7SZ26SpSoQrCJyiJLwVaTQ9SkGSt', - 'QmeWtq9n6qYToECMGrU1EZG7LYzTkJMq96KMzETMFQJtgo', - 'QmSCEMFHMi2Jnwnqpdtn6rNof7M6EGy7q5nVyMt7Uq8qk2', - 'QmTa8jYFawebeNx8L9XzKyjboktZVeYDV1m36LBS9MnMg6', - 'QmcUsmW8aN8AHfoKgFuMg6AUHWGFhwsKv4GAF385UdxZ4c', - 'QmPYiEZRDbtVVyE6CmMsXeeDPMu7CzxsNTyYhmqjWZn7qt', - 'QmPW2wP5HGRN8hbcEwFdY58UbWCePb3uGYiHQWJV6JtZEZ', - 'QmcKWcCTMxcAmfrY4CJ9S3oE2CyxwLVrxA73pqLDZXoTNf', - 'QmQPaxgXf5CW44i1nPAxvV53FM1PF8UQJXtNk3axM4yJeX', - 'QmeEcbxpwXtDpZDoWSiL5jLuPFQebgGxUdyytwwcEke2Hy', - 'QmPBhM1v3m6qko5obwPFmkdPqYCycaN7FzuRT2M5vZkqya', - 'QmUJvT9zaD2SM8h7CftHSL9pYwq3Hg8Dq6neG14MFPwWVR', - 'QmavxtXyLNW8kqSVycXxB6mUJiHiRdXrbXA7dvWj7wAYth', - 'QmX74NW5YZYTnX24mDzMfnTAKbphtV2vd8QRQ3ds8n47SG', - 'Qmdvv61ntow9sgTt1VabpPpBPg5YEK24CRHnB4VTFKiy5m', - 'Qmex5bWCFQ7tRj1hhoNRxkP1NeHheqdP68p8UZpDBKmvSo', - 'QmXffz7ck5GLtQWnkjbeSUPSiCJXJMuauPeQaHzmeuFkb4', - 'Qmc4xxqLhCDhfqcc1ZVhM5E83UZEmc9q13ipw6kqDT6XXg', - 'QmbsTcK4MiFZv1S5Bs8ihhWFuLfZstVBy3BdKYvSSxa4Yv', - 'QmSYH4LDXgRWbL1ieKRCaDvVdAYdZnEcNCG9BYA9jzYsGK', - 'QmfEzY1CXaX4CahEym8pPMqM6ErTfjNfpe3dta449rf4YR', - 'QmPmdRJtQVhnpZp1kgjrsR7Jqhf4pTKcKgnS4dX1fGhGaV', - 'Qme4yqyjexHbQF7Aep3gSpVu7qdTejXPh59pLth61bJ9k9', - 'QmeiFjHnpa7on3Gq1iSdTjc97Tc6dxUrG6HY7bmrsvjyMW', - 'QmYGCzLQkFZCcXJ5X4ZL3JegnCzscHidC8T67EuVLfYCsc', - 'QmNdFj6fxHgYAzGiFhrGKCqgZNz2h7Cg8ySZYVMJ1bYQWo', - 'QmeJJGz9JxKxBYQ3eo2oTJw648Uao9iHaoCyrPZynBSHh1', - 'QmSgioV2r92KEf2a5PLCEri5gkFgyxe7S87K6pCkKVMrr3', - 'QmcTE5isKSbXCDDCS2LoayyYpYMuoowXtPjTvro5hrmioh', - 'Qmd6Dzhu5bWpPKja35LHL872i8bTgBddAFpHpXzKxvHbJ3', - 'QmU4Sb39Q6UKTwKtW7uAp85rhTRid726TzjWhNMm4tT312', - 'QmPosaecCZeSfN2rPSUvz8Qg5Cz5ZPrF2tVRGsPiKecn6S', - 'QmVoswF2yzYURKrqKvWMYmJZkeSCo6CD2ntmkBzbvAhHXz', - 'QmTZNBfQSnxDaZvPuCnUcDRRJhpGcuv6S5zBi1cCYdtkV7', - 'QmS2TDeDxVbxLmkqv9Py6iibzhWhymykjjiswQxNFbzFmT', - 'QmcQUGsdj2U8i6EqTt8uQsGdghYYfHUZU2rZwddwniEUSA', - 'QmX7Y5K2gFtHpT9xskoYvSyTkGtazAboqU47QNbnjBiMFr', - 'QmaEP1vhnDnVD1GCf9NVuHdCcR5MWc6Kd6v8q6tpDy5BJY', - 'QmeuTi152Zt5v7Rvipj6UBFBUEq2PJ69rXEdCDsCtiH3MB', - 'QmNcHqxeWzsDADdux8bkYh2XMVv7cWZdRUVUTpS8WDqmG8', - 'QmVTxh7DX88PqQF9tpzcqkpW868ApAqYydHnmjKHDJCyUh', - 'QmPuNivsbijk5Privi24CtmDjG4S2u6VCWmBJc4quCspcf', - 'QmTJWh3EPf5t9zv3ygcVu1UcufrQjRLVQnUdqxAkfD6NSQ', - 'QmZQHRVp16qnYDKq21GjN5TTwGb21fvGYLAd1Jpe69mko7', - 'QmPfytLRxQQumN9tVgjcS7EX7EPjvVjGEKAgQ3apfD44uU', - 'QmVipjPMCBChaanQLzn7iawjGd9gn72UU6xu3QhW6mQQam', - 'QmUXuFYReGXVw5EiHkw9QgVMcXeNHshAtp2JJRQ6TR9bVq', - 'QmWSjp8VXT9r62BX4BahGKx9m8z2qPqTW7MepEU1jEAVWd', - 'QmeVCQWxPUw6N9E83jCZkCqNGvezBXac6CYt8vBjW3K8n2', - 'QmNR4t3quXH5Tf9g9rLJELFhdWozTPqmrGpxkiBLgrxGMC', - ], - contributionAsset: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE', - contributionSize: '10000000000000000000', - contributionMultiplier: '150', - } - - await dictionaryContract.setTier(0, Tier0, { from: signerAccount.address }) - await dictionaryContract.setTier(1, Tier1, { from: signerAccount.address }) - await dictionaryContract.setTier(2, Tier2, { from: signerAccount.address }) - - let baseLoanSizeGasEstimate = - await dictionaryContract.estimateGas.tokenBaseLoanSize('0') - console.log('baseLoanSizeGasEstimate', baseLoanSizeGasEstimate.toString()) - - let baseLoanSize = await dictionaryContract.tokenBaseLoanSize('0') - expect(baseLoanSize).to.equal('2500000000000000000000') - - let tokenURIHash = await dictionaryContract.tokenURIHash('0') - expect(tokenURIHash).to.equal( - 'QmeL8KzMzHXgMUXWNEjTk5aWbWvHWqjmbpE8AjE47p366e' - ) - - let tokenContributionAsset = - await dictionaryContract.tokenContributionAsset('0') - expect(tokenContributionAsset).to.equal( - '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE' - ) - - let tokenContributionSize = await dictionaryContract.tokenContributionSize( - '0' - ) - expect(tokenContributionSize).to.equal('1000000000000000000') - - let tokenContributionMultiplier = - await dictionaryContract.tokenContributionMultiplier('0') - expect(tokenContributionMultiplier).to.equal('150') + const tokenContributionMultiplier = + await dictionaryContract.tokenContributionMultiplier('0') + expect(tokenContributionMultiplier).to.equal('150') + }) }) }) diff --git a/test/unit/pair-aggregator.test.ts b/test/unit/pair-aggregator.test.ts index 8602768dd..d6fd2bd96 100644 --- a/test/unit/pair-aggregator.test.ts +++ b/test/unit/pair-aggregator.test.ts @@ -3,11 +3,9 @@ import chaiAsPromised from 'chai-as-promised' import { Signer } from 'ethers' import hre from 'hardhat' -import { getChainlink, getTokens } from '../../config' +import { getTokens } from '../../config' import { Address } from '../../types/custom/config-types' -import { ITellerDiamond } from '../../types/typechain' -import { NULL_ADDRESS } from '../../utils/consts' -import { RUN_EXISTING } from '../helpers/env-helpers' +import { PriceAggregator } from '../../types/typechain' chai.should() chai.use(chaiAsPromised) @@ -15,79 +13,32 @@ chai.use(chaiAsPromised) const { contracts, tokens, deployments, getNamedSigner, toBN } = hre describe('PriceAggregator', () => { - let diamond: ITellerDiamond + let priceAgg: PriceAggregator let deployer: Signer - const chainlink = getChainlink(hre.network) const tokenAddresses = getTokens(hre.network) - const pairs = Object.values(chainlink) + const pairs = [ + ['dai', 'weth'], + ['usdc', 'weth'], + ['link', 'weth'], + ] - const getTokenAddress = (sym: string): Address => tokenAddresses.all[sym] + const getTokenAddress = (sym: string): Address => + tokenAddresses.all[sym.toUpperCase()] before(async () => { await deployments.fixture('protocol') - diamond = await contracts.get('TellerDiamond') + priceAgg = await contracts.get('PriceAggregator') deployer = await getNamedSigner('deployer') }) - describe('addChainlinkAggregator', () => { - it('Should not be able to add a Chainlink aggregator as not an admin', async () => { - // Sender address - const lender = await getNamedSigner('lender') - - await diamond - .connect(lender) - .addChainlinkAggregator( - getTokenAddress(pairs[0].baseTokenName), - getTokenAddress(pairs[0].quoteTokenName), - pairs[0].address - ) - .should.be.rejectedWith('AccessControl: not authorized') - }) - - for (const pair of pairs) { - it(`Should be able add Chainlink aggregators for ${pair.baseTokenName}/${pair.quoteTokenName} an admin`, async () => { - const srcTokenAddress = getTokenAddress(pair.baseTokenName) - const dstTokenAddress = getTokenAddress(pair.quoteTokenName) - - // Add aggregator - await diamond - .connect(deployer) - .addChainlinkAggregator( - srcTokenAddress, - dstTokenAddress, - pair.address - ) - - // Check if aggregator was successfully added - const aggregatorResponse = await diamond.getChainlinkAggregatorFor( - srcTokenAddress, - dstTokenAddress - ) - - const tokenSupportResponse = await diamond.isChainlinkTokenSupported( - srcTokenAddress - ) - - aggregatorResponse.agg.should.be.equals( - pair.address, - 'Chainlink pair Aggregator was not stored' - ) - tokenSupportResponse.should.eql( - true, - 'Chainlink token not supported after pair added' - ) - }) - } - }) - describe('getPriceFor', () => { - for (const pair of pairs) { - it(`Should be able get the latest price for ${pair.baseTokenName}/${pair.quoteTokenName}`, async () => { - const answer = await diamond.getPriceFor( - getTokenAddress(pair.baseTokenName), - getTokenAddress(pair.quoteTokenName) + for (const [base, quote] of pairs) { + it(`Should be able get the latest price for ${base}/${quote}`, async () => { + const answer = await priceAgg.getPriceFor( + getTokenAddress(base), + getTokenAddress(quote) ) answer.gt(0).should.eql(true, 'Chainlink pair zero price') @@ -96,75 +47,16 @@ describe('PriceAggregator', () => { }) describe('getValueFor', () => { - for (const pair of pairs) { - it(`Should be able get the latest price for ${pair.baseTokenName}/${pair.quoteTokenName}`, async () => { - const answer = await diamond.getValueFor( - getTokenAddress(pair.baseTokenName), - getTokenAddress(pair.quoteTokenName), - await tokens - .get(pair.baseTokenName) - .then(async (t) => toBN(1, await t.decimals())) + for (const [base, quote] of pairs) { + it(`Should be able get the latest price for ${base}/${quote}`, async () => { + const answer = await priceAgg.getValueFor( + getTokenAddress(base), + getTokenAddress(quote), + await tokens.get(base).then(async (t) => toBN(1, await t.decimals())) ) answer.gt(0).should.eql(true, 'Chainlink pair zero value') }) } }) - - describe('removeChainlinkAggregator', () => { - it('Should not be able to remove an aggregator as not an admin', async () => { - // Sender address - const lender = await getNamedSigner('lender') - - await diamond - .connect(lender) - .removeChainlinkAggregator( - getTokenAddress(pairs[0].baseTokenName), - getTokenAddress(pairs[0].quoteTokenName) - ) - .should.be.rejectedWith('AccessControl: not authorized') - }) - - for (const pair of pairs) { - it(`Should be able remove the aggregator for ${pair.baseTokenName}/${pair.quoteTokenName} as an admin`, async () => { - const srcTokenAddress = getTokenAddress(pair.baseTokenName) - const dstTokenAddress = getTokenAddress(pair.quoteTokenName) - - // Remove aggregator - await diamond - .connect(deployer) - .removeChainlinkAggregator(srcTokenAddress, dstTokenAddress) - - // Check if aggregator was successfully removed - const { agg } = await diamond.getChainlinkAggregatorFor( - srcTokenAddress, - dstTokenAddress - ) - - agg.should.be.equal(NULL_ADDRESS, 'Chainlink Aggregator not removed') - }) - } - - const tokenAddresses = pairs.reduce( - (set, { baseTokenName, quoteTokenName }) => { - set.add(getTokenAddress(baseTokenName)) - set.add(getTokenAddress(quoteTokenName)) - return set - }, - new Set() - ) - - for (const tokenAddress of tokenAddresses) { - it(`should not support any tokens after all aggregators being removed`, async () => { - const tokenSupportResponse = await diamond.isChainlinkTokenSupported( - tokenAddress - ) - - tokenSupportResponse.should.eql( - false, - 'Chainlink token still supported' - ) - }) - } - }) }) diff --git a/types/custom/config-types.d.ts b/types/custom/config-types.d.ts index 6e8f84480..2b0a9154f 100644 --- a/types/custom/config-types.d.ts +++ b/types/custom/config-types.d.ts @@ -53,7 +53,7 @@ interface Market { interface MarketStrategy { name: string initArgs: Array<{ - type: 'TokenSymbol' | 'Address' | 'Number' + type: 'TokenSymbol' | 'Address' | 'Number' | 'ProtocolAddressConstant' value: any }> } @@ -100,7 +100,10 @@ export interface Signers extends Array
{} export interface NetworkTokens { erc20: Tokens - compound: Tokens + compound?: Tokens + aave?: Tokens + poolTogether?: Tokens + yearn?: Tokens } export interface Tokens { diff --git a/utils/consts.ts b/utils/consts.ts index 0aa868a5a..fadae0065 100644 --- a/utils/consts.ts +++ b/utils/consts.ts @@ -7,6 +7,8 @@ export const HUNDRED_PERCENT = 10000 export const UNISWAP_ROUTER_V2_ADDRESS = '0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D' +export const SUSHISWAP_ROUTER_V2_ADDRESS_POLYGON = + '0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506' export const DUMMY_ADDRESS = '0x0000000000000000000000000000000000000001' export const NULL_ADDRESS = '0x0000000000000000000000000000000000000000' @@ -27,6 +29,7 @@ export enum CacheType { } export enum AssetType { + Token, Address, Amount, Bool, diff --git a/utils/deploy-helpers.ts b/utils/deploy-helpers.ts index 2dca3cc3b..20abbaaeb 100644 --- a/utils/deploy-helpers.ts +++ b/utils/deploy-helpers.ts @@ -20,9 +20,11 @@ export interface DeployArgs extends CommonDeployArgs { mock?: boolean } +type DeployedContract = C & { deployResult: DeployResult } + export const deploy = async ( args: DeployArgs -): Promise => { +): Promise> => { const { hre, skipIfAlreadyDeployed = true, indent = 1 } = args const { deployments: { deploy, getOrNull }, @@ -34,12 +36,13 @@ export const deploy = async ( const contractDeployName = args.name ?? args.contract const existingContract = await getOrNull(contractDeployName) let contractAddress: string + let result: DeployResult if (!existingContract || (existingContract && !skipIfAlreadyDeployed)) { // If marked as mock, prepend "Mock" to the contract name const contractName = `${args.contract}${args.mock ? 'Mock' : ''}` - const result = await deploy(contractDeployName, { + result = await deploy(contractDeployName, { ...args, contract: contractName, from: deployer, @@ -48,16 +51,21 @@ export const deploy = async ( contractAddress = result.address await onDeployResult({ result, name: contractDeployName, hre, indent }) } else { + result = { ...existingContract, newlyDeployed: false } contractAddress = existingContract.address await onDeployResult({ - result: { ...existingContract, newlyDeployed: false }, + result, name: contractDeployName, hre, indent, }) } - return (await ethers.getContractAt(args.contract, contractAddress)) as C + const contract = (await hre.contracts.get(args.contract, { + at: contractAddress, + })) as DeployedContract + contract.deployResult = result + return contract } export interface DiamondExecuteArgs { diff --git a/yarn.lock b/yarn.lock index 531de6c9a..184d3e8ac 100644 --- a/yarn.lock +++ b/yarn.lock @@ -9,27 +9,34 @@ dependencies: "@babel/highlight" "^7.10.4" -"@babel/code-frame@^7.0.0": - version "7.12.13" - resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.12.13.tgz#dcfc826beef65e75c50e21d3837d7d95798dd658" - integrity sha512-HV1Cm0Q3ZrpCR93tkWOYiuYIgLxZXZFVG2VgK+MBWjUqZTundupbfx2aXarXuw5Ko5aMcjtJgbSs4vUGBS5v6g== +"@babel/code-frame@^7.0.0", "@babel/code-frame@^7.12.13": + version "7.14.5" + resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.14.5.tgz#23b08d740e83f49c5e59945fbf1b43e80bbf4edb" + integrity sha512-9pzDqyc6OLDaqe+zbACgFkb6fKMNG6CObKpnYXChRsvYGyEdc7CA2BaqeOM+vOtCS5ndmJicPJhKAwYRI6UfFw== dependencies: - "@babel/highlight" "^7.12.13" + "@babel/highlight" "^7.14.5" -"@babel/helper-validator-identifier@^7.14.0": - version "7.14.0" - resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.14.0.tgz#d26cad8a47c65286b15df1547319a5d0bcf27288" - integrity sha512-V3ts7zMSu5lfiwWDVWzRDGIN+lnCEUdaXgtVHJgLb1rGaA6jMrtB9EmE7L18foXJIE8Un/A/h6NJfGQp/e1J4A== +"@babel/helper-validator-identifier@^7.14.5": + version "7.14.5" + resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.14.5.tgz#d0f0e277c512e0c938277faa85a3968c9a44c0e8" + integrity sha512-5lsetuxCLilmVGyiLEfoHBRX8UCFD+1m2x3Rj97WrW3V7H3u4RWRXA4evMjImCsin2J2YT0QaVDGf+z8ondbAg== -"@babel/highlight@^7.10.4", "@babel/highlight@^7.12.13": - version "7.14.0" - resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.14.0.tgz#3197e375711ef6bf834e67d0daec88e4f46113cf" - integrity sha512-YSCOwxvTYEIMSGaBQb5kDDsCopDdiUGsqpatp3fOlI4+2HQSkTmEVWnVuySdAC5EWCqSWWTv0ib63RjR7dTBdg== +"@babel/highlight@^7.10.4", "@babel/highlight@^7.14.5": + version "7.14.5" + resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.14.5.tgz#6861a52f03966405001f6aa534a01a24d99e8cd9" + integrity sha512-qf9u2WFWVV0MppaL877j2dBtQIDgmidgjGk5VIMw3OadXvYaXn66U1BFlH2t4+t3i+8PhedppRv+i40ABzd+gg== dependencies: - "@babel/helper-validator-identifier" "^7.14.0" + "@babel/helper-validator-identifier" "^7.14.5" chalk "^2.0.0" js-tokens "^4.0.0" +"@babel/runtime@^7.4.4": + version "7.14.6" + resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.14.6.tgz#535203bc0892efc7dec60bdc27b2ecf6e409062d" + integrity sha512-/PCB2uJ7oM44tz8YhC4Z/6PeOKXp4K588f+5M3clr1M4zbqztlo0XEfJ2LEzj/FgwfgGcIdl8n7YYjTCI0BYwg== + dependencies: + regenerator-runtime "^0.13.4" + "@chainlink/contracts@^0.1.6": version "0.1.7" resolved "https://registry.yarnpkg.com/@chainlink/contracts/-/contracts-0.1.7.tgz#ff8e8f1fad5f0766d52ad515f83148f9d82cccad" @@ -38,6 +45,63 @@ "@truffle/contract" "^4.3.8" ethers "^4.0.45" +"@ensdomains/address-encoder@^0.1.7": + version "0.1.9" + resolved "https://registry.yarnpkg.com/@ensdomains/address-encoder/-/address-encoder-0.1.9.tgz#f948c485443d9ef7ed2c0c4790e931c33334d02d" + integrity sha512-E2d2gP4uxJQnDu2Kfg1tHNspefzbLT8Tyjrm5sEuim32UkU2sm5xL4VXtgc2X33fmPEw9+jUMpGs4veMbf+PYg== + dependencies: + bech32 "^1.1.3" + blakejs "^1.1.0" + bn.js "^4.11.8" + bs58 "^4.0.1" + crypto-addr-codec "^0.1.7" + nano-base32 "^1.0.1" + ripemd160 "^2.0.2" + +"@ensdomains/buffer@^0.0.10": + version "0.0.10" + resolved "https://registry.yarnpkg.com/@ensdomains/buffer/-/buffer-0.0.10.tgz#3b9f8b6a34c6160ae8a8cb8f0f033aa35c1a9970" + integrity sha512-EOFqiWnN36EyyBAgHFTsabFcFICUALt41SiDm/4pAw4V36R4lD4wHcnZcqCYki9m1fMaeWGHrdqxmrMa8iiSTQ== + +"@ensdomains/buffer@^0.0.13": + version "0.0.13" + resolved "https://registry.yarnpkg.com/@ensdomains/buffer/-/buffer-0.0.13.tgz#b9f60defb78fc5f2bee30faca17e63dfbef19253" + integrity sha512-8aA+U/e4S54ebPwcge1HHvvpgXLKxPd6EOSegMlrTvBnKB8RwB3OpNyflaikD6KqzIwDaBaH8bvnTrMcfpV7oQ== + dependencies: + "@nomiclabs/hardhat-truffle5" "^2.0.0" + +"@ensdomains/ens-contracts@0.0.3": + version "0.0.3" + resolved "https://registry.yarnpkg.com/@ensdomains/ens-contracts/-/ens-contracts-0.0.3.tgz#7023a3ad8e74431fa64c550f63c5730d9cb64303" + integrity sha512-da67JjAFjl8gLDDAqYQs5PSvth9usBcD7clXiXpfvJTMJnZnR+c/cG6xrkVgL4qEP7jmI+iEoj0y29qFtupy2w== + dependencies: + "@ensdomains/buffer" "^0.0.10" + "@openzeppelin/contracts" "^4.1.0" + +"@ensdomains/ens-contracts@^0.0.5": + version "0.0.5" + resolved "https://registry.yarnpkg.com/@ensdomains/ens-contracts/-/ens-contracts-0.0.5.tgz#9668828746cbc70df578da83ce27897a19f0d1da" + integrity sha512-p7U2ZzftSScYUvG26dOAynKb362s2SMz/G7hWnBziQekzh38irLHQ8vR8I0HxaRbDb0MS4rNYruq/rT5GGcwzA== + dependencies: + "@ensdomains/buffer" "^0.0.13" + "@ensdomains/solsha1" "0.0.3" + "@openzeppelin/contracts" "^4.1.0" + dns-packet "^5.2.4" + name-wrapper "^1.0.0" + +"@ensdomains/ens@0.4.3": + version "0.4.3" + resolved "https://registry.yarnpkg.com/@ensdomains/ens/-/ens-0.4.3.tgz#f4a6b55146fe526c9a50e13f373bf90d36ca94dc" + integrity sha512-btC+fGze//ml8SMNCx5DgwM8+kG2t+qDCZrqlL/2+PV4CNxnRIpR3egZ49D9FqS52PFoYLmz6MaQfl7AO3pUMA== + dependencies: + bluebird "^3.5.2" + eth-ens-namehash "^2.0.8" + ethereumjs-testrpc "^6.0.3" + ganache-cli "^6.1.0" + solc "^0.4.20" + testrpc "0.0.1" + web3-utils "^1.0.0-beta.31" + "@ensdomains/ens@^0.4.4": version "0.4.5" resolved "https://registry.yarnpkg.com/@ensdomains/ens/-/ens-0.4.5.tgz#e0aebc005afdc066447c6e22feb4eda89a5edbfc" @@ -49,38 +113,59 @@ testrpc "0.0.1" web3-utils "^1.0.0-beta.31" -"@ensdomains/resolver@^0.2.4": +"@ensdomains/ensjs@^2.0.1": + version "2.0.1" + resolved "https://registry.yarnpkg.com/@ensdomains/ensjs/-/ensjs-2.0.1.tgz#c27438f9ca074825ddb08430988c7decf2062a91" + integrity sha512-gZLntzE1xqPNkPvaHdJlV5DXHms8JbHBwrXc2xNrL1AylERK01Lj/txCCZyVQqFd3TvUO1laDbfUv8VII0qrjg== + dependencies: + "@babel/runtime" "^7.4.4" + "@ensdomains/address-encoder" "^0.1.7" + "@ensdomains/ens" "0.4.3" + "@ensdomains/resolver" "0.2.4" + content-hash "^2.5.2" + eth-ens-namehash "^2.0.8" + ethers "^5.0.13" + js-sha3 "^0.8.0" + +"@ensdomains/resolver@0.2.4", "@ensdomains/resolver@^0.2.4": version "0.2.4" resolved "https://registry.yarnpkg.com/@ensdomains/resolver/-/resolver-0.2.4.tgz#c10fe28bf5efbf49bff4666d909aed0265efbc89" integrity sha512-bvaTH34PMCbv6anRa9I/0zjLJgY4EuznbEMgbV77JBCQ9KNC46rzi0avuxpOfu+xDjPEtSFGqVEOr5GlUSGudA== -"@eslint/eslintrc@^0.4.1": - version "0.4.1" - resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-0.4.1.tgz#442763b88cecbe3ee0ec7ca6d6dd6168550cbf14" - integrity sha512-5v7TDE9plVhvxQeWLXDTvFvJBdH6pEsdnl2g/dAptmuFEPedQ4Erq5rsDsX+mvAM610IhNaO2W5V1dOOnDKxkQ== +"@ensdomains/solsha1@0.0.3": + version "0.0.3" + resolved "https://registry.yarnpkg.com/@ensdomains/solsha1/-/solsha1-0.0.3.tgz#fd479da9d40aadb59ff4fb4ec50632e7d2275a83" + integrity sha512-uhuG5LzRt/UJC0Ux83cE2rCKwSleRePoYdQVcqPN1wyf3/ekMzT/KZUF9+v7/AG5w9jlMLCQkUM50vfjr0Yu9Q== + dependencies: + hash-test-vectors "^1.3.2" + +"@eslint/eslintrc@^0.4.2": + version "0.4.2" + resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-0.4.2.tgz#f63d0ef06f5c0c57d76c4ab5f63d3835c51b0179" + integrity sha512-8nmGq/4ycLpIwzvhI4tNDmQztZ8sp+hI7cyG8i1nQDhkAbRzHpXPidRAHlNvCZQpJTKw5ItIpMw9RSToGF00mg== dependencies: ajv "^6.12.4" debug "^4.1.1" espree "^7.3.0" - globals "^12.1.0" + globals "^13.9.0" ignore "^4.0.6" import-fresh "^3.2.1" js-yaml "^3.13.1" minimatch "^3.0.4" strip-json-comments "^3.1.1" -"@ethereum-waffle/chai@^3.3.0": - version "3.3.1" - resolved "https://registry.yarnpkg.com/@ethereum-waffle/chai/-/chai-3.3.1.tgz#3f20b810d0fa516f19af93c50c3be1091333fa8e" - integrity sha512-+vepCjttfOzCSnmiVEmd1bR8ctA2wYVrtWa8bDLhnTpj91BIIHotNDTwpeq7fyjrOCIBTN3Ai8ACfjNoatc4OA== +"@ethereum-waffle/chai@^3.4.0": + version "3.4.0" + resolved "https://registry.yarnpkg.com/@ethereum-waffle/chai/-/chai-3.4.0.tgz#2477877410a96bf370edd64df905b04fb9aba9d5" + integrity sha512-GVaFKuFbFUclMkhHtQTDnWBnBQMJc/pAbfbFj/nnIK237WPLsO3KDDslA7m+MNEyTAOFrcc0CyfruAGGXAQw3g== dependencies: - "@ethereum-waffle/provider" "^3.3.1" + "@ethereum-waffle/provider" "^3.4.0" ethers "^5.0.0" -"@ethereum-waffle/compiler@^3.3.0": - version "3.3.1" - resolved "https://registry.yarnpkg.com/@ethereum-waffle/compiler/-/compiler-3.3.1.tgz#946128fd565aa4347075fd716dbd0f3f38189280" - integrity sha512-X/TeQugt94AQwXEdCjIQxcXYGawNulVBYEBE7nloj4wE/RBxNolXwjoVNjcS4kuiMMbKkdO0JkL5sn6ixx8bDg== +"@ethereum-waffle/compiler@^3.4.0": + version "3.4.0" + resolved "https://registry.yarnpkg.com/@ethereum-waffle/compiler/-/compiler-3.4.0.tgz#68917321212563544913de33e408327745cb1284" + integrity sha512-a2wxGOoB9F1QFRE+Om7Cz2wn+pxM/o7a0a6cbwhaS2lECJgFzeN9xEkVrKahRkF4gEfXGcuORg4msP0Asxezlw== dependencies: "@resolver-engine/imports" "^0.3.3" "@resolver-engine/imports-fs" "^0.3.3" @@ -89,71 +174,71 @@ "@types/node-fetch" "^2.5.5" ethers "^5.0.1" mkdirp "^0.5.1" - node-fetch "^2.6.0" + node-fetch "^2.6.1" solc "^0.6.3" ts-generator "^0.1.1" typechain "^3.0.0" -"@ethereum-waffle/ens@^3.2.4": - version "3.2.4" - resolved "https://registry.yarnpkg.com/@ethereum-waffle/ens/-/ens-3.2.4.tgz#c486be4879ea7107e1ff01b24851a5e44f5946ce" - integrity sha512-lkRVPCEkk7KOwH9MqFMB+gL0X8cZNsm+MnKpP9CNbAyhFos2sCDGcY8t6BA12KBK6pdMuuRXPxYL9WfPl9bqSQ== +"@ethereum-waffle/ens@^3.3.0": + version "3.3.0" + resolved "https://registry.yarnpkg.com/@ethereum-waffle/ens/-/ens-3.3.0.tgz#d54f4c8e6b7bcafdc13ab294433f45416b2b2791" + integrity sha512-zVIH/5cQnIEgJPg1aV8+ehYicpcfuAisfrtzYh1pN3UbfeqPylFBeBaIZ7xj/xYzlJjkrek/h9VfULl6EX9Aqw== dependencies: "@ensdomains/ens" "^0.4.4" "@ensdomains/resolver" "^0.2.4" ethers "^5.0.1" -"@ethereum-waffle/mock-contract@^3.2.2": - version "3.2.2" - resolved "https://registry.yarnpkg.com/@ethereum-waffle/mock-contract/-/mock-contract-3.2.2.tgz#5749b03cbb4850150f81cf66151c4523eb7436f0" - integrity sha512-H60Cc5C7sYNU4LuPMSKDh8YIaN9/fkwEjznY78CEbOosO+lMlFYdA+5VZjeDGDuYKfsBqsocQdkj1CRyoi1KNw== +"@ethereum-waffle/mock-contract@^3.3.0": + version "3.3.0" + resolved "https://registry.yarnpkg.com/@ethereum-waffle/mock-contract/-/mock-contract-3.3.0.tgz#7b331f1c95c5d46ee9478f7a6be2869f707d307a" + integrity sha512-apwq0d+2nQxaNwsyLkE+BNMBhZ1MKGV28BtI9WjD3QD2Ztdt1q9II4sKA4VrLTUneYSmkYbJZJxw89f+OpJGyw== dependencies: "@ethersproject/abi" "^5.0.1" ethers "^5.0.1" -"@ethereum-waffle/provider@^3.3.0", "@ethereum-waffle/provider@^3.3.1": - version "3.3.2" - resolved "https://registry.yarnpkg.com/@ethereum-waffle/provider/-/provider-3.3.2.tgz#33677baf6af5cbb087c3072d84f38c152968ebb1" - integrity sha512-ilz6cXK0ylSKCmZktTMpY4gjo0CN6rb86JfN7+RZYk6tKtZA6sXoOe95skWEQkGf1fZk7G817fTzLb0CmFDp1g== +"@ethereum-waffle/provider@^3.4.0": + version "3.4.0" + resolved "https://registry.yarnpkg.com/@ethereum-waffle/provider/-/provider-3.4.0.tgz#a36a0890d4fbc230e807870c8d3b683594efef00" + integrity sha512-QgseGzpwlzmaHXhqfdzthCGu5a6P1SBF955jQHf/rBkK1Y7gGo2ukt3rXgxgfg/O5eHqRU+r8xw5MzVyVaBscQ== dependencies: - "@ethereum-waffle/ens" "^3.2.4" + "@ethereum-waffle/ens" "^3.3.0" ethers "^5.0.1" ganache-core "^2.13.2" patch-package "^6.2.2" postinstall-postinstall "^2.1.0" -"@ethereumjs/block@^3.2.0", "@ethereumjs/block@^3.2.1": - version "3.2.1" - resolved "https://registry.yarnpkg.com/@ethereumjs/block/-/block-3.2.1.tgz#c24c345e6dd6299efa4bed40979280b7dda96d3a" - integrity sha512-FCxo5KwwULne2A2Yuae4iaGGqSsRjwzXOlDhGalOFiBbLfP3hE04RHaHGw4c8vh1PfOrLauwi0dQNUBkOG3zIA== +"@ethereumjs/block@^3.3.0": + version "3.3.0" + resolved "https://registry.yarnpkg.com/@ethereumjs/block/-/block-3.3.0.tgz#a1b3baec831c71c0d9e7f6145f25e919cff4939c" + integrity sha512-WoefY9Rs4W8vZTxG9qwntAlV61xsSv0NPoXmHO7x3SH16dwJQtU15YvahPCz4HEEXbu7GgGgNgu0pv8JY7VauA== dependencies: - "@ethereumjs/common" "^2.2.0" - "@ethereumjs/tx" "^3.1.3" + "@ethereumjs/common" "^2.3.0" + "@ethereumjs/tx" "^3.2.0" ethereumjs-util "^7.0.10" - merkle-patricia-tree "^4.1.0" + merkle-patricia-tree "^4.2.0" -"@ethereumjs/blockchain@^5.2.1": - version "5.2.1" - resolved "https://registry.yarnpkg.com/@ethereumjs/blockchain/-/blockchain-5.2.1.tgz#83ed83647667265f1666f111caf065ef9d1e82b5" - integrity sha512-+hshP2qSOOFsiYvZCbaDQFG7jYTWafE8sfBi+pAsdhAHfP7BN7VLyob7qoQISgwS1s7NTR4c4+2t/woU9ahItw== +"@ethereumjs/blockchain@^5.3.0": + version "5.3.0" + resolved "https://registry.yarnpkg.com/@ethereumjs/blockchain/-/blockchain-5.3.0.tgz#206936e30a4320d87a26e58d157eadef21ef6ff1" + integrity sha512-B0Y5QDZcRDQISPilv3m8nzk97QmC98DnSE9WxzGpCxfef22Mw7xhwGipci5Iy0dVC2Np2Cr5d3F6bHAR7+yVmQ== dependencies: - "@ethereumjs/block" "^3.2.0" - "@ethereumjs/common" "^2.2.0" + "@ethereumjs/block" "^3.3.0" + "@ethereumjs/common" "^2.3.0" "@ethereumjs/ethash" "^1.0.0" debug "^2.2.0" - ethereumjs-util "^7.0.9" + ethereumjs-util "^7.0.10" level-mem "^5.0.1" lru-cache "^5.1.1" rlp "^2.2.4" semaphore-async-await "^1.5.1" -"@ethereumjs/common@^2.2.0": - version "2.2.0" - resolved "https://registry.yarnpkg.com/@ethereumjs/common/-/common-2.2.0.tgz#850a3e3e594ee707ad8d44a11e8152fb62450535" - integrity sha512-PyQiTG00MJtBRkJmv46ChZL8u2XWxNBeAthznAUIUiefxPAXjbkuiCZOuncgJS34/XkMbNc9zMt/PlgKRBElig== +"@ethereumjs/common@^2.3.0", "@ethereumjs/common@^2.3.1": + version "2.3.1" + resolved "https://registry.yarnpkg.com/@ethereumjs/common/-/common-2.3.1.tgz#d692e3aff5adb35dd587dd1e6caab69e0ed2fa0b" + integrity sha512-V8hrULExoq0H4HFs3cCmdRGbgmipmlNzak6Xg34nHYfQyqkSdrCuflvYjyWmsNpI8GtrcZhzifAbgX/1C1Cjwg== dependencies: crc-32 "^1.2.0" - ethereumjs-util "^7.0.9" + ethereumjs-util "^7.0.10" "@ethereumjs/ethash@^1.0.0": version "1.0.0" @@ -165,30 +250,30 @@ ethereumjs-util "^7.0.7" miller-rabin "^4.0.0" -"@ethereumjs/tx@^3.1.3": - version "3.1.4" - resolved "https://registry.yarnpkg.com/@ethereumjs/tx/-/tx-3.1.4.tgz#04cf9e9406da5f04a1a26c458744641f4b4b8dd0" - integrity sha512-6cJpmmjCpG5ZVN9NJYtWvmrEQcevw9DIR8hj2ca2PszD2fxbIFXky3Z37gpf8S6u0Npv09kG8It+G4xjydZVLg== +"@ethereumjs/tx@^3.2.0", "@ethereumjs/tx@^3.2.1": + version "3.2.1" + resolved "https://registry.yarnpkg.com/@ethereumjs/tx/-/tx-3.2.1.tgz#65f5f1c11541764f08377a94ba4b0dcbbd67739e" + integrity sha512-i9V39OtKvwWos1uVNZxdVhd7zFOyzFLjgt69CoiOY0EmXugS0HjO3uxpLBSglDKFMRriuGqw6ddKEv+RP1UNEw== dependencies: - "@ethereumjs/common" "^2.2.0" + "@ethereumjs/common" "^2.3.1" ethereumjs-util "^7.0.10" "@ethereumjs/vm@^5.3.2": - version "5.3.2" - resolved "https://registry.yarnpkg.com/@ethereumjs/vm/-/vm-5.3.2.tgz#b4d83a3d50a7ad22d6d412cc21bbde221b3e2871" - integrity sha512-QmCUQrW6xbhgEbQh9njue4kAJdM056C+ytBFUTF/kDYa3kNDm4Qxp9HUyTlt1OCSXvDhws0qqlh8+q+pmXpN7g== - dependencies: - "@ethereumjs/block" "^3.2.1" - "@ethereumjs/blockchain" "^5.2.1" - "@ethereumjs/common" "^2.2.0" - "@ethereumjs/tx" "^3.1.3" + version "5.4.1" + resolved "https://registry.yarnpkg.com/@ethereumjs/vm/-/vm-5.4.1.tgz#62d9f64aa5a2fb334ad630418683c9654f683a5a" + integrity sha512-cpQcg5CtjzXJBn8QNiobaiWckeN/ZQwsDHLYa9df2wBEUvzuEZgFWK48YEXSpx3CnUY9fNT/lgA9CzKdq8HTzQ== + dependencies: + "@ethereumjs/block" "^3.3.0" + "@ethereumjs/blockchain" "^5.3.0" + "@ethereumjs/common" "^2.3.1" + "@ethereumjs/tx" "^3.2.1" async-eventemitter "^0.2.4" core-js-pure "^3.0.1" debug "^2.2.0" ethereumjs-util "^7.0.10" functional-red-black-tree "^1.0.1" mcl-wasm "^0.7.1" - merkle-patricia-tree "^4.1.0" + merkle-patricia-tree "^4.2.0" rustbn.js "~0.2.0" util.promisify "^1.0.1" @@ -222,52 +307,7 @@ "@ethersproject/properties" "^5.0.3" "@ethersproject/strings" "^5.0.4" -"@ethersproject/abi@5.1.2", "@ethersproject/abi@^5.0.0-beta.146", "@ethersproject/abi@^5.0.1", "@ethersproject/abi@^5.0.2": - version "5.1.2" - resolved "https://registry.yarnpkg.com/@ethersproject/abi/-/abi-5.1.2.tgz#a8e75cd0455e6dc9e4861c3d1c22bbe436c1d775" - integrity sha512-uMhoQVPX0UtfzTpekYQSEUcJGDgsJ25ifz+SV6PDETWaUFhcR8RNgb1QPTASP13inW8r6iy0/Xdq9D5hK2pNvA== - dependencies: - "@ethersproject/address" "^5.1.0" - "@ethersproject/bignumber" "^5.1.0" - "@ethersproject/bytes" "^5.1.0" - "@ethersproject/constants" "^5.1.0" - "@ethersproject/hash" "^5.1.0" - "@ethersproject/keccak256" "^5.1.0" - "@ethersproject/logger" "^5.1.0" - "@ethersproject/properties" "^5.1.0" - "@ethersproject/strings" "^5.1.0" - -"@ethersproject/abi@5.2.0", "@ethersproject/abi@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/abi/-/abi-5.2.0.tgz#e2ca0b7f7e3b83e4d427ed8b38fdc1c48e2bb00f" - integrity sha512-24ExfHa0VbIOUHbB36b6lCVmWkaIVmrd9/m8MICtmSsRKzlugWqUD0B8g0zrRylXNxAOc3V6T4xKJ8jEDSvp3w== - dependencies: - "@ethersproject/address" "^5.2.0" - "@ethersproject/bignumber" "^5.2.0" - "@ethersproject/bytes" "^5.2.0" - "@ethersproject/constants" "^5.2.0" - "@ethersproject/hash" "^5.2.0" - "@ethersproject/keccak256" "^5.2.0" - "@ethersproject/logger" "^5.2.0" - "@ethersproject/properties" "^5.2.0" - "@ethersproject/strings" "^5.2.0" - -"@ethersproject/abi@^5.2.0", "@ethersproject/abi@^5.3.0": - version "5.3.0" - resolved "https://registry.yarnpkg.com/@ethersproject/abi/-/abi-5.3.0.tgz#00f0647d906edcd32c50b16ab9c98f83e208dcf1" - integrity sha512-NaT4UacjOwca8qCG/gv8k+DgTcWu49xlrvdhr/p8PTFnoS8e3aMWqjI3znFME5Txa/QWXDrg2/heufIUue9rtw== - dependencies: - "@ethersproject/address" "^5.3.0" - "@ethersproject/bignumber" "^5.3.0" - "@ethersproject/bytes" "^5.3.0" - "@ethersproject/constants" "^5.3.0" - "@ethersproject/hash" "^5.3.0" - "@ethersproject/keccak256" "^5.3.0" - "@ethersproject/logger" "^5.3.0" - "@ethersproject/properties" "^5.3.0" - "@ethersproject/strings" "^5.3.0" - -"@ethersproject/abi@^5.3.1": +"@ethersproject/abi@5.3.1", "@ethersproject/abi@^5.0.1", "@ethersproject/abi@^5.0.2", "@ethersproject/abi@^5.1.2", "@ethersproject/abi@^5.3.0", "@ethersproject/abi@^5.3.1": version "5.3.1" resolved "https://registry.yarnpkg.com/@ethersproject/abi/-/abi-5.3.1.tgz#69a1a496729d3a83521675a57cbe21f3cc27241c" integrity sha512-F98FWTJG7nWWAQ4DcV6R0cSlrj67MWK3ylahuFbzkumem5cLWg1p7fZ3vIdRoS1c7TEf55Lvyx0w7ICR47IImw== @@ -282,33 +322,22 @@ "@ethersproject/properties" "^5.3.0" "@ethersproject/strings" "^5.3.0" -"@ethersproject/abstract-provider@5.1.0": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/abstract-provider/-/abstract-provider-5.1.0.tgz#1f24c56cda5524ef4ed3cfc562a01d6b6f8eeb0b" - integrity sha512-8dJUnT8VNvPwWhYIau4dwp7qe1g+KgdRm4XTWvjkI9gAT2zZa90WF5ApdZ3vl1r6NDmnn6vUVvyphClRZRteTQ== - dependencies: - "@ethersproject/bignumber" "^5.1.0" - "@ethersproject/bytes" "^5.1.0" - "@ethersproject/logger" "^5.1.0" - "@ethersproject/networks" "^5.1.0" - "@ethersproject/properties" "^5.1.0" - "@ethersproject/transactions" "^5.1.0" - "@ethersproject/web" "^5.1.0" - -"@ethersproject/abstract-provider@5.2.0", "@ethersproject/abstract-provider@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/abstract-provider/-/abstract-provider-5.2.0.tgz#b5c24b162f119b5d241738ded9555186013aa77d" - integrity sha512-Xi7Pt+CulRijc/vskBGIaYMEhafKjoNx8y4RNj/dnSpXHXScOJUSTtypqGBUngZddRbcwZGbHwEr6DZoKZwIZA== - dependencies: - "@ethersproject/bignumber" "^5.2.0" - "@ethersproject/bytes" "^5.2.0" - "@ethersproject/logger" "^5.2.0" - "@ethersproject/networks" "^5.2.0" - "@ethersproject/properties" "^5.2.0" - "@ethersproject/transactions" "^5.2.0" - "@ethersproject/web" "^5.2.0" - -"@ethersproject/abstract-provider@^5.2.0", "@ethersproject/abstract-provider@^5.3.0": +"@ethersproject/abi@5.4.0", "@ethersproject/abi@^5.0.0-beta.146", "@ethersproject/abi@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/abi/-/abi-5.4.0.tgz#a6d63bdb3672f738398846d4279fa6b6c9818242" + integrity sha512-9gU2H+/yK1j2eVMdzm6xvHSnMxk8waIHQGYCZg5uvAyH0rsAzxkModzBSpbAkAuhKFEovC2S9hM4nPuLym8IZw== + dependencies: + "@ethersproject/address" "^5.4.0" + "@ethersproject/bignumber" "^5.4.0" + "@ethersproject/bytes" "^5.4.0" + "@ethersproject/constants" "^5.4.0" + "@ethersproject/hash" "^5.4.0" + "@ethersproject/keccak256" "^5.4.0" + "@ethersproject/logger" "^5.4.0" + "@ethersproject/properties" "^5.4.0" + "@ethersproject/strings" "^5.4.0" + +"@ethersproject/abstract-provider@5.3.0", "@ethersproject/abstract-provider@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/abstract-provider/-/abstract-provider-5.3.0.tgz#f4c0ae4a4cef9f204d7781de805fd44b72756c81" integrity sha512-1+MLhGP1GwxBDBNwMWVmhCsvKwh4gK7oIfOrmlmePNeskg1NhIrYssraJBieaFNHUYfKEd/1DjiVZMw8Qu5Cxw== @@ -321,29 +350,20 @@ "@ethersproject/transactions" "^5.3.0" "@ethersproject/web" "^5.3.0" -"@ethersproject/abstract-signer@5.1.0": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/abstract-signer/-/abstract-signer-5.1.0.tgz#744c7a2d0ebe3cc0bc38294d0f53d5ca3f4e49e3" - integrity sha512-qQDMkjGZSSJSKl6AnfTgmz9FSnzq3iEoEbHTYwjDlEAv+LNP7zd4ixCcVWlWyk+2siud856M5CRhAmPdupeN9w== - dependencies: - "@ethersproject/abstract-provider" "^5.1.0" - "@ethersproject/bignumber" "^5.1.0" - "@ethersproject/bytes" "^5.1.0" - "@ethersproject/logger" "^5.1.0" - "@ethersproject/properties" "^5.1.0" - -"@ethersproject/abstract-signer@5.2.0", "@ethersproject/abstract-signer@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/abstract-signer/-/abstract-signer-5.2.0.tgz#8e291fb6558b4190fb3e2fe440a9ffd092a2f459" - integrity sha512-JTXzLUrtoxpOEq1ecH86U7tstkEa9POKAGbGBb+gicbjGgzYYkLR4/LD83SX2/JNWvtYyY8t5errt5ehiy1gxQ== +"@ethersproject/abstract-provider@5.4.0", "@ethersproject/abstract-provider@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/abstract-provider/-/abstract-provider-5.4.0.tgz#415331031b0f678388971e1987305244edc04e1d" + integrity sha512-vPBR7HKUBY0lpdllIn7tLIzNN7DrVnhCLKSzY0l8WAwxz686m/aL7ASDzrVxV93GJtIub6N2t4dfZ29CkPOxgA== dependencies: - "@ethersproject/abstract-provider" "^5.2.0" - "@ethersproject/bignumber" "^5.2.0" - "@ethersproject/bytes" "^5.2.0" - "@ethersproject/logger" "^5.2.0" - "@ethersproject/properties" "^5.2.0" + "@ethersproject/bignumber" "^5.4.0" + "@ethersproject/bytes" "^5.4.0" + "@ethersproject/logger" "^5.4.0" + "@ethersproject/networks" "^5.4.0" + "@ethersproject/properties" "^5.4.0" + "@ethersproject/transactions" "^5.4.0" + "@ethersproject/web" "^5.4.0" -"@ethersproject/abstract-signer@^5.2.0", "@ethersproject/abstract-signer@^5.3.0": +"@ethersproject/abstract-signer@5.3.0", "@ethersproject/abstract-signer@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/abstract-signer/-/abstract-signer-5.3.0.tgz#05172b653e15b535ed5854ef5f6a72f4b441052d" integrity sha512-w8IFwOYqiPrtvosPuArZ3+QPR2nmdVTRrVY8uJYL3NNfMmQfTy3V3l2wbzX47UUlNbPJY+gKvzJAyvK1onZxJg== @@ -354,29 +374,18 @@ "@ethersproject/logger" "^5.3.0" "@ethersproject/properties" "^5.3.0" -"@ethersproject/address@5.1.0", "@ethersproject/address@>=5.0.0-beta.128", "@ethersproject/address@^5.0.2", "@ethersproject/address@^5.0.4": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/address/-/address-5.1.0.tgz#3854fd7ebcb6af7597de66f847c3345dae735b58" - integrity sha512-rfWQR12eHn2cpstCFS4RF7oGjfbkZb0oqep+BfrT+gWEGWG2IowJvIsacPOvzyS1jhNF4MQ4BS59B04Mbovteg== - dependencies: - "@ethersproject/bignumber" "^5.1.0" - "@ethersproject/bytes" "^5.1.0" - "@ethersproject/keccak256" "^5.1.0" - "@ethersproject/logger" "^5.1.0" - "@ethersproject/rlp" "^5.1.0" - -"@ethersproject/address@5.2.0", "@ethersproject/address@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/address/-/address-5.2.0.tgz#afcfa92db84582f54a60a9da361cea4aae450a69" - integrity sha512-2YfZlalWefOEfnr/CdqKRrgMgbKidYc+zG4/ilxSdcryZSux3eBU5/5btAT/hSiaHipUjd8UrWK8esCBHU6QNQ== +"@ethersproject/abstract-signer@5.4.0", "@ethersproject/abstract-signer@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/abstract-signer/-/abstract-signer-5.4.0.tgz#cd5f50b93141ee9f9f49feb4075a0b3eafb57d65" + integrity sha512-AieQAzt05HJZS2bMofpuxMEp81AHufA5D6M4ScKwtolj041nrfIbIi8ciNW7+F59VYxXq+V4c3d568Q6l2m8ew== dependencies: - "@ethersproject/bignumber" "^5.2.0" - "@ethersproject/bytes" "^5.2.0" - "@ethersproject/keccak256" "^5.2.0" - "@ethersproject/logger" "^5.2.0" - "@ethersproject/rlp" "^5.2.0" + "@ethersproject/abstract-provider" "^5.4.0" + "@ethersproject/bignumber" "^5.4.0" + "@ethersproject/bytes" "^5.4.0" + "@ethersproject/logger" "^5.4.0" + "@ethersproject/properties" "^5.4.0" -"@ethersproject/address@^5.0.0", "@ethersproject/address@^5.2.0", "@ethersproject/address@^5.3.0": +"@ethersproject/address@5.3.0", "@ethersproject/address@>=5.0.0-beta.128", "@ethersproject/address@^5.0.0", "@ethersproject/address@^5.0.2", "@ethersproject/address@^5.0.4", "@ethersproject/address@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/address/-/address-5.3.0.tgz#e53b69eacebf332e8175de814c5e6507d6932518" integrity sha512-29TgjzEBK+gUEUAOfWCG7s9IxLNLCqvr+oDSk6L9TXD0VLvZJKhJV479tKQqheVA81OeGxfpdxYtUVH8hqlCvA== @@ -387,44 +396,32 @@ "@ethersproject/logger" "^5.3.0" "@ethersproject/rlp" "^5.3.0" -"@ethersproject/base64@5.1.0": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/base64/-/base64-5.1.0.tgz#27240c174d0a4e13f6eae87416fd876caf7f42b6" - integrity sha512-npD1bLvK4Bcxz+m4EMkx+F8Rd7CnqS9DYnhNu0/GlQBXhWjvfoAZzk5HJ0f1qeyp8d+A86PTuzLOGOXf4/CN8g== +"@ethersproject/address@5.4.0", "@ethersproject/address@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/address/-/address-5.4.0.tgz#ba2d00a0f8c4c0854933b963b9a3a9f6eb4a37a3" + integrity sha512-SD0VgOEkcACEG/C6xavlU1Hy3m5DGSXW3CUHkaaEHbAPPsgi0coP5oNPsxau8eTlZOk/bpa/hKeCNoK5IzVI2Q== dependencies: - "@ethersproject/bytes" "^5.1.0" + "@ethersproject/bignumber" "^5.4.0" + "@ethersproject/bytes" "^5.4.0" + "@ethersproject/keccak256" "^5.4.0" + "@ethersproject/logger" "^5.4.0" + "@ethersproject/rlp" "^5.4.0" -"@ethersproject/base64@5.2.0", "@ethersproject/base64@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/base64/-/base64-5.2.0.tgz#e01066d25e5b4e8a051545163bee5def47bd9534" - integrity sha512-D9wOvRE90QBI+yFsKMv0hnANiMzf40Xicq9JZbV9XYzh7srImmwmMcReU2wHjOs9FtEgSJo51Tt+sI1dKPYKDg== - dependencies: - "@ethersproject/bytes" "^5.2.0" - -"@ethersproject/base64@^5.2.0", "@ethersproject/base64@^5.3.0": +"@ethersproject/base64@5.3.0", "@ethersproject/base64@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/base64/-/base64-5.3.0.tgz#b831fb35418b42ad24d943c557259062b8640824" integrity sha512-JIqgtOmgKcbc2sjGWTXyXktqUhvFUDte8fPVsAaOrcPiJf6YotNF+nsrOYGC9pbHBEGSuSBp3QR0varkO8JHEw== dependencies: "@ethersproject/bytes" "^5.3.0" -"@ethersproject/basex@5.1.0": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/basex/-/basex-5.1.0.tgz#80da2e86f9da0cb5ccd446b337364d791f6a131c" - integrity sha512-vBKr39bum7DDbOvkr1Sj19bRMEPA4FnST6Utt6xhDzI7o7L6QNkDn2yrCfP+hnvJGhZFKtLygWwqlTBZoBXYLg== +"@ethersproject/base64@5.4.0", "@ethersproject/base64@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/base64/-/base64-5.4.0.tgz#7252bf65295954c9048c7ca5f43e5c86441b2a9a" + integrity sha512-CjQw6E17QDSSC5jiM9YpF7N1aSCHmYGMt9bWD8PWv6YPMxjsys2/Q8xLrROKI3IWJ7sFfZ8B3flKDTM5wlWuZQ== dependencies: - "@ethersproject/bytes" "^5.1.0" - "@ethersproject/properties" "^5.1.0" + "@ethersproject/bytes" "^5.4.0" -"@ethersproject/basex@5.2.0", "@ethersproject/basex@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/basex/-/basex-5.2.0.tgz#f921039e3bdfdab8c5a7ba8b21e81c83fc1ab98b" - integrity sha512-Oo7oX7BmaHLY/8ZsOLI5W0mrSwPBb1iboosN17jfK/4vGAtKjAInDai9I72CzN4NRJaMN5FkFLoPYywGqgGHlg== - dependencies: - "@ethersproject/bytes" "^5.2.0" - "@ethersproject/properties" "^5.2.0" - -"@ethersproject/basex@^5.2.0", "@ethersproject/basex@^5.3.0": +"@ethersproject/basex@5.3.0", "@ethersproject/basex@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/basex/-/basex-5.3.0.tgz#02dea3ab8559ae625c6d548bc11773432255c916" integrity sha512-8J4nS6t/SOnoCgr3DF5WCSRLC5YwTKYpZWJqeyYQLX+86TwPhtzvHXacODzcDII9tWKhVg6g0Bka8JCBWXsCiQ== @@ -432,25 +429,15 @@ "@ethersproject/bytes" "^5.3.0" "@ethersproject/properties" "^5.3.0" -"@ethersproject/bignumber@5.1.1", "@ethersproject/bignumber@>=5.0.0-beta.130", "@ethersproject/bignumber@^5.0.7": - version "5.1.1" - resolved "https://registry.yarnpkg.com/@ethersproject/bignumber/-/bignumber-5.1.1.tgz#84812695253ccbc639117f7ac49ee1529b68e637" - integrity sha512-AVz5iqz7+70RIqoQTznsdJ6DOVBYciNlvO+AlQmPTB6ofCvoihI9bQdr6wljsX+d5W7Yc4nyvQvP4JMzg0Agig== +"@ethersproject/basex@5.4.0", "@ethersproject/basex@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/basex/-/basex-5.4.0.tgz#0a2da0f4e76c504a94f2b21d3161ed9438c7f8a6" + integrity sha512-J07+QCVJ7np2bcpxydFVf/CuYo9mZ7T73Pe7KQY4c1lRlrixMeblauMxHXD0MPwFmUHZIILDNViVkykFBZylbg== dependencies: - "@ethersproject/bytes" "^5.1.0" - "@ethersproject/logger" "^5.1.0" - bn.js "^4.4.0" + "@ethersproject/bytes" "^5.4.0" + "@ethersproject/properties" "^5.4.0" -"@ethersproject/bignumber@5.2.0", "@ethersproject/bignumber@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/bignumber/-/bignumber-5.2.0.tgz#03f91ea740c5adb6f8c6a2e91bb4ee5ffaff5503" - integrity sha512-+MNQTxwV7GEiA4NH/i51UqQ+lY36O0rxPdV+0qzjFSySiyBlJpLk6aaa4UTvKmYWlI7YKZm6vuyCENeYn7qAOw== - dependencies: - "@ethersproject/bytes" "^5.2.0" - "@ethersproject/logger" "^5.2.0" - bn.js "^4.4.0" - -"@ethersproject/bignumber@^5.2.0", "@ethersproject/bignumber@^5.3.0": +"@ethersproject/bignumber@5.3.0", "@ethersproject/bignumber@>=5.0.0-beta.130", "@ethersproject/bignumber@^5.0.7", "@ethersproject/bignumber@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/bignumber/-/bignumber-5.3.0.tgz#74ab2ec9c3bda4e344920565720a6ee9c794e9db" integrity sha512-5xguJ+Q1/zRMgHgDCaqAexx/8DwDVLRemw2i6uR8KyGjwGdXI8f32QZZ1cKGucBN6ekJvpUpHy6XAuQnTv0mPA== @@ -459,81 +446,44 @@ "@ethersproject/logger" "^5.3.0" bn.js "^4.11.9" -"@ethersproject/bytes@5.1.0", "@ethersproject/bytes@>=5.0.0-beta.129", "@ethersproject/bytes@^5.0.4": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/bytes/-/bytes-5.1.0.tgz#55dfa9c4c21df1b1b538be3accb50fb76d5facfd" - integrity sha512-sGTxb+LVjFxJcJeUswAIK6ncgOrh3D8c192iEJd7mLr95V6du119rRfYT/b87WPkZ5I3gRBUYIYXtdgCWACe8g== - dependencies: - "@ethersproject/logger" "^5.1.0" - -"@ethersproject/bytes@5.2.0", "@ethersproject/bytes@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/bytes/-/bytes-5.2.0.tgz#327917d5a1600f92fd2a9da4052fa6d974583132" - integrity sha512-O1CRpvJDnRTB47vvW8vyqojUZxVookb4LJv/s06TotriU3Xje5WFvlvXJu1yTchtxTz9BbvJw0lFXKpyO6Dn7w== +"@ethersproject/bignumber@5.4.0", "@ethersproject/bignumber@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/bignumber/-/bignumber-5.4.0.tgz#be8dea298c0ec71208ee60f0b245be0761217ad9" + integrity sha512-OXUu9f9hO3vGRIPxU40cignXZVaYyfx6j9NNMjebKdnaCL3anCLSSy8/b8d03vY6dh7duCC0kW72GEC4tZer2w== dependencies: - "@ethersproject/logger" "^5.2.0" + "@ethersproject/bytes" "^5.4.0" + "@ethersproject/logger" "^5.4.0" + bn.js "^4.11.9" -"@ethersproject/bytes@^5.2.0", "@ethersproject/bytes@^5.3.0": +"@ethersproject/bytes@5.3.0", "@ethersproject/bytes@>=5.0.0-beta.129", "@ethersproject/bytes@^5.0.4", "@ethersproject/bytes@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/bytes/-/bytes-5.3.0.tgz#473e0da7f831d535b2002be05e6f4ca3729a1bc9" integrity sha512-rqLJjdVqCcn7glPer7Fxh87PRqlnRScVAoxcIP3PmOUNApMWJ6yRdOFfo2KvPAdO7Le3yEI1o0YW+Yvr7XCYvw== dependencies: "@ethersproject/logger" "^5.3.0" -"@ethersproject/constants@5.1.0", "@ethersproject/constants@>=5.0.0-beta.128", "@ethersproject/constants@^5.0.4": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/constants/-/constants-5.1.0.tgz#4e7da6367ea0e9be87585d8b09f3fccf384b1452" - integrity sha512-0/SuHrxc8R8k+JiLmJymxHJbojUDWBQqO+b+XFdwaP0jGzqC09YDy/CAlSZB6qHsBifY8X3I89HcK/oMqxRdBw== - dependencies: - "@ethersproject/bignumber" "^5.1.0" - -"@ethersproject/constants@5.2.0", "@ethersproject/constants@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/constants/-/constants-5.2.0.tgz#ccea78ce325f78abfe7358397c03eec570518d92" - integrity sha512-p+34YG0KbHS20NGdE+Ic0M6egzd7cDvcfoO9RpaAgyAYm3V5gJVqL7UynS87yCt6O6Nlx6wRFboPiM5ctAr+jA== +"@ethersproject/bytes@5.4.0", "@ethersproject/bytes@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/bytes/-/bytes-5.4.0.tgz#56fa32ce3bf67153756dbaefda921d1d4774404e" + integrity sha512-H60ceqgTHbhzOj4uRc/83SCN9d+BSUnOkrr2intevqdtEMO1JFVZ1XL84OEZV+QjV36OaZYxtnt4lGmxcGsPfA== dependencies: - "@ethersproject/bignumber" "^5.2.0" + "@ethersproject/logger" "^5.4.0" -"@ethersproject/constants@^5.2.0", "@ethersproject/constants@^5.3.0": +"@ethersproject/constants@5.3.0", "@ethersproject/constants@>=5.0.0-beta.128", "@ethersproject/constants@^5.0.4", "@ethersproject/constants@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/constants/-/constants-5.3.0.tgz#a5d6d86c0eec2c64c3024479609493b9afb3fc77" integrity sha512-4y1feNOwEpgjAfiCFWOHznvv6qUF/H6uI0UKp8xdhftb+H+FbKflXg1pOgH5qs4Sr7EYBL+zPyPb+YD5g1aEyw== dependencies: "@ethersproject/bignumber" "^5.3.0" -"@ethersproject/contracts@5.1.1": - version "5.1.1" - resolved "https://registry.yarnpkg.com/@ethersproject/contracts/-/contracts-5.1.1.tgz#c66cb6d618fcbd73e20a6b808e8f768b2b781d0b" - integrity sha512-6WwktLJ0DFWU8pDkgH4IGttQHhQN4SnwKFu9h+QYVe48VGWtbDu4W8/q/7QA1u/HWlWMrKxqawPiZUJj0UMvOw== - dependencies: - "@ethersproject/abi" "^5.1.0" - "@ethersproject/abstract-provider" "^5.1.0" - "@ethersproject/abstract-signer" "^5.1.0" - "@ethersproject/address" "^5.1.0" - "@ethersproject/bignumber" "^5.1.0" - "@ethersproject/bytes" "^5.1.0" - "@ethersproject/constants" "^5.1.0" - "@ethersproject/logger" "^5.1.0" - "@ethersproject/properties" "^5.1.0" - "@ethersproject/transactions" "^5.1.0" - -"@ethersproject/contracts@5.2.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/contracts/-/contracts-5.2.0.tgz#f54e12ec4a323f2bf93c338034839cc6dfc1e347" - integrity sha512-/2fg5tWPG6Z4pciEWpwGji3ggGA5j0ChVNF7NTmkOhvFrrJuWnRpzbvYA00nz8tBDNCOV3cwub5zfWRpgwYEJQ== - dependencies: - "@ethersproject/abi" "^5.2.0" - "@ethersproject/abstract-provider" "^5.2.0" - "@ethersproject/abstract-signer" "^5.2.0" - "@ethersproject/address" "^5.2.0" - "@ethersproject/bignumber" "^5.2.0" - "@ethersproject/bytes" "^5.2.0" - "@ethersproject/constants" "^5.2.0" - "@ethersproject/logger" "^5.2.0" - "@ethersproject/properties" "^5.2.0" - "@ethersproject/transactions" "^5.2.0" - -"@ethersproject/contracts@^5.3.0": +"@ethersproject/constants@5.4.0", "@ethersproject/constants@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/constants/-/constants-5.4.0.tgz#ee0bdcb30bf1b532d2353c977bf2ef1ee117958a" + integrity sha512-tzjn6S7sj9+DIIeKTJLjK9WGN2Tj0P++Z8ONEIlZjyoTkBuODN+0VfhAyYksKi43l1Sx9tX2VlFfzjfmr5Wl3Q== + dependencies: + "@ethersproject/bignumber" "^5.4.0" + +"@ethersproject/contracts@5.3.0", "@ethersproject/contracts@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/contracts/-/contracts-5.3.0.tgz#ad699a3abaae30bfb6422cf31813a663b2d4099c" integrity sha512-eDyQ8ltykvyQqnGZxb/c1e0OnEtzqXhNNC4BX8nhYBCaoBrYYuK/1fLmyEvc5+XUMoxNhwpYkoSSwvPLci7/Zg== @@ -549,35 +499,23 @@ "@ethersproject/properties" "^5.3.0" "@ethersproject/transactions" "^5.3.0" -"@ethersproject/hash@5.1.0", "@ethersproject/hash@>=5.0.0-beta.128", "@ethersproject/hash@^5.0.4": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/hash/-/hash-5.1.0.tgz#40961d64837d57f580b7b055e0d74174876d891e" - integrity sha512-fNwry20yLLPpnRRwm3fBL+2ksgO+KMadxM44WJmRIoTKzy4269+rbq9KFoe2LTqq2CXJM2CE70beGaNrpuqflQ== - dependencies: - "@ethersproject/abstract-signer" "^5.1.0" - "@ethersproject/address" "^5.1.0" - "@ethersproject/bignumber" "^5.1.0" - "@ethersproject/bytes" "^5.1.0" - "@ethersproject/keccak256" "^5.1.0" - "@ethersproject/logger" "^5.1.0" - "@ethersproject/properties" "^5.1.0" - "@ethersproject/strings" "^5.1.0" - -"@ethersproject/hash@5.2.0", "@ethersproject/hash@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/hash/-/hash-5.2.0.tgz#2d21901eafc5bdb738b4ad96bee364d371ec724b" - integrity sha512-wEGry2HFFSssFiNEkFWMzj1vpdFv4rQlkBp41UfL6J58zKGNycoAWimokITDMk8p7548MKr27h48QfERnNKkRw== - dependencies: - "@ethersproject/abstract-signer" "^5.2.0" - "@ethersproject/address" "^5.2.0" - "@ethersproject/bignumber" "^5.2.0" - "@ethersproject/bytes" "^5.2.0" - "@ethersproject/keccak256" "^5.2.0" - "@ethersproject/logger" "^5.2.0" - "@ethersproject/properties" "^5.2.0" - "@ethersproject/strings" "^5.2.0" - -"@ethersproject/hash@^5.2.0", "@ethersproject/hash@^5.3.0": +"@ethersproject/contracts@5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/contracts/-/contracts-5.4.0.tgz#e05fe6bd33acc98741e27d553889ec5920078abb" + integrity sha512-hkO3L3IhS1Z3ZtHtaAG/T87nQ7KiPV+/qnvutag35I0IkiQ8G3ZpCQ9NNOpSCzn4pWSW4CfzmtE02FcqnLI+hw== + dependencies: + "@ethersproject/abi" "^5.4.0" + "@ethersproject/abstract-provider" "^5.4.0" + "@ethersproject/abstract-signer" "^5.4.0" + "@ethersproject/address" "^5.4.0" + "@ethersproject/bignumber" "^5.4.0" + "@ethersproject/bytes" "^5.4.0" + "@ethersproject/constants" "^5.4.0" + "@ethersproject/logger" "^5.4.0" + "@ethersproject/properties" "^5.4.0" + "@ethersproject/transactions" "^5.4.0" + +"@ethersproject/hash@5.3.0", "@ethersproject/hash@>=5.0.0-beta.128", "@ethersproject/hash@^5.0.4", "@ethersproject/hash@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/hash/-/hash-5.3.0.tgz#f65e3bf3db3282df4da676db6cfa049535dd3643" integrity sha512-gAFZSjUPQ32CIfoKSMtMEQ+IO0kQxqhwz9fCIFt2DtAq2u4pWt8mL9Z5P0r6KkLcQU8LE9FmuPPyd+JvBzmr1w== @@ -591,43 +529,21 @@ "@ethersproject/properties" "^5.3.0" "@ethersproject/strings" "^5.3.0" -"@ethersproject/hdnode@5.1.0": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/hdnode/-/hdnode-5.1.0.tgz#2bf5c4048935136ce83e9242e1bd570afcc0bc83" - integrity sha512-obIWdlujloExPHWJGmhJO/sETOOo7SEb6qemV4f8kyFoXg+cJK+Ta9SvBrj7hsUK85n3LZeZJZRjjM7oez3Clg== - dependencies: - "@ethersproject/abstract-signer" "^5.1.0" - "@ethersproject/basex" "^5.1.0" - "@ethersproject/bignumber" "^5.1.0" - "@ethersproject/bytes" "^5.1.0" - "@ethersproject/logger" "^5.1.0" - "@ethersproject/pbkdf2" "^5.1.0" - "@ethersproject/properties" "^5.1.0" - "@ethersproject/sha2" "^5.1.0" - "@ethersproject/signing-key" "^5.1.0" - "@ethersproject/strings" "^5.1.0" - "@ethersproject/transactions" "^5.1.0" - "@ethersproject/wordlists" "^5.1.0" - -"@ethersproject/hdnode@5.2.0", "@ethersproject/hdnode@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/hdnode/-/hdnode-5.2.0.tgz#efea9b2f713e55aa5ba23cc62b4aac6d08dcfa53" - integrity sha512-ffq2JrW5AftCmfWZ8DxpdWdw/x06Yn+e9wrWHLpj8If1+w87W4LbTMRUaUmO1DUSN8H8g/6kMUKCTJPVuxsuOw== - dependencies: - "@ethersproject/abstract-signer" "^5.2.0" - "@ethersproject/basex" "^5.2.0" - "@ethersproject/bignumber" "^5.2.0" - "@ethersproject/bytes" "^5.2.0" - "@ethersproject/logger" "^5.2.0" - "@ethersproject/pbkdf2" "^5.2.0" - "@ethersproject/properties" "^5.2.0" - "@ethersproject/sha2" "^5.2.0" - "@ethersproject/signing-key" "^5.2.0" - "@ethersproject/strings" "^5.2.0" - "@ethersproject/transactions" "^5.2.0" - "@ethersproject/wordlists" "^5.2.0" - -"@ethersproject/hdnode@^5.2.0", "@ethersproject/hdnode@^5.3.0": +"@ethersproject/hash@5.4.0", "@ethersproject/hash@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/hash/-/hash-5.4.0.tgz#d18a8e927e828e22860a011f39e429d388344ae0" + integrity sha512-xymAM9tmikKgbktOCjW60Z5sdouiIIurkZUr9oW5NOex5uwxrbsYG09kb5bMcNjlVeJD3yPivTNzViIs1GCbqA== + dependencies: + "@ethersproject/abstract-signer" "^5.4.0" + "@ethersproject/address" "^5.4.0" + "@ethersproject/bignumber" "^5.4.0" + "@ethersproject/bytes" "^5.4.0" + "@ethersproject/keccak256" "^5.4.0" + "@ethersproject/logger" "^5.4.0" + "@ethersproject/properties" "^5.4.0" + "@ethersproject/strings" "^5.4.0" + +"@ethersproject/hdnode@5.3.0", "@ethersproject/hdnode@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/hdnode/-/hdnode-5.3.0.tgz#26fed65ffd5c25463fddff13f5fb4e5617553c94" integrity sha512-zLmmtLNoDMGoYRdjOab01Zqkvp+TmZyCGDAMQF1Bs3yZyBs/kzTNi1qJjR1jVUcPP5CWGtjFwY8iNG8oNV9J8g== @@ -645,45 +561,25 @@ "@ethersproject/transactions" "^5.3.0" "@ethersproject/wordlists" "^5.3.0" -"@ethersproject/json-wallets@5.1.0": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/json-wallets/-/json-wallets-5.1.0.tgz#bba7af2e520e8aea4d3829d80520db5d2e4fb8d2" - integrity sha512-00n2iBy27w8zrGZSiU762UOVuzCQZxUZxopsZC47++js6xUFuI74DHcJ5K/2pddlF1YBskvmMuboEu1geK8mnA== - dependencies: - "@ethersproject/abstract-signer" "^5.1.0" - "@ethersproject/address" "^5.1.0" - "@ethersproject/bytes" "^5.1.0" - "@ethersproject/hdnode" "^5.1.0" - "@ethersproject/keccak256" "^5.1.0" - "@ethersproject/logger" "^5.1.0" - "@ethersproject/pbkdf2" "^5.1.0" - "@ethersproject/properties" "^5.1.0" - "@ethersproject/random" "^5.1.0" - "@ethersproject/strings" "^5.1.0" - "@ethersproject/transactions" "^5.1.0" - aes-js "3.0.0" - scrypt-js "3.0.1" - -"@ethersproject/json-wallets@5.2.0", "@ethersproject/json-wallets@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/json-wallets/-/json-wallets-5.2.0.tgz#d41c7c39e4d236b586e26e2145b09ac49dc56608" - integrity sha512-iWxSm9XiugEtaehYD6w1ImmXeatjcGcrQvffZVJHH1UqV4FckDzrOYnZBRHPQRYlnhNVrGTld1+S0Cu4MB8gdw== - dependencies: - "@ethersproject/abstract-signer" "^5.2.0" - "@ethersproject/address" "^5.2.0" - "@ethersproject/bytes" "^5.2.0" - "@ethersproject/hdnode" "^5.2.0" - "@ethersproject/keccak256" "^5.2.0" - "@ethersproject/logger" "^5.2.0" - "@ethersproject/pbkdf2" "^5.2.0" - "@ethersproject/properties" "^5.2.0" - "@ethersproject/random" "^5.2.0" - "@ethersproject/strings" "^5.2.0" - "@ethersproject/transactions" "^5.2.0" - aes-js "3.0.0" - scrypt-js "3.0.1" - -"@ethersproject/json-wallets@^5.2.0", "@ethersproject/json-wallets@^5.3.0": +"@ethersproject/hdnode@5.4.0", "@ethersproject/hdnode@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/hdnode/-/hdnode-5.4.0.tgz#4bc9999b9a12eb5ce80c5faa83114a57e4107cac" + integrity sha512-pKxdS0KAaeVGfZPp1KOiDLB0jba11tG6OP1u11QnYfb7pXn6IZx0xceqWRr6ygke8+Kw74IpOoSi7/DwANhy8Q== + dependencies: + "@ethersproject/abstract-signer" "^5.4.0" + "@ethersproject/basex" "^5.4.0" + "@ethersproject/bignumber" "^5.4.0" + "@ethersproject/bytes" "^5.4.0" + "@ethersproject/logger" "^5.4.0" + "@ethersproject/pbkdf2" "^5.4.0" + "@ethersproject/properties" "^5.4.0" + "@ethersproject/sha2" "^5.4.0" + "@ethersproject/signing-key" "^5.4.0" + "@ethersproject/strings" "^5.4.0" + "@ethersproject/transactions" "^5.4.0" + "@ethersproject/wordlists" "^5.4.0" + +"@ethersproject/json-wallets@5.3.0", "@ethersproject/json-wallets@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/json-wallets/-/json-wallets-5.3.0.tgz#7b1a5ff500c12aa8597ae82c8939837b0449376e" integrity sha512-/xwbqaIb5grUIGNmeEaz8GdcpmDr++X8WT4Jqcclnxow8PXCUHFeDxjf3O+nSuoqOYG/Ds0+BI5xuQKbva6Xkw== @@ -702,23 +598,26 @@ aes-js "3.0.0" scrypt-js "3.0.1" -"@ethersproject/keccak256@5.1.0", "@ethersproject/keccak256@>=5.0.0-beta.127", "@ethersproject/keccak256@^5.0.3": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/keccak256/-/keccak256-5.1.0.tgz#fdcd88fb13bfef4271b225cdd8dec4d315c8e60e" - integrity sha512-vrTB1W6AEYoadww5c9UyVJ2YcSiyIUTNDRccZIgwTmFFoSHwBtcvG1hqy9RzJ1T0bMdATbM9Hfx2mJ6H0i7Hig== - dependencies: - "@ethersproject/bytes" "^5.1.0" - js-sha3 "0.5.7" - -"@ethersproject/keccak256@5.2.0", "@ethersproject/keccak256@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/keccak256/-/keccak256-5.2.0.tgz#15257862807c23f24a3209d1016d322dca85a464" - integrity sha512-LqyxTwVANga5Y3L1yo184czW6b3PibabN8xyE/eOulQLLfXNrHHhwrOTpOhoVRWCICVCD/5SjQfwqTrczjS7jQ== - dependencies: - "@ethersproject/bytes" "^5.2.0" - js-sha3 "0.5.7" +"@ethersproject/json-wallets@5.4.0", "@ethersproject/json-wallets@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/json-wallets/-/json-wallets-5.4.0.tgz#2583341cfe313fc9856642e8ace3080154145e95" + integrity sha512-igWcu3fx4aiczrzEHwG1xJZo9l1cFfQOWzTqwRw/xcvxTk58q4f9M7cjh51EKphMHvrJtcezJ1gf1q1AUOfEQQ== + dependencies: + "@ethersproject/abstract-signer" "^5.4.0" + "@ethersproject/address" "^5.4.0" + "@ethersproject/bytes" "^5.4.0" + "@ethersproject/hdnode" "^5.4.0" + "@ethersproject/keccak256" "^5.4.0" + "@ethersproject/logger" "^5.4.0" + "@ethersproject/pbkdf2" "^5.4.0" + "@ethersproject/properties" "^5.4.0" + "@ethersproject/random" "^5.4.0" + "@ethersproject/strings" "^5.4.0" + "@ethersproject/transactions" "^5.4.0" + aes-js "3.0.0" + scrypt-js "3.0.1" -"@ethersproject/keccak256@^5.2.0", "@ethersproject/keccak256@^5.3.0": +"@ethersproject/keccak256@5.3.0", "@ethersproject/keccak256@>=5.0.0-beta.127", "@ethersproject/keccak256@^5.0.3", "@ethersproject/keccak256@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/keccak256/-/keccak256-5.3.0.tgz#fb5cd36bdfd6fa02e2ea84964078a9fc6bd731be" integrity sha512-Gv2YqgIUmRbYVNIibafT0qGaeGYLIA/EdWHJ7JcVxVSs2vyxafGxOJ5VpSBHWeOIsE6OOaCelYowhuuTicgdFQ== @@ -726,59 +625,39 @@ "@ethersproject/bytes" "^5.3.0" js-sha3 "0.5.7" -"@ethersproject/logger@5.1.0", "@ethersproject/logger@>=5.0.0-beta.129", "@ethersproject/logger@^5.0.5": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/logger/-/logger-5.1.0.tgz#4cdeeefac029373349d5818f39c31b82cc6d9bbf" - integrity sha512-wtUaD1lBX10HBXjjKV9VHCBnTdUaKQnQ2XSET1ezglqLdPdllNOIlLfhyCRqXm5xwcjExVI5ETokOYfjPtaAlw== - -"@ethersproject/logger@5.2.0", "@ethersproject/logger@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/logger/-/logger-5.2.0.tgz#accf5348251f78b6c8891af67f42490a4ea4e5ae" - integrity sha512-dPZ6/E3YiArgG8dI/spGkaRDry7YZpCntf4gm/c6SI8Mbqiihd7q3nuLN5VvDap/0K3xm3RE1AIUOcUwwh2ezQ== +"@ethersproject/keccak256@5.4.0", "@ethersproject/keccak256@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/keccak256/-/keccak256-5.4.0.tgz#7143b8eea4976080241d2bd92e3b1f1bf7025318" + integrity sha512-FBI1plWet+dPUvAzPAeHzRKiPpETQzqSUWR1wXJGHVWi4i8bOSrpC3NwpkPjgeXG7MnugVc1B42VbfnQikyC/A== + dependencies: + "@ethersproject/bytes" "^5.4.0" + js-sha3 "0.5.7" -"@ethersproject/logger@^5.2.0", "@ethersproject/logger@^5.3.0": +"@ethersproject/logger@5.3.0", "@ethersproject/logger@>=5.0.0-beta.129", "@ethersproject/logger@^5.0.5", "@ethersproject/logger@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/logger/-/logger-5.3.0.tgz#7a69fa1d4ca0d4b7138da1627eb152f763d84dd0" integrity sha512-8bwJ2gxJGkZZnpQSq5uSiZSJjyVTWmlGft4oH8vxHdvO1Asy4TwVepAhPgxIQIMxXZFUNMych1YjIV4oQ4I7dA== -"@ethersproject/networks@5.1.0": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/networks/-/networks-5.1.0.tgz#f537290cb05aa6dc5e81e910926c04cfd5814bca" - integrity sha512-A/NIrIED/G/IgU1XUukOA3WcFRxn2I4O5GxsYGA5nFlIi+UZWdGojs85I1VXkR1gX9eFnDXzjE6OtbgZHjFhIA== - dependencies: - "@ethersproject/logger" "^5.1.0" +"@ethersproject/logger@5.4.0", "@ethersproject/logger@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/logger/-/logger-5.4.0.tgz#f39adadf62ad610c420bcd156fd41270e91b3ca9" + integrity sha512-xYdWGGQ9P2cxBayt64d8LC8aPFJk6yWCawQi/4eJ4+oJdMMjEBMrIcIMZ9AxhwpPVmnBPrsB10PcXGmGAqgUEQ== -"@ethersproject/networks@5.2.0", "@ethersproject/networks@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/networks/-/networks-5.2.0.tgz#66c23c6ac477dd703645b2c971ac842d8b8aa524" - integrity sha512-q+htMgq7wQoEnjlkdHM6t1sktKxNbEB/F6DQBPNwru7KpQ1R0n0UTIXJB8Rb7lSnvjqcAQ40X3iVqm94NJfYDw== - dependencies: - "@ethersproject/logger" "^5.2.0" - -"@ethersproject/networks@^5.2.0", "@ethersproject/networks@^5.3.0": - version "5.3.0" - resolved "https://registry.yarnpkg.com/@ethersproject/networks/-/networks-5.3.0.tgz#d8ad06eb107c69fb8651f4c81ddd0e88944fdfea" - integrity sha512-XGbD9MMgqrR7SYz8o6xVgdG+25v7YT5vQG8ZdlcLj2I7elOBM7VNeQrnxfSN7rWQNcqu2z80OM29gGbQz+4Low== +"@ethersproject/networks@5.3.1", "@ethersproject/networks@^5.3.0": + version "5.3.1" + resolved "https://registry.yarnpkg.com/@ethersproject/networks/-/networks-5.3.1.tgz#78fe08324cee289ce239acf8c746121934b2ef61" + integrity sha512-6uQKHkYChlsfeiZhQ8IHIqGE/sQsf25o9ZxAYpMxi15dLPzz3IxOEF5KiSD32aHwsjXVBKBSlo+teAXLlYJybw== dependencies: "@ethersproject/logger" "^5.3.0" -"@ethersproject/pbkdf2@5.1.0": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/pbkdf2/-/pbkdf2-5.1.0.tgz#6b740a85dc780e879338af74856ca2c0d3b24d19" - integrity sha512-B8cUbHHTgs8OtgJIafrRcz/YPDobVd5Ru8gTnShOiM9EBuFpYHQpq3+8iQJ6pyczDu6HP/oc/njAsIBhwFZYew== +"@ethersproject/networks@5.4.0", "@ethersproject/networks@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/networks/-/networks-5.4.0.tgz#71eecd3ef3755118b42c1a5d2a44a7e07202e10a" + integrity sha512-5fywtKRDcnaVeA5SjxXH3DOQqe/IbeD/plwydi94SdPps1fbDUrnO6SzDExaruBZXxpxJcO9upG9UComsei4bg== dependencies: - "@ethersproject/bytes" "^5.1.0" - "@ethersproject/sha2" "^5.1.0" + "@ethersproject/logger" "^5.4.0" -"@ethersproject/pbkdf2@5.2.0", "@ethersproject/pbkdf2@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/pbkdf2/-/pbkdf2-5.2.0.tgz#8166a7a7238a5fd1d9bb6eb2000fea0f19fdde06" - integrity sha512-qKOoO6yir/qnAgg6OP3U4gRuZ6jl9P7xwggRu/spVfnuaR+wa490AatWLqB1WOXKf6JFjm5yOaT/T5fCICQVdQ== - dependencies: - "@ethersproject/bytes" "^5.2.0" - "@ethersproject/sha2" "^5.2.0" - -"@ethersproject/pbkdf2@^5.2.0", "@ethersproject/pbkdf2@^5.3.0": +"@ethersproject/pbkdf2@5.3.0", "@ethersproject/pbkdf2@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/pbkdf2/-/pbkdf2-5.3.0.tgz#8adbb41489c3c9f319cc44bc7d3e6095fd468dc8" integrity sha512-Q9ChVU6gBFiex0FSdtzo4b0SAKz3ZYcYVFLrEWHL0FnHvNk3J3WgAtRNtBQGQYn/T5wkoTdZttMbfBkFlaiWcA== @@ -786,78 +665,29 @@ "@ethersproject/bytes" "^5.3.0" "@ethersproject/sha2" "^5.3.0" -"@ethersproject/properties@5.1.0", "@ethersproject/properties@>=5.0.0-beta.131", "@ethersproject/properties@^5.0.3": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/properties/-/properties-5.1.0.tgz#9484bd6def16595fc6e4bdc26f29dff4d3f6ac42" - integrity sha512-519KKTwgmH42AQL3+GFV3SX6khYEfHsvI6v8HYejlkigSDuqttdgVygFTDsGlofNFchhDwuclrxQnD5B0YLNMg== - dependencies: - "@ethersproject/logger" "^5.1.0" - -"@ethersproject/properties@5.2.0", "@ethersproject/properties@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/properties/-/properties-5.2.0.tgz#8fadf367f7ac7357019d0224aa579b234c545ac1" - integrity sha512-oNFkzcoGwXXV+/Yp/MLcDLrL/2i360XIy2YN9yRZJPnIbLwjroFNLiRzLs6PyPw1D09Xs8OcPR1/nHv6xDKE2A== +"@ethersproject/pbkdf2@5.4.0", "@ethersproject/pbkdf2@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/pbkdf2/-/pbkdf2-5.4.0.tgz#ed88782a67fda1594c22d60d0ca911a9d669641c" + integrity sha512-x94aIv6tiA04g6BnazZSLoRXqyusawRyZWlUhKip2jvoLpzJuLb//KtMM6PEovE47pMbW+Qe1uw+68ameJjB7g== dependencies: - "@ethersproject/logger" "^5.2.0" + "@ethersproject/bytes" "^5.4.0" + "@ethersproject/sha2" "^5.4.0" -"@ethersproject/properties@^5.2.0", "@ethersproject/properties@^5.3.0": +"@ethersproject/properties@5.3.0", "@ethersproject/properties@>=5.0.0-beta.131", "@ethersproject/properties@^5.0.3", "@ethersproject/properties@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/properties/-/properties-5.3.0.tgz#feef4c4babeb7c10a6b3449575016f4ad2c092b2" integrity sha512-PaHxJyM5/bfusk6vr3yP//JMnm4UEojpzuWGTmtL5X4uNhNnFNvlYilZLyDr4I9cTkIbipCMsAuIcXWsmdRnEw== dependencies: "@ethersproject/logger" "^5.3.0" -"@ethersproject/providers@5.1.2": - version "5.1.2" - resolved "https://registry.yarnpkg.com/@ethersproject/providers/-/providers-5.1.2.tgz#4e4459698903f911402fe91aa7544eb07f3921ed" - integrity sha512-GqsS8rd+eyd4eNkcNgzZ4l9IRULBPUZa7JPnv22k4MHflMobUseyhfbVnmoN5bVNNkOxjV1IPTw9i0sV1hwdpg== - dependencies: - "@ethersproject/abstract-provider" "^5.1.0" - "@ethersproject/abstract-signer" "^5.1.0" - "@ethersproject/address" "^5.1.0" - "@ethersproject/basex" "^5.1.0" - "@ethersproject/bignumber" "^5.1.0" - "@ethersproject/bytes" "^5.1.0" - "@ethersproject/constants" "^5.1.0" - "@ethersproject/hash" "^5.1.0" - "@ethersproject/logger" "^5.1.0" - "@ethersproject/networks" "^5.1.0" - "@ethersproject/properties" "^5.1.0" - "@ethersproject/random" "^5.1.0" - "@ethersproject/rlp" "^5.1.0" - "@ethersproject/sha2" "^5.1.0" - "@ethersproject/strings" "^5.1.0" - "@ethersproject/transactions" "^5.1.0" - "@ethersproject/web" "^5.1.0" - bech32 "1.1.4" - ws "7.2.3" - -"@ethersproject/providers@5.2.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/providers/-/providers-5.2.0.tgz#b2f3e3b2ca4567c8372543ceb6f3c6e3a2370783" - integrity sha512-Yf/ZUqCrVr+jR0SHA9GuNZs4R1xnV9Ibnh1TlOa0ZzI6o+Qf8bEyE550k9bYI4zk2f9x9baX2RRs6BJY7Jz/WA== - dependencies: - "@ethersproject/abstract-provider" "^5.2.0" - "@ethersproject/abstract-signer" "^5.2.0" - "@ethersproject/address" "^5.2.0" - "@ethersproject/basex" "^5.2.0" - "@ethersproject/bignumber" "^5.2.0" - "@ethersproject/bytes" "^5.2.0" - "@ethersproject/constants" "^5.2.0" - "@ethersproject/hash" "^5.2.0" - "@ethersproject/logger" "^5.2.0" - "@ethersproject/networks" "^5.2.0" - "@ethersproject/properties" "^5.2.0" - "@ethersproject/random" "^5.2.0" - "@ethersproject/rlp" "^5.2.0" - "@ethersproject/sha2" "^5.2.0" - "@ethersproject/strings" "^5.2.0" - "@ethersproject/transactions" "^5.2.0" - "@ethersproject/web" "^5.2.0" - bech32 "1.1.4" - ws "7.2.3" +"@ethersproject/properties@5.4.0", "@ethersproject/properties@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/properties/-/properties-5.4.0.tgz#38ba20539b44dcc5d5f80c45ad902017dcdbefe7" + integrity sha512-7jczalGVRAJ+XSRvNA6D5sAwT4gavLq3OXPuV/74o3Rd2wuzSL035IMpIMgei4CYyBdialJMrTqkOnzccLHn4A== + dependencies: + "@ethersproject/logger" "^5.4.0" -"@ethersproject/providers@^5.3.1": +"@ethersproject/providers@5.3.1", "@ethersproject/providers@^5.3.1": version "5.3.1" resolved "https://registry.yarnpkg.com/@ethersproject/providers/-/providers-5.3.1.tgz#a12c6370e8cbc0968c9744641b8ef90b0dd5ec2b" integrity sha512-HC63vENTrur6/JKEhcQbA8PRDj1FAesdpX98IW+xAAo3EAkf70ou5fMIA3KCGzJDLNTeYA4C2Bonz849tVLekg== @@ -882,23 +712,32 @@ bech32 "1.1.4" ws "7.4.6" -"@ethersproject/random@5.1.0": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/random/-/random-5.1.0.tgz#0bdff2554df03ebc5f75689614f2d58ea0d9a71f" - integrity sha512-+uuczLQZ4+no9cP6TCoCktXx0u2YbNaRT7lRkSt12d8263e702f0u+4JnnRO8Qmv5nylWJebnqCHzyxP+6mLqw== - dependencies: - "@ethersproject/bytes" "^5.1.0" - "@ethersproject/logger" "^5.1.0" - -"@ethersproject/random@5.2.0", "@ethersproject/random@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/random/-/random-5.2.0.tgz#1d7e19f17d88eda56228a263063826829e49eebe" - integrity sha512-7Nd3qjivBGlDCGDuGYjPi8CXdtVhRZ7NeyBXoJgtnJBwn1S01ahrbMeOUVmRVWrFM0YiSEPEGo7i4xEu2gRPcg== - dependencies: - "@ethersproject/bytes" "^5.2.0" - "@ethersproject/logger" "^5.2.0" +"@ethersproject/providers@5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/providers/-/providers-5.4.0.tgz#1b9eeaf394d790a662ec66373d7219c82f4433f2" + integrity sha512-XRmI9syLnkNdLA8ikEeg0duxmwSWTTt9S+xabnTOyI51JPJyhQ0QUNT+wvmod218ebb7rLupHDPQ7UVe2/+Tjg== + dependencies: + "@ethersproject/abstract-provider" "^5.4.0" + "@ethersproject/abstract-signer" "^5.4.0" + "@ethersproject/address" "^5.4.0" + "@ethersproject/basex" "^5.4.0" + "@ethersproject/bignumber" "^5.4.0" + "@ethersproject/bytes" "^5.4.0" + "@ethersproject/constants" "^5.4.0" + "@ethersproject/hash" "^5.4.0" + "@ethersproject/logger" "^5.4.0" + "@ethersproject/networks" "^5.4.0" + "@ethersproject/properties" "^5.4.0" + "@ethersproject/random" "^5.4.0" + "@ethersproject/rlp" "^5.4.0" + "@ethersproject/sha2" "^5.4.0" + "@ethersproject/strings" "^5.4.0" + "@ethersproject/transactions" "^5.4.0" + "@ethersproject/web" "^5.4.0" + bech32 "1.1.4" + ws "7.4.6" -"@ethersproject/random@^5.2.0", "@ethersproject/random@^5.3.0": +"@ethersproject/random@5.3.0", "@ethersproject/random@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/random/-/random-5.3.0.tgz#7c46bf36e50cb0d0550bc8c666af8e1d4496dc1a" integrity sha512-A5SL/4inutSwt3Fh2OD0x2gz+x6GHmuUnIPkR7zAiTidMD2N8F6tZdMF1hlQKWVCcVMWhEQg8mWijhEzm6BBYw== @@ -906,23 +745,15 @@ "@ethersproject/bytes" "^5.3.0" "@ethersproject/logger" "^5.3.0" -"@ethersproject/rlp@5.1.0": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/rlp/-/rlp-5.1.0.tgz#700f4f071c27fa298d3c1d637485fefe919dd084" - integrity sha512-vDTyHIwNPrecy55gKGZ47eJZhBm8LLBxihzi5ou+zrSvYTpkSTWRcKUlXFDFQVwfWB+P5PGyERAdiDEI76clxw== - dependencies: - "@ethersproject/bytes" "^5.1.0" - "@ethersproject/logger" "^5.1.0" - -"@ethersproject/rlp@5.2.0", "@ethersproject/rlp@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/rlp/-/rlp-5.2.0.tgz#bbf605183818a9d96bdc40323d734c79e26cfaca" - integrity sha512-RqGsELtPWxcFhOOhSr0lQ2hBNT9tBE08WK0tb6VQbCk97EpqkbgP8yXED9PZlWMiRGchJTw6S+ExzK62XMX/fw== +"@ethersproject/random@5.4.0", "@ethersproject/random@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/random/-/random-5.4.0.tgz#9cdde60e160d024be39cc16f8de3b9ce39191e16" + integrity sha512-pnpWNQlf0VAZDEOVp1rsYQosmv2o0ITS/PecNw+mS2/btF8eYdspkN0vIXrCMtkX09EAh9bdk8GoXmFXM1eAKw== dependencies: - "@ethersproject/bytes" "^5.2.0" - "@ethersproject/logger" "^5.2.0" + "@ethersproject/bytes" "^5.4.0" + "@ethersproject/logger" "^5.4.0" -"@ethersproject/rlp@^5.2.0", "@ethersproject/rlp@^5.3.0": +"@ethersproject/rlp@5.3.0", "@ethersproject/rlp@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/rlp/-/rlp-5.3.0.tgz#7cb93a7b5dfa69163894153c9d4b0d936f333188" integrity sha512-oI0joYpsRanl9guDubaW+1NbcpK0vJ3F/6Wpcanzcnqq+oaW9O5E98liwkEDPcb16BUTLIJ+ZF8GPIHYxJ/5Pw== @@ -930,25 +761,15 @@ "@ethersproject/bytes" "^5.3.0" "@ethersproject/logger" "^5.3.0" -"@ethersproject/sha2@5.1.0": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/sha2/-/sha2-5.1.0.tgz#6ca42d1a26884b3e32ffa943fe6494af7211506c" - integrity sha512-+fNSeZRstOpdRJpdGUkRONFCaiAqWkc91zXgg76Nlp5ndBQE25Kk5yK8gCPG1aGnCrbariiPr5j9DmrYH78JCA== +"@ethersproject/rlp@5.4.0", "@ethersproject/rlp@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/rlp/-/rlp-5.4.0.tgz#de61afda5ff979454e76d3b3310a6c32ad060931" + integrity sha512-0I7MZKfi+T5+G8atId9QaQKHRvvasM/kqLyAH4XxBCBchAooH2EX5rL9kYZWwcm3awYV+XC7VF6nLhfeQFKVPg== dependencies: - "@ethersproject/bytes" "^5.1.0" - "@ethersproject/logger" "^5.1.0" - hash.js "1.1.3" - -"@ethersproject/sha2@5.2.0", "@ethersproject/sha2@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/sha2/-/sha2-5.2.0.tgz#ae18fa6c09c6d99fa2b564dac7276bcd513c1579" - integrity sha512-Wqqptfn0PRO2mvmpktPW1HOLrrCyGtxhVQxO1ZyePoGrcEOurhICOlIvkTogoX4Q928D3Z9XtSSCUbdOJUF2kg== - dependencies: - "@ethersproject/bytes" "^5.2.0" - "@ethersproject/logger" "^5.2.0" - hash.js "1.1.3" + "@ethersproject/bytes" "^5.4.0" + "@ethersproject/logger" "^5.4.0" -"@ethersproject/sha2@^5.2.0", "@ethersproject/sha2@^5.3.0": +"@ethersproject/sha2@5.3.0", "@ethersproject/sha2@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/sha2/-/sha2-5.3.0.tgz#209f9a1649f7d2452dcd5e5b94af43b7f3f42366" integrity sha512-r5ftlwKcocYEuFz2JbeKOT5SAsCV4m1RJDsTOEfQ5L67ZC7NFDK5i7maPdn1bx4nPhylF9VAwxSrQ1esmwzylg== @@ -957,29 +778,16 @@ "@ethersproject/logger" "^5.3.0" hash.js "1.1.7" -"@ethersproject/signing-key@5.1.0": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/signing-key/-/signing-key-5.1.0.tgz#6eddfbddb6826b597b9650e01acf817bf8991b9c" - integrity sha512-tE5LFlbmdObG8bY04NpuwPWSRPgEswfxweAI1sH7TbP0ml1elNfqcq7ii/3AvIN05i5U0Pkm3Tf8bramt8MmLw== - dependencies: - "@ethersproject/bytes" "^5.1.0" - "@ethersproject/logger" "^5.1.0" - "@ethersproject/properties" "^5.1.0" - bn.js "^4.4.0" - elliptic "6.5.4" - -"@ethersproject/signing-key@5.2.0", "@ethersproject/signing-key@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/signing-key/-/signing-key-5.2.0.tgz#e8eb10d3c0f4a575479db8d70c62aaf93cd384d1" - integrity sha512-9A+dVSkrVAPuhJnWqLWV/NkKi/KB4iagTKEuojfuApUfeIHEhpwQ0Jx3cBimk7qWISSSKdgiAmIqpvVtZ5FEkg== +"@ethersproject/sha2@5.4.0", "@ethersproject/sha2@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/sha2/-/sha2-5.4.0.tgz#c9a8db1037014cbc4e9482bd662f86c090440371" + integrity sha512-siheo36r1WD7Cy+bDdE1BJ8y0bDtqXCOxRMzPa4bV1TGt/eTUUt03BHoJNB6reWJD8A30E/pdJ8WFkq+/uz4Gg== dependencies: - "@ethersproject/bytes" "^5.2.0" - "@ethersproject/logger" "^5.2.0" - "@ethersproject/properties" "^5.2.0" - bn.js "^4.4.0" - elliptic "6.5.4" + "@ethersproject/bytes" "^5.4.0" + "@ethersproject/logger" "^5.4.0" + hash.js "1.1.7" -"@ethersproject/signing-key@^5.2.0", "@ethersproject/signing-key@^5.3.0": +"@ethersproject/signing-key@5.3.0", "@ethersproject/signing-key@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/signing-key/-/signing-key-5.3.0.tgz#a96c88f8173e1abedfa35de32d3e5db7c48e5259" integrity sha512-+DX/GwHAd0ok1bgedV1cKO0zfK7P/9aEyNoaYiRsGHpCecN7mhLqcdoUiUzE7Uz86LBsxm5ssK0qA1kBB47fbQ== @@ -991,29 +799,19 @@ elliptic "6.5.4" hash.js "1.1.7" -"@ethersproject/solidity@5.1.0": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/solidity/-/solidity-5.1.0.tgz#095a9c75244edccb26c452c155736d363399b954" - integrity sha512-kPodsGyo9zg1g9XSXp1lGhFaezBAUUsAUB1Vf6OkppE5Wksg4Et+x3kG4m7J/uShDMP2upkJtHNsIBK2XkVpKQ== +"@ethersproject/signing-key@5.4.0", "@ethersproject/signing-key@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/signing-key/-/signing-key-5.4.0.tgz#2f05120984e81cf89a3d5f6dec5c68ee0894fbec" + integrity sha512-q8POUeywx6AKg2/jX9qBYZIAmKSB4ubGXdQ88l40hmATj29JnG5pp331nAWwwxPn2Qao4JpWHNZsQN+bPiSW9A== dependencies: - "@ethersproject/bignumber" "^5.1.0" - "@ethersproject/bytes" "^5.1.0" - "@ethersproject/keccak256" "^5.1.0" - "@ethersproject/sha2" "^5.1.0" - "@ethersproject/strings" "^5.1.0" - -"@ethersproject/solidity@5.2.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/solidity/-/solidity-5.2.0.tgz#ac902d8f8b11bf58fd37ccf77392178cbbd0b08f" - integrity sha512-EEFlNyEnONW3CWF8UGWPcqxJUHiaIoofO7itGwO/2gvGpnwlL+WUV+GmQoHNxmn+QJeOHspnZuh6NOVrJL6H1g== - dependencies: - "@ethersproject/bignumber" "^5.2.0" - "@ethersproject/bytes" "^5.2.0" - "@ethersproject/keccak256" "^5.2.0" - "@ethersproject/sha2" "^5.2.0" - "@ethersproject/strings" "^5.2.0" + "@ethersproject/bytes" "^5.4.0" + "@ethersproject/logger" "^5.4.0" + "@ethersproject/properties" "^5.4.0" + bn.js "^4.11.9" + elliptic "6.5.4" + hash.js "1.1.7" -"@ethersproject/solidity@^5.0.0", "@ethersproject/solidity@^5.3.0": +"@ethersproject/solidity@5.3.0", "@ethersproject/solidity@^5.0.0", "@ethersproject/solidity@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/solidity/-/solidity-5.3.0.tgz#2a0b00b4aaaef99a080ddea13acab1fa35cd4a93" integrity sha512-uLRBaNUiISHbut94XKewJgQh6UmydWTBp71I7I21pkjVXfZO2dJ5EOo3jCnumJc01M4LOm79dlNNmF3oGIvweQ== @@ -1024,25 +822,18 @@ "@ethersproject/sha2" "^5.3.0" "@ethersproject/strings" "^5.3.0" -"@ethersproject/strings@5.1.0", "@ethersproject/strings@>=5.0.0-beta.130", "@ethersproject/strings@^5.0.4": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/strings/-/strings-5.1.0.tgz#0f95a56c3c8c9d5510a06c241d818779750e2da5" - integrity sha512-perBZy0RrmmL0ejiFGUOlBVjMsUceqLut3OBP3zP96LhiJWWbS8u1NqQVgN4/Gyrbziuda66DxiQocXhsvx+Sw== - dependencies: - "@ethersproject/bytes" "^5.1.0" - "@ethersproject/constants" "^5.1.0" - "@ethersproject/logger" "^5.1.0" - -"@ethersproject/strings@5.2.0", "@ethersproject/strings@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/strings/-/strings-5.2.0.tgz#e93d989859587191c3f64bda124d9dedbc3f5a97" - integrity sha512-RmjX800wRYKgrzo2ZCSlA8OCQYyq4+M46VgjSVDVyYkLZctBXC3epqlppDA24R7eo856KNbXqezZsMnHT+sSuA== +"@ethersproject/solidity@5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/solidity/-/solidity-5.4.0.tgz#1305e058ea02dc4891df18b33232b11a14ece9ec" + integrity sha512-XFQTZ7wFSHOhHcV1DpcWj7VXECEiSrBuv7JErJvB9Uo+KfCdc3QtUZV+Vjh/AAaYgezUEKbCtE6Khjm44seevQ== dependencies: - "@ethersproject/bytes" "^5.2.0" - "@ethersproject/constants" "^5.2.0" - "@ethersproject/logger" "^5.2.0" + "@ethersproject/bignumber" "^5.4.0" + "@ethersproject/bytes" "^5.4.0" + "@ethersproject/keccak256" "^5.4.0" + "@ethersproject/sha2" "^5.4.0" + "@ethersproject/strings" "^5.4.0" -"@ethersproject/strings@^5.2.0", "@ethersproject/strings@^5.3.0": +"@ethersproject/strings@5.3.0", "@ethersproject/strings@>=5.0.0-beta.130", "@ethersproject/strings@^5.0.4", "@ethersproject/strings@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/strings/-/strings-5.3.0.tgz#a6b640aab56a18e0909f657da798eef890968ff0" integrity sha512-j/AzIGZ503cvhuF2ldRSjB0BrKzpsBMtCieDtn4TYMMZMQ9zScJn9wLzTQl/bRNvJbBE6TOspK0r8/Ngae/f2Q== @@ -1051,37 +842,16 @@ "@ethersproject/constants" "^5.3.0" "@ethersproject/logger" "^5.3.0" -"@ethersproject/transactions@5.1.1", "@ethersproject/transactions@^5.0.0-beta.135": - version "5.1.1" - resolved "https://registry.yarnpkg.com/@ethersproject/transactions/-/transactions-5.1.1.tgz#5a6bbb25fb062c3cc75eb0db12faefcdd3870813" - integrity sha512-Nwgbp09ttIVN0OoUBatCXaHxR7grWPHbozJN8v7AXDLrl6nnOIBEMDh+yJTnosSQlFhcyjfTGGN+Mx6R8HdvMw== - dependencies: - "@ethersproject/address" "^5.1.0" - "@ethersproject/bignumber" "^5.1.0" - "@ethersproject/bytes" "^5.1.0" - "@ethersproject/constants" "^5.1.0" - "@ethersproject/keccak256" "^5.1.0" - "@ethersproject/logger" "^5.1.0" - "@ethersproject/properties" "^5.1.0" - "@ethersproject/rlp" "^5.1.0" - "@ethersproject/signing-key" "^5.1.0" - -"@ethersproject/transactions@5.2.0", "@ethersproject/transactions@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/transactions/-/transactions-5.2.0.tgz#052e2ef8f8adf7037ebe4cc47aad2a61950e6491" - integrity sha512-QrGbhGYsouNNclUp3tWMbckMsuXJTOsA56kT3BuRrLlXJcUH7myIihajXdSfKcyJsvHJPrGZP+U3TKh+sLzZtg== - dependencies: - "@ethersproject/address" "^5.2.0" - "@ethersproject/bignumber" "^5.2.0" - "@ethersproject/bytes" "^5.2.0" - "@ethersproject/constants" "^5.2.0" - "@ethersproject/keccak256" "^5.2.0" - "@ethersproject/logger" "^5.2.0" - "@ethersproject/properties" "^5.2.0" - "@ethersproject/rlp" "^5.2.0" - "@ethersproject/signing-key" "^5.2.0" - -"@ethersproject/transactions@^5.2.0", "@ethersproject/transactions@^5.3.0": +"@ethersproject/strings@5.4.0", "@ethersproject/strings@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/strings/-/strings-5.4.0.tgz#fb12270132dd84b02906a8d895ae7e7fa3d07d9a" + integrity sha512-k/9DkH5UGDhv7aReXLluFG5ExurwtIpUfnDNhQA29w896Dw3i4uDTz01Quaptbks1Uj9kI8wo9tmW73wcIEaWA== + dependencies: + "@ethersproject/bytes" "^5.4.0" + "@ethersproject/constants" "^5.4.0" + "@ethersproject/logger" "^5.4.0" + +"@ethersproject/transactions@5.3.0", "@ethersproject/transactions@^5.0.0-beta.135", "@ethersproject/transactions@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/transactions/-/transactions-5.3.0.tgz#49b86f2bafa4d0bdf8e596578fc795ee47c50458" integrity sha512-cdfK8VVyW2oEBCXhURG0WQ6AICL/r6Gmjh0e4Bvbv6MCn/GBd8FeBH3rtl7ho+AW50csMKeGv3m3K1HSHB2jMQ== @@ -1096,67 +866,40 @@ "@ethersproject/rlp" "^5.3.0" "@ethersproject/signing-key" "^5.3.0" -"@ethersproject/units@5.1.0": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/units/-/units-5.1.0.tgz#b6ab3430ebc22adc3cb4839516496f167bee3ad5" - integrity sha512-isvJrx6qG0nKWfxsGORNjmOq/nh175fStfvRTA2xEKrGqx8JNJY83fswu4GkILowfriEM/eYpretfJnfzi7YhA== +"@ethersproject/transactions@5.4.0", "@ethersproject/transactions@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/transactions/-/transactions-5.4.0.tgz#a159d035179334bd92f340ce0f77e83e9e1522e0" + integrity sha512-s3EjZZt7xa4BkLknJZ98QGoIza94rVjaEed0rzZ/jB9WrIuu/1+tjvYCWzVrystXtDswy7TPBeIepyXwSYa4WQ== + dependencies: + "@ethersproject/address" "^5.4.0" + "@ethersproject/bignumber" "^5.4.0" + "@ethersproject/bytes" "^5.4.0" + "@ethersproject/constants" "^5.4.0" + "@ethersproject/keccak256" "^5.4.0" + "@ethersproject/logger" "^5.4.0" + "@ethersproject/properties" "^5.4.0" + "@ethersproject/rlp" "^5.4.0" + "@ethersproject/signing-key" "^5.4.0" + +"@ethersproject/units@5.3.0": + version "5.3.0" + resolved "https://registry.yarnpkg.com/@ethersproject/units/-/units-5.3.0.tgz#c4d1493532ad3d4ddf6e2bc4f8c94a2db933a8f5" + integrity sha512-BkfccZGwfJ6Ob+AelpIrgAzuNhrN2VLp3AILnkqTOv+yBdsc83V4AYf25XC/u0rHnWl6f4POaietPwlMqP2vUg== dependencies: - "@ethersproject/bignumber" "^5.1.0" - "@ethersproject/constants" "^5.1.0" - "@ethersproject/logger" "^5.1.0" + "@ethersproject/bignumber" "^5.3.0" + "@ethersproject/constants" "^5.3.0" + "@ethersproject/logger" "^5.3.0" -"@ethersproject/units@5.2.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/units/-/units-5.2.0.tgz#08643e5d4583ecc1a32b103c1157f7ae80803392" - integrity sha512-yrwlyomXcBBHp5oSrLxlLkyHN7dVu3PO7hMbQXc00h388zU4TF3o/PAIUhh+x695wgJ19Fa8YgUWCab3a1RDwA== +"@ethersproject/units@5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/units/-/units-5.4.0.tgz#d57477a4498b14b88b10396062c8cbbaf20c79fe" + integrity sha512-Z88krX40KCp+JqPCP5oPv5p750g+uU6gopDYRTBGcDvOASh6qhiEYCRatuM/suC4S2XW9Zz90QI35MfSrTIaFg== dependencies: - "@ethersproject/bignumber" "^5.2.0" - "@ethersproject/constants" "^5.2.0" - "@ethersproject/logger" "^5.2.0" + "@ethersproject/bignumber" "^5.4.0" + "@ethersproject/constants" "^5.4.0" + "@ethersproject/logger" "^5.4.0" -"@ethersproject/wallet@5.1.0": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/wallet/-/wallet-5.1.0.tgz#134c5816eaeaa586beae9f9ff67891104a2c9a15" - integrity sha512-ULmUtiYQLTUS+y3DgkLzRhFEK10zMwmjOthnjiZxee3Q/MVwr3rnmuAnXIUZrPjna6hvUPnyRIdW5XuF0Ld0YQ== - dependencies: - "@ethersproject/abstract-provider" "^5.1.0" - "@ethersproject/abstract-signer" "^5.1.0" - "@ethersproject/address" "^5.1.0" - "@ethersproject/bignumber" "^5.1.0" - "@ethersproject/bytes" "^5.1.0" - "@ethersproject/hash" "^5.1.0" - "@ethersproject/hdnode" "^5.1.0" - "@ethersproject/json-wallets" "^5.1.0" - "@ethersproject/keccak256" "^5.1.0" - "@ethersproject/logger" "^5.1.0" - "@ethersproject/properties" "^5.1.0" - "@ethersproject/random" "^5.1.0" - "@ethersproject/signing-key" "^5.1.0" - "@ethersproject/transactions" "^5.1.0" - "@ethersproject/wordlists" "^5.1.0" - -"@ethersproject/wallet@5.2.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/wallet/-/wallet-5.2.0.tgz#b5a8406676067e34f633536a4cb53c2ff98c0b5c" - integrity sha512-uPdjZwUmAJLo1+ybR/G/rL9pv/NEcCqOsjn6RJFvG7RmwP2kS1v5C+F+ysgx2W/PxBIVT+2IEsfXLbBz8s/6Rg== - dependencies: - "@ethersproject/abstract-provider" "^5.2.0" - "@ethersproject/abstract-signer" "^5.2.0" - "@ethersproject/address" "^5.2.0" - "@ethersproject/bignumber" "^5.2.0" - "@ethersproject/bytes" "^5.2.0" - "@ethersproject/hash" "^5.2.0" - "@ethersproject/hdnode" "^5.2.0" - "@ethersproject/json-wallets" "^5.2.0" - "@ethersproject/keccak256" "^5.2.0" - "@ethersproject/logger" "^5.2.0" - "@ethersproject/properties" "^5.2.0" - "@ethersproject/random" "^5.2.0" - "@ethersproject/signing-key" "^5.2.0" - "@ethersproject/transactions" "^5.2.0" - "@ethersproject/wordlists" "^5.2.0" - -"@ethersproject/wallet@^5.3.0": +"@ethersproject/wallet@5.3.0", "@ethersproject/wallet@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/wallet/-/wallet-5.3.0.tgz#91946b470bd279e39ade58866f21f92749d062af" integrity sha512-boYBLydG6671p9QoG6EinNnNzbm7DNOjVT20eV8J6HQEq4aUaGiA2CytF2vK+2rOEWbzhZqoNDt6AlkE1LlsTg== @@ -1177,29 +920,28 @@ "@ethersproject/transactions" "^5.3.0" "@ethersproject/wordlists" "^5.3.0" -"@ethersproject/web@5.1.0": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/web/-/web-5.1.0.tgz#ed56bbe4e3d9a8ffe3b2ed882da5c62d3551381b" - integrity sha512-LTeluWgTq04+RNqAkVhpydPcRZK/kKxD2Vy7PYGrAD27ABO9kTqTBKwiOuzTyAHKUQHfnvZbXmxBXJAGViSDcA== - dependencies: - "@ethersproject/base64" "^5.1.0" - "@ethersproject/bytes" "^5.1.0" - "@ethersproject/logger" "^5.1.0" - "@ethersproject/properties" "^5.1.0" - "@ethersproject/strings" "^5.1.0" - -"@ethersproject/web@5.2.0", "@ethersproject/web@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/web/-/web-5.2.0.tgz#47d8e152e7fcc07ba0aff4f99fde268fde79dd7a" - integrity sha512-mYb9qxGlOBFR2pR6t1CZczuqqX6r8RQGn7MtwrBciMex3cvA/qs+wbmcDgl+/OZY0Pco/ih6WHQRnVi+4sBeCQ== - dependencies: - "@ethersproject/base64" "^5.2.0" - "@ethersproject/bytes" "^5.2.0" - "@ethersproject/logger" "^5.2.0" - "@ethersproject/properties" "^5.2.0" - "@ethersproject/strings" "^5.2.0" - -"@ethersproject/web@^5.2.0", "@ethersproject/web@^5.3.0": +"@ethersproject/wallet@5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/wallet/-/wallet-5.4.0.tgz#fa5b59830b42e9be56eadd45a16a2e0933ad9353" + integrity sha512-wU29majLjM6AjCjpat21mPPviG+EpK7wY1+jzKD0fg3ui5fgedf2zEu1RDgpfIMsfn8fJHJuzM4zXZ2+hSHaSQ== + dependencies: + "@ethersproject/abstract-provider" "^5.4.0" + "@ethersproject/abstract-signer" "^5.4.0" + "@ethersproject/address" "^5.4.0" + "@ethersproject/bignumber" "^5.4.0" + "@ethersproject/bytes" "^5.4.0" + "@ethersproject/hash" "^5.4.0" + "@ethersproject/hdnode" "^5.4.0" + "@ethersproject/json-wallets" "^5.4.0" + "@ethersproject/keccak256" "^5.4.0" + "@ethersproject/logger" "^5.4.0" + "@ethersproject/properties" "^5.4.0" + "@ethersproject/random" "^5.4.0" + "@ethersproject/signing-key" "^5.4.0" + "@ethersproject/transactions" "^5.4.0" + "@ethersproject/wordlists" "^5.4.0" + +"@ethersproject/web@5.3.0", "@ethersproject/web@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/web/-/web-5.3.0.tgz#7959c403f6476c61515008d8f92da51c553a8ee1" integrity sha512-Ni6/DHnY6k/TD41LEkv0RQDx4jqWz5e/RZvrSecsxGYycF+MFy2z++T/yGc2peRunLOTIFwEksgEGGlbwfYmhQ== @@ -1210,29 +952,18 @@ "@ethersproject/properties" "^5.3.0" "@ethersproject/strings" "^5.3.0" -"@ethersproject/wordlists@5.1.0": - version "5.1.0" - resolved "https://registry.yarnpkg.com/@ethersproject/wordlists/-/wordlists-5.1.0.tgz#54eb9ef3a00babbff90ffe124e19c89e07e6aace" - integrity sha512-NsUCi/TpBb+oTFvMSccUkJGtp5o/84eOyqp5q5aBeiNBSLkYyw21znRn9mAmxZgySpxgruVgKbaapnYPgvctPQ== +"@ethersproject/web@5.4.0", "@ethersproject/web@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/web/-/web-5.4.0.tgz#49fac173b96992334ed36a175538ba07a7413d1f" + integrity sha512-1bUusGmcoRLYgMn6c1BLk1tOKUIFuTg8j+6N8lYlbMpDesnle+i3pGSagGNvwjaiLo4Y5gBibwctpPRmjrh4Og== dependencies: - "@ethersproject/bytes" "^5.1.0" - "@ethersproject/hash" "^5.1.0" - "@ethersproject/logger" "^5.1.0" - "@ethersproject/properties" "^5.1.0" - "@ethersproject/strings" "^5.1.0" + "@ethersproject/base64" "^5.4.0" + "@ethersproject/bytes" "^5.4.0" + "@ethersproject/logger" "^5.4.0" + "@ethersproject/properties" "^5.4.0" + "@ethersproject/strings" "^5.4.0" -"@ethersproject/wordlists@5.2.0", "@ethersproject/wordlists@^5.1.0": - version "5.2.0" - resolved "https://registry.yarnpkg.com/@ethersproject/wordlists/-/wordlists-5.2.0.tgz#afcce0229e9ef64af1bf8a1e96571fa441e9f444" - integrity sha512-/7TG5r/Zm8Wd9WhoqQ4QnntgMkIfIZ8QVrpU81muiChLD26XLOgmyiqKPL7K058uYt7UZ0wzbXjxyCYadU3xFQ== - dependencies: - "@ethersproject/bytes" "^5.2.0" - "@ethersproject/hash" "^5.2.0" - "@ethersproject/logger" "^5.2.0" - "@ethersproject/properties" "^5.2.0" - "@ethersproject/strings" "^5.2.0" - -"@ethersproject/wordlists@^5.2.0", "@ethersproject/wordlists@^5.3.0": +"@ethersproject/wordlists@5.3.0", "@ethersproject/wordlists@^5.3.0": version "5.3.0" resolved "https://registry.yarnpkg.com/@ethersproject/wordlists/-/wordlists-5.3.0.tgz#45a0205f5178c1de33d316cb2ab7ed5eac3c06c5" integrity sha512-JcwumCZcsUxgWpiFU/BRy6b4KlTRdOmYvOKZcAw/3sdF93/pZyPW5Od2hFkHS8oWp4xS06YQ+qHqQhdcxdHafQ== @@ -1243,6 +974,17 @@ "@ethersproject/properties" "^5.3.0" "@ethersproject/strings" "^5.3.0" +"@ethersproject/wordlists@5.4.0", "@ethersproject/wordlists@^5.4.0": + version "5.4.0" + resolved "https://registry.yarnpkg.com/@ethersproject/wordlists/-/wordlists-5.4.0.tgz#f34205ec3bbc9e2c49cadaee774cf0b07e7573d7" + integrity sha512-FemEkf6a+EBKEPxlzeVgUaVSodU7G0Na89jqKjmWMlDB0tomoU8RlEMgUvXyqtrg8N4cwpLh8nyRnm1Nay1isA== + dependencies: + "@ethersproject/bytes" "^5.4.0" + "@ethersproject/hash" "^5.4.0" + "@ethersproject/logger" "^5.4.0" + "@ethersproject/properties" "^5.4.0" + "@ethersproject/strings" "^5.4.0" + "@fvictorio/tabtab@^0.0.3": version "0.0.3" resolved "https://registry.yarnpkg.com/@fvictorio/tabtab/-/tabtab-0.0.3.tgz#1b97981424386490fa2a5818706d2afd1f6e4659" @@ -1254,47 +996,47 @@ mkdirp "^1.0.3" untildify "^4.0.0" -"@jest/types@^26.6.2": - version "26.6.2" - resolved "https://registry.yarnpkg.com/@jest/types/-/types-26.6.2.tgz#bef5a532030e1d88a2f5a6d933f84e97226ed48e" - integrity sha512-fC6QCp7Sc5sX6g8Tvbmj4XUTbyrik0akgRy03yjXbQaBWWNWGE7SGtJk98m0N8nzegD/7SggrUlivxo5ax4KWQ== +"@jest/types@^27.0.2": + version "27.0.2" + resolved "https://registry.yarnpkg.com/@jest/types/-/types-27.0.2.tgz#e153d6c46bda0f2589f0702b071f9898c7bbd37e" + integrity sha512-XpjCtJ/99HB4PmyJ2vgmN7vT+JLP7RW1FBT9RgnMFS4Dt7cvIyBee8O3/j98aUZ34ZpenPZFqmaaObWSeL65dg== dependencies: "@types/istanbul-lib-coverage" "^2.0.0" "@types/istanbul-reports" "^3.0.0" "@types/node" "*" - "@types/yargs" "^15.0.0" + "@types/yargs" "^16.0.0" chalk "^4.0.0" -"@nodelib/fs.scandir@2.1.4": - version "2.1.4" - resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.4.tgz#d4b3549a5db5de2683e0c1071ab4f140904bbf69" - integrity sha512-33g3pMJk3bg5nXbL/+CY6I2eJDzZAni49PfJnL5fghPTggPvBd/pFNSgJsdAgWptuFu7qq/ERvOYFlhvsLTCKA== +"@nodelib/fs.scandir@2.1.5": + version "2.1.5" + resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz#7619c2eb21b25483f6d167548b4cfd5a7488c3d5" + integrity sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g== dependencies: - "@nodelib/fs.stat" "2.0.4" + "@nodelib/fs.stat" "2.0.5" run-parallel "^1.1.9" -"@nodelib/fs.stat@2.0.4", "@nodelib/fs.stat@^2.0.2": - version "2.0.4" - resolved "https://registry.yarnpkg.com/@nodelib/fs.stat/-/fs.stat-2.0.4.tgz#a3f2dd61bab43b8db8fa108a121cfffe4c676655" - integrity sha512-IYlHJA0clt2+Vg7bccq+TzRdJvv19c2INqBSsoOLp1je7xjtr7J26+WXR72MCdvU9q1qTzIWDfhMf+DRvQJK4Q== +"@nodelib/fs.stat@2.0.5", "@nodelib/fs.stat@^2.0.2": + version "2.0.5" + resolved "https://registry.yarnpkg.com/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz#5bd262af94e9d25bd1e71b05deed44876a222e8b" + integrity sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A== "@nodelib/fs.walk@^1.2.3": - version "1.2.6" - resolved "https://registry.yarnpkg.com/@nodelib/fs.walk/-/fs.walk-1.2.6.tgz#cce9396b30aa5afe9e3756608f5831adcb53d063" - integrity sha512-8Broas6vTtW4GIXTAHDoE32hnN2M5ykgCpWGbuXHQ15vEMqr23pB76e/GZcYsZCHALv50ktd24qhEyKr6wBtow== + version "1.2.7" + resolved "https://registry.yarnpkg.com/@nodelib/fs.walk/-/fs.walk-1.2.7.tgz#94c23db18ee4653e129abd26fb06f870ac9e1ee2" + integrity sha512-BTIhocbPBSrRmHxOAJFtR18oLhxTtAFDAvL8hY1S3iU8k+E60W/YFs4jrixGzQjMpF4qPXxIQHcjVD9dz1C2QA== dependencies: - "@nodelib/fs.scandir" "2.1.4" + "@nodelib/fs.scandir" "2.1.5" fastq "^1.6.0" -"@nomiclabs/hardhat-ethers@^2.0.1": +"@nomiclabs/hardhat-ethers@^2.0.0", "@nomiclabs/hardhat-ethers@^2.0.1": version "2.0.2" resolved "https://registry.yarnpkg.com/@nomiclabs/hardhat-ethers/-/hardhat-ethers-2.0.2.tgz#c472abcba0c5185aaa4ad4070146e95213c68511" integrity sha512-6quxWe8wwS4X5v3Au8q1jOvXYEPkS1Fh+cME5u6AwNdnI4uERvPlVjlgRWzpnb+Rrt1l/cEqiNRH9GlsBMSDQg== "@nomiclabs/hardhat-etherscan@^2.1.0": - version "2.1.2" - resolved "https://registry.yarnpkg.com/@nomiclabs/hardhat-etherscan/-/hardhat-etherscan-2.1.2.tgz#333b70a6116e922d16de2ef833dcb7191319afdd" - integrity sha512-SExzaBuHlnmHw0HKkElHITzdvhUQmlIRc2tlaywzgvPbh7WoI24nYqZ4N0CO+JXSDgRpFycvQNA8zRaCqjuqUg== + version "2.1.3" + resolved "https://registry.yarnpkg.com/@nomiclabs/hardhat-etherscan/-/hardhat-etherscan-2.1.3.tgz#ba52e5cb526f6c477e5e97e07c72a42232773c92" + integrity sha512-0Ic5dLBWASeX3e8tR5cdfoSQw8fTp2Bw49RGUN1pSJuxKIQAOWq5MI9qC1Bd51xK/AsdRSnHDxoVYK1+FC1s1w== dependencies: "@ethersproject/abi" "^5.0.2" "@ethersproject/address" "^5.0.2" @@ -1304,7 +1046,18 @@ node-fetch "^2.6.0" semver "^6.3.0" -"@nomiclabs/hardhat-waffle@^2.0.1": +"@nomiclabs/hardhat-truffle5@^2.0.0": + version "2.0.0" + resolved "https://registry.yarnpkg.com/@nomiclabs/hardhat-truffle5/-/hardhat-truffle5-2.0.0.tgz#1363b7f4f90e3d5b049d22e5e6d3519ba1b91fdf" + integrity sha512-JLjyfeXTiSqa0oLHcN3i8kD4coJa4Gx6uAXybGv3aBiliEbHddLSzmBWx0EU69a1/Ad5YDdGSqVnjB8mkUCr/g== + dependencies: + "@nomiclabs/truffle-contract" "^4.2.23" + "@types/chai" "^4.2.0" + chai "^4.2.0" + ethereumjs-util "^6.1.0" + fs-extra "^7.0.1" + +"@nomiclabs/hardhat-waffle@^2.0.0", "@nomiclabs/hardhat-waffle@^2.0.1": version "2.0.1" resolved "https://registry.yarnpkg.com/@nomiclabs/hardhat-waffle/-/hardhat-waffle-2.0.1.tgz#5d43654fba780720c5033dea240fe14f70ef4bd2" integrity sha512-2YR2V5zTiztSH9n8BYWgtv3Q+EL0N5Ltm1PAr5z20uAY4SkkfylJ98CIqt18XFvxTD5x4K2wKBzddjV9ViDAZQ== @@ -1312,6 +1065,21 @@ "@types/sinon-chai" "^3.2.3" "@types/web3" "1.0.19" +"@nomiclabs/truffle-contract@^4.2.23": + version "4.2.23" + resolved "https://registry.yarnpkg.com/@nomiclabs/truffle-contract/-/truffle-contract-4.2.23.tgz#3431d09d2400413d3a14650494abc0a6233c16d4" + integrity sha512-Khj/Ts9r0LqEpGYhISbc+8WTOd6qJ4aFnDR+Ew+neqcjGnhwrIvuihNwPFWU6hDepW3Xod6Y+rTo90N8sLRDjw== + dependencies: + "@truffle/blockchain-utils" "^0.0.25" + "@truffle/contract-schema" "^3.2.5" + "@truffle/debug-utils" "^4.2.9" + "@truffle/error" "^0.0.11" + "@truffle/interface-adapter" "^0.4.16" + bignumber.js "^7.2.1" + ethereum-ens "^0.8.0" + ethers "^4.0.0-beta.1" + source-map-support "^0.5.19" + "@openzeppelin/contracts-upgradeable@^4.0.0": version "4.1.0" resolved "https://registry.yarnpkg.com/@openzeppelin/contracts-upgradeable/-/contracts-upgradeable-4.1.0.tgz#36a6113ceeda278ae14f740280e5388161dfd383" @@ -1322,6 +1090,11 @@ resolved "https://registry.yarnpkg.com/@openzeppelin/contracts/-/contracts-4.1.0.tgz#baec89a7f5f73e3d8ea582a78f1980134b605375" integrity sha512-TihZitscnaHNcZgXGj9zDLDyCqjziytB4tMCwXq0XimfWkAjBYyk5/pOsDbbwcavhlc79HhpTEpQcrMnPVa1mw== +"@openzeppelin/contracts@^4.1.0": + version "4.2.0" + resolved "https://registry.yarnpkg.com/@openzeppelin/contracts/-/contracts-4.2.0.tgz#260d921d99356e48013d9d760caaa6cea35dc642" + integrity sha512-LD4NnkKpHHSMo5z9MvFsG4g1xxZUDqV3A3Futu3nvyfs4wPwXxqOgMaxOoa2PeyGL2VNeSlbxT54enbQzGcgJQ== + "@resolver-engine/core@^0.3.3": version "0.3.3" resolved "https://registry.yarnpkg.com/@resolver-engine/core/-/core-0.3.3.tgz#590f77d85d45bc7ecc4e06c654f41345db6ca967" @@ -1439,10 +1212,10 @@ dependencies: type-detect "4.0.8" -"@sinonjs/fake-timers@^7.0.4": - version "7.0.5" - resolved "https://registry.yarnpkg.com/@sinonjs/fake-timers/-/fake-timers-7.0.5.tgz#558a7f8145a01366c44b3dcbdd7172c05c461564" - integrity sha512-fUt6b15bjV/VW93UP5opNXJxdwZSbK1EdiwnhN7XrQrcpaOhMJpZ/CjwFpM3THpxwA+YviBUJKSuEqKlCK5alw== +"@sinonjs/fake-timers@^7.1.0": + version "7.1.2" + resolved "https://registry.yarnpkg.com/@sinonjs/fake-timers/-/fake-timers-7.1.2.tgz#2524eae70c4910edccf99b2f4e6efc5894aff7b5" + integrity sha512-iQADsW4LBMISqZ6Ci1dupJL9pprqwcVFTcOsEmQOEhW+KLCVn/Y4Jrvg2k19fIHCp+iFprriYPTdRcQR8NbUPg== dependencies: "@sinonjs/commons" "^1.7.0" @@ -1451,11 +1224,18 @@ resolved "https://registry.yarnpkg.com/@solidity-parser/parser/-/parser-0.11.1.tgz#fa840af64840c930f24a9c82c08d4a092a068add" integrity sha512-H8BSBoKE8EubJa0ONqecA2TviT3TnHeC4NpgnAHSUiuhZoQBfPB4L2P9bs8R6AoTW10Endvh3vc+fomVMIDIYQ== -"@solidity-parser/parser@^0.12.0", "@solidity-parser/parser@^0.12.1": +"@solidity-parser/parser@^0.12.0": version "0.12.2" resolved "https://registry.yarnpkg.com/@solidity-parser/parser/-/parser-0.12.2.tgz#1afad367cb29a2ed8cdd4a3a62701c2821fb578f" integrity sha512-d7VS7PxgMosm5NyaiyDJRNID5pK4AWj1l64Dbz0147hJgy5k2C0/ZiKK/9u5c5K+HRUVHmp+RMvGEjGh84oA5Q== +"@solidity-parser/parser@^0.13.2": + version "0.13.2" + resolved "https://registry.yarnpkg.com/@solidity-parser/parser/-/parser-0.13.2.tgz#b6c71d8ca0b382d90a7bbed241f9bc110af65cbe" + integrity sha512-RwHnpRnfrnD2MSPveYoPh8nhofEvX7fgjHk1Oq+NNvCcLx4r1js91CO9o+F/F3fBzOCyvm8kKRTriFICX/odWw== + dependencies: + antlr4ts "^0.5.0-alpha.4" + "@szmarczak/http-timer@^1.1.2": version "1.1.2" resolved "https://registry.yarnpkg.com/@szmarczak/http-timer/-/http-timer-1.1.2.tgz#b1665e2c461a2cd92f4c1bbf50d5454de0d4b421" @@ -1472,15 +1252,22 @@ fs-extra "^9.0.1" js-yaml "^3.14.0" -"@truffle/blockchain-utils@^0.0.30": - version "0.0.30" - resolved "https://registry.yarnpkg.com/@truffle/blockchain-utils/-/blockchain-utils-0.0.30.tgz#1fafbd8e8694d79280177b5eff167b0690838855" - integrity sha512-3hkHSHxVavoALcxpBqD4YwHuCmkBrvjq6PAGw93i6WCB+pnejBD5sFjVCiZZKCogh4kGObxxcwu53+3dyT/6IQ== +"@truffle/blockchain-utils@^0.0.25": + version "0.0.25" + resolved "https://registry.yarnpkg.com/@truffle/blockchain-utils/-/blockchain-utils-0.0.25.tgz#f4b320890113d282f25f1a1ecd65b94a8b763ac1" + integrity sha512-XA5m0BfAWtysy5ChHyiAf1fXbJxJXphKk+eZ9Rb9Twi6fn3Jg4gnHNwYXJacYFEydqT5vr2s4Ou812JHlautpw== + dependencies: + source-map-support "^0.5.19" + +"@truffle/blockchain-utils@^0.0.31": + version "0.0.31" + resolved "https://registry.yarnpkg.com/@truffle/blockchain-utils/-/blockchain-utils-0.0.31.tgz#0503d9fb2ce3e05c167c27294927f2f88d70a24d" + integrity sha512-BFo/nyxwhoHqPrqBQA1EAmSxeNnspGLiOCMa9pAL7WYSjyNBlrHaqCMO/F2O87G+NUK/u06E70DiSP2BFP0ZZw== -"@truffle/codec@^0.10.6": - version "0.10.6" - resolved "https://registry.yarnpkg.com/@truffle/codec/-/codec-0.10.6.tgz#38e85e098c1ac13892a095b6ed823c6ff5d85a2d" - integrity sha512-laKk5iL2Y9W0ndNnFAy2f3tuhwYV4PlQf1aZO3mlxk0QgCVkhS1G+p/b2xsJp75CI1PVVvEfGwjshQk8qL04wA== +"@truffle/codec@^0.11.1": + version "0.11.1" + resolved "https://registry.yarnpkg.com/@truffle/codec/-/codec-0.11.1.tgz#fbe54d7635bc896b3f746b87e15b8125242bc820" + integrity sha512-7Z+BStlCKws+mdpQUb3XGCYCkv80QUtmaLVTbl7/Abzimr63lsCTC/37GLWXeRJ1Vam9JYiZEmzaXUHCqJWsTg== dependencies: big.js "^5.2.2" bn.js "^5.1.3" @@ -1492,9 +1279,27 @@ lodash.sum "^4.0.2" semver "^7.3.4" utf8 "^3.0.0" - web3-utils "1.3.5" + web3-utils "1.3.6" -"@truffle/contract-schema@^3.4.1": +"@truffle/codec@^0.7.1": + version "0.7.1" + resolved "https://registry.yarnpkg.com/@truffle/codec/-/codec-0.7.1.tgz#2ef0fa40109040796afbebb8812c872122100ae4" + integrity sha512-mNd6KnW6J0UB1zafGBXDlTEbCMvWpmPAJmzv7aF/nAIaN/F8UePSCiQ1OTQP39Rprj6GFiCCaWVnBAwum6UGSg== + dependencies: + big.js "^5.2.2" + bn.js "^4.11.8" + borc "^2.1.2" + debug "^4.1.0" + lodash.clonedeep "^4.5.0" + lodash.escaperegexp "^4.1.2" + lodash.partition "^4.6.0" + lodash.sum "^4.0.2" + semver "^6.3.0" + source-map-support "^0.5.19" + utf8 "^3.0.0" + web3-utils "1.2.9" + +"@truffle/contract-schema@^3.2.5", "@truffle/contract-schema@^3.4.1": version "3.4.1" resolved "https://registry.yarnpkg.com/@truffle/contract-schema/-/contract-schema-3.4.1.tgz#13b404383d438b48960862022a20102970323666" integrity sha512-2gvu6gxJtbbI67H2Bwh2rBuej+1uCV3z4zKFzQZP00hjNoL+QfybrmBcOVB88PflBeEB+oUXuwQfDoKX3TXlnQ== @@ -1504,52 +1309,78 @@ debug "^4.3.1" "@truffle/contract@^4.3.8": - version "4.3.16" - resolved "https://registry.yarnpkg.com/@truffle/contract/-/contract-4.3.16.tgz#c28b14a0c258f0bd6e0f739f7cd081a75270bbd5" - integrity sha512-/GhDFu8pu1TMVev5WTxQj87Vo8Di5Uo0LXvdV7ESdUbEIzMlm9pjfkf2uWg8Jx2aSBGgfCeLXw8GVScBk9OjlA== + version "4.3.21" + resolved "https://registry.yarnpkg.com/@truffle/contract/-/contract-4.3.21.tgz#a90a363564ea63ff3a42550cb0b97ffdd4972880" + integrity sha512-J4nYQVoOL29G7Rg2rmbHbsyQUx/Oj41HBHQOafjltnxppYuFk8OPW0EBm1o7gOAkfgFy4oJPhOVFucZ6JqY+GQ== dependencies: - "@truffle/blockchain-utils" "^0.0.30" + "@ensdomains/ensjs" "^2.0.1" + "@truffle/blockchain-utils" "^0.0.31" "@truffle/contract-schema" "^3.4.1" - "@truffle/debug-utils" "^5.0.16" + "@truffle/debug-utils" "^5.1.1" "@truffle/error" "^0.0.14" - "@truffle/interface-adapter" "^0.4.23" + "@truffle/interface-adapter" "^0.5.1" bignumber.js "^7.2.1" - ethereum-ens "^0.8.0" ethers "^4.0.32" - web3 "1.3.5" - web3-core-helpers "1.3.5" - web3-core-promievent "1.3.5" - web3-eth-abi "1.3.5" - web3-utils "1.3.5" - -"@truffle/debug-utils@^5.0.16": - version "5.0.16" - resolved "https://registry.yarnpkg.com/@truffle/debug-utils/-/debug-utils-5.0.16.tgz#a933df7f392a6e519208f23287b14b4deb2bdec8" - integrity sha512-1I6DYs/eGeeTPXi+S3720HCzb9bsG5X6Oxjh2K/tlV0GeDnsmr+PN+ODFpbpa/ZtY0W07+5vBUUo+wzNlbOZrA== - dependencies: - "@truffle/codec" "^0.10.6" + web3 "1.3.6" + web3-core-helpers "1.3.6" + web3-core-promievent "1.3.6" + web3-eth-abi "1.3.6" + web3-utils "1.3.6" + +"@truffle/debug-utils@^4.2.9": + version "4.2.14" + resolved "https://registry.yarnpkg.com/@truffle/debug-utils/-/debug-utils-4.2.14.tgz#28431691bc3a96bad19e31733d957ac79059d4e7" + integrity sha512-g5UTX2DPTzrjRjBJkviGI2IrQRTTSvqjmNWCNZNXP+vgQKNxL9maLZhQ6oA3BuuByVW/kusgYeXt8+W1zynC8g== + dependencies: + "@truffle/codec" "^0.7.1" + "@trufflesuite/chromafi" "^2.2.1" + chalk "^2.4.2" + debug "^4.1.0" + highlight.js "^9.15.8" + highlightjs-solidity "^1.0.18" + +"@truffle/debug-utils@^5.1.1": + version "5.1.1" + resolved "https://registry.yarnpkg.com/@truffle/debug-utils/-/debug-utils-5.1.1.tgz#7dd5960a4042bad0588074ebb95b73a44fe1f859" + integrity sha512-vp/rutosfUV0kdHPfXO+OdzmfmSq/phgXhwjCXn53ePivCemd2WCP4YNo8wO9erhgnYPy5z+tU4tLtIEx9YU0Q== + dependencies: + "@truffle/codec" "^0.11.1" "@trufflesuite/chromafi" "^2.2.2" bn.js "^5.1.3" chalk "^2.4.2" debug "^4.3.1" highlight.js "^10.4.0" - highlightjs-solidity "^1.0.22" + highlightjs-solidity "^1.1.1" + +"@truffle/error@^0.0.11": + version "0.0.11" + resolved "https://registry.yarnpkg.com/@truffle/error/-/error-0.0.11.tgz#2789c0042d7e796dcbb840c7a9b5d2bcd8e0e2d8" + integrity sha512-ju6TucjlJkfYMmdraYY/IBJaFb+Sa+huhYtOoyOJ+G29KcgytUVnDzKGwC7Kgk6IsxQMm62Mc1E0GZzFbGGipw== "@truffle/error@^0.0.14": version "0.0.14" resolved "https://registry.yarnpkg.com/@truffle/error/-/error-0.0.14.tgz#59683b5407bede7bddf16d80dc5592f9c5e5fa05" integrity sha512-utJx+SZYoMqk8wldQG4gCVKhV8GwMJbWY7sLXFT/D8wWZTnE2peX7URFJh/cxkjTRCO328z1s2qewkhyVsu2HA== -"@truffle/interface-adapter@^0.4.23": - version "0.4.23" - resolved "https://registry.yarnpkg.com/@truffle/interface-adapter/-/interface-adapter-0.4.23.tgz#9b474bb0455df1f02d72bf5a08f3d70b6fef875d" - integrity sha512-mfpwY25Apx36WHHNJMNHWyDQVFZoZYNQ43rOwr/n+5gAMxke7+D7+IR9UW4kuO/Jp0+2848UxMdRV+oqm017kQ== +"@truffle/interface-adapter@^0.4.16": + version "0.4.24" + resolved "https://registry.yarnpkg.com/@truffle/interface-adapter/-/interface-adapter-0.4.24.tgz#5d6d4f10c756e967f19ac2ad1620d11d25c034bb" + integrity sha512-2Zho4dJbm/XGwNleY7FdxcjXiAR3SzdGklgrAW4N/YVmltaJv6bT56ACIbPNN6AdzkTSTO65OlsB/63sfSa/VA== dependencies: bn.js "^5.1.3" ethers "^4.0.32" - web3 "1.3.5" + web3 "1.3.6" -"@trufflesuite/chromafi@^2.2.2": +"@truffle/interface-adapter@^0.5.1": + version "0.5.1" + resolved "https://registry.yarnpkg.com/@truffle/interface-adapter/-/interface-adapter-0.5.1.tgz#14c16e59dab5babc3860e9ccaeb350ffa76a8cba" + integrity sha512-Uvd7em/9DKb0PAMSklvlvbfHNNm9CiXKxXJT5VUmV9SlAe+C/vbUIiuIv8lStdX1PdF4KkO/K5rBJDvmDmXOyw== + dependencies: + bn.js "^5.1.3" + ethers "^4.0.32" + web3 "1.3.6" + +"@trufflesuite/chromafi@^2.2.1", "@trufflesuite/chromafi@^2.2.2": version "2.2.2" resolved "https://registry.yarnpkg.com/@trufflesuite/chromafi/-/chromafi-2.2.2.tgz#d3fc507aa8504faffc50fb892cedcfe98ff57f77" integrity sha512-mItQwVBsb8qP/vaYHQ1kDt2vJLhjoEXJptT6y6fJGvFophMFhOI/NsTVUa0nJL1nyMeFiS6hSYuNVdpQZzB1gA== @@ -1607,15 +1438,15 @@ dependencies: "@types/chai" "*" -"@types/chai@*", "@types/chai@^4.2.14": - version "4.2.18" - resolved "https://registry.yarnpkg.com/@types/chai/-/chai-4.2.18.tgz#0c8e298dbff8205e2266606c1ea5fbdba29b46e4" - integrity sha512-rS27+EkB/RE1Iz3u0XtVL5q36MGDWbgYe7zWiodyKNUnthxY0rukK5V36eiUCtCisB7NN8zKYH6DO2M37qxFEQ== +"@types/chai@*", "@types/chai@^4.2.0", "@types/chai@^4.2.14": + version "4.2.19" + resolved "https://registry.yarnpkg.com/@types/chai/-/chai-4.2.19.tgz#80f286b515897413c7a35bdda069cc80f2344233" + integrity sha512-jRJgpRBuY+7izT7/WNXP/LsMO9YonsstuL+xuvycDyESpoDoIAsMd7suwpB4h9oEWB+ZlPTqJJ8EHomzNhwTPQ== "@types/concat-stream@^1.6.0": - version "1.6.0" - resolved "https://registry.yarnpkg.com/@types/concat-stream/-/concat-stream-1.6.0.tgz#394dbe0bb5fee46b38d896735e8b68ef2390d00d" - integrity sha1-OU2+C7X+5Gs42JZzXoto7yOQ0A0= + version "1.6.1" + resolved "https://registry.yarnpkg.com/@types/concat-stream/-/concat-stream-1.6.1.tgz#24bcfc101ecf68e886aaedce60dfd74b632a1b74" + integrity sha512-eHE4cQPoj6ngxBZMvVf6Hw7Mh4jMW4U9lpGmS5GBPB9RYxlFg+CHaVN7ErNY4W9XfLIEn20b4VDYaIrbq0q4uA== dependencies: "@types/node" "*" @@ -1653,13 +1484,13 @@ "@types/istanbul-lib-coverage" "*" "@types/istanbul-reports@^3.0.0": - version "3.0.0" - resolved "https://registry.yarnpkg.com/@types/istanbul-reports/-/istanbul-reports-3.0.0.tgz#508b13aa344fa4976234e75dddcc34925737d821" - integrity sha512-nwKNbvnwJ2/mndE9ItP/zc2TCzw6uuodnF4EHYWD+gCQDVBuRQL5UzbZD0/ezy1iKsFU2ZQiDqg4M9dN4+wZgA== + version "3.0.1" + resolved "https://registry.yarnpkg.com/@types/istanbul-reports/-/istanbul-reports-3.0.1.tgz#9153fe98bba2bd565a63add9436d6f0d7f8468ff" + integrity sha512-c3mAZEuK0lvBp8tmuL74XRKn1+y2dcwOUpH7x4WrF6gk1GIgiluDRgMYQtw2OFcBvAJWlt6ASU3tSqxp0Uu0Aw== dependencies: "@types/istanbul-lib-report" "*" -"@types/json-schema@^7.0.3": +"@types/json-schema@^7.0.7": version "7.0.7" resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.7.tgz#98a993516c859eb0d5c4c8f098317a9ea68db9ad" integrity sha512-cxWFQVseBm6O9Gbw1IWb8r6OS4OhSt3hPZLkFApLjM8TEXROBuQGLAH2i2gZpcXdLBIrpXuTDhH7Vbm1iXmNGA== @@ -1710,9 +1541,9 @@ form-data "^3.0.0" "@types/node@*": - version "15.3.0" - resolved "https://registry.yarnpkg.com/@types/node/-/node-15.3.0.tgz#d6fed7d6bc6854306da3dea1af9f874b00783e26" - integrity sha512-8/bnjSZD86ZfpBsDlCIkNXIvm+h6wi9g7IqL+kmFkQ+Wvu3JrasgLElfiPgoo8V8vVfnEi0QVS12gbl94h9YsQ== + version "15.12.4" + resolved "https://registry.yarnpkg.com/@types/node/-/node-15.12.4.tgz#e1cf817d70a1e118e81922c4ff6683ce9d422e26" + integrity sha512-zrNj1+yqYF4WskCMOHwN+w9iuD12+dGm0rQ35HLl9/Ouuq52cEtd0CH9qMgrdNmi5ejC1/V7vKEXYubB+65DkA== "@types/node@^10.0.3": version "10.17.60" @@ -1720,14 +1551,14 @@ integrity sha512-F0KIgDJfy2nA3zMLmWGKxcH2ZVEtCZXHHdOQs2gSaQ27+lNeEfGxzkIw90aXswATX7AZ33tahPbzy6KAfUreVw== "@types/node@^12.12.6": - version "12.20.13" - resolved "https://registry.yarnpkg.com/@types/node/-/node-12.20.13.tgz#e743bae112bd779ac9650f907197dd2caa7f0364" - integrity sha512-1x8W5OpxPq+T85OUsHRP6BqXeosKmeXRtjoF39STcdf/UWLqUsoehstZKOi0CunhVqHG17AyZgpj20eRVooK6A== + version "12.20.15" + resolved "https://registry.yarnpkg.com/@types/node/-/node-12.20.15.tgz#10ee6a6a3f971966fddfa3f6e89ef7a73ec622df" + integrity sha512-F6S4Chv4JicJmyrwlDkxUdGNSplsQdGwp1A0AJloEVDirWdZOAiRHhovDlsFkKUrquUXhz1imJhXHsf59auyAg== "@types/node@^14.14.22": - version "14.14.45" - resolved "https://registry.yarnpkg.com/@types/node/-/node-14.14.45.tgz#ec2dfb5566ff814d061aef7e141575aedba245cf" - integrity sha512-DssMqTV9UnnoxDWu959sDLZzfvqCF0qDNRjaWeYSui9xkFe61kKo4l1TWNTQONpuXEm+gLMRvdlzvNHBamzmEw== + version "14.17.3" + resolved "https://registry.yarnpkg.com/@types/node/-/node-14.17.3.tgz#6d327abaa4be34a74e421ed6409a0ae2f47f4c3d" + integrity sha512-e6ZowgGJmTuXa3GyaPbTGxX17tnThl2aSSizrFthQ7m9uLGZBXiGhgE55cjRZTF5kjZvYn9EOPOMljdjwbflxw== "@types/node@^8.0.0": version "8.10.66" @@ -1747,11 +1578,16 @@ "@types/node" "*" "@types/prettier@^2.1.1": - version "2.2.3" - resolved "https://registry.yarnpkg.com/@types/prettier/-/prettier-2.2.3.tgz#ef65165aea2924c9359205bf748865b8881753c0" - integrity sha512-PijRCG/K3s3w1We6ynUKdxEc5AcuuH3NBmMDP8uvKVp6X43UY7NQlTzczakXP3DJR0F4dfNQIGjU2cUeRYs2AA== + version "2.3.0" + resolved "https://registry.yarnpkg.com/@types/prettier/-/prettier-2.3.0.tgz#2e8332cc7363f887d32ec5496b207d26ba8052bb" + integrity sha512-hkc1DATxFLQo4VxPDpMH1gCkPpBbpOoJ/4nhuXw4n63/0R6bCpQECj4+K226UJ4JO/eJQz+1mC2I7JsWanAdQw== + +"@types/qs@^6.2.31": + version "6.9.7" + resolved "https://registry.yarnpkg.com/@types/qs/-/qs-6.9.7.tgz#63bb7d067db107cc1e457c303bc25d511febf6cb" + integrity sha512-FGa1F62FT09qcrueBA6qYTrJPVDzah9a+493+o2PCXsesWHIn27G98TsSMs3WPNbZIEj4+VJf6saSFpvD+3Zsw== -"@types/qs@^6.2.31", "@types/qs@^6.9.4": +"@types/qs@^6.9.4": version "6.9.6" resolved "https://registry.yarnpkg.com/@types/qs/-/qs-6.9.6.tgz#df9c3c8b31a247ec315e6996566be3171df4b3b1" integrity sha512-0/HnwIfW4ki2D8L8c9GVcG5I72s9jP5GSLVF0VIXDW00kmIpA6O33G7a8n59Tmh7Nz0WUC3rSb7PTY/sdW2JzA== @@ -1779,11 +1615,11 @@ "@types/sinon" "*" "@types/sinon@*": - version "10.0.0" - resolved "https://registry.yarnpkg.com/@types/sinon/-/sinon-10.0.0.tgz#eecc3847af03d45ffe53d55aaaaf6ecb28b5e584" - integrity sha512-jDZ55oCKxqlDmoTBBbBBEx+N8ZraUVhggMZ9T5t+6/Dh8/4NiOjSUfpLrPiEwxQDlAe3wpAkoXhWvE6LibtsMQ== + version "10.0.2" + resolved "https://registry.yarnpkg.com/@types/sinon/-/sinon-10.0.2.tgz#f360d2f189c0fd433d14aeb97b9d705d7e4cc0e4" + integrity sha512-BHn8Bpkapj8Wdfxvh2jWIUoaYB/9/XhsL0oOvBfRagJtKlSl9NWPcFOz2lRukI9szwGxFtYZCTejJSqsGDbdmw== dependencies: - "@sinonjs/fake-timers" "^7.0.4" + "@sinonjs/fake-timers" "^7.1.0" "@types/stack-utils@^2.0.0": version "2.0.0" @@ -1808,81 +1644,80 @@ resolved "https://registry.yarnpkg.com/@types/yargs-parser/-/yargs-parser-20.2.0.tgz#dd3e6699ba3237f0348cd085e4698780204842f9" integrity sha512-37RSHht+gzzgYeobbG+KWryeAW8J33Nhr69cjTqSYymXVZEN9NbRYWoYlRtDhHKPVT1FyNKwaTPC1NynKZpzRA== -"@types/yargs@^15.0.0": - version "15.0.13" - resolved "https://registry.yarnpkg.com/@types/yargs/-/yargs-15.0.13.tgz#34f7fec8b389d7f3c1fd08026a5763e072d3c6dc" - integrity sha512-kQ5JNTrbDv3Rp5X2n/iUu37IJBDU2gsZ5R/g1/KHOOEc5IKfUFjXT6DENPGduh08I/pamwtEq4oul7gUqKTQDQ== +"@types/yargs@^16.0.0": + version "16.0.3" + resolved "https://registry.yarnpkg.com/@types/yargs/-/yargs-16.0.3.tgz#4b6d35bb8e680510a7dc2308518a80ee1ef27e01" + integrity sha512-YlFfTGS+zqCgXuXNV26rOIeETOkXnGQXP/pjjL9P0gO/EP9jTmc7pUBhx+jVEIxpq41RX33GQ7N3DzOSfZoglQ== dependencies: "@types/yargs-parser" "*" "@typescript-eslint/eslint-plugin@^4.8.2": - version "4.23.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-4.23.0.tgz#29d3c9c81f6200b1fd6d8454cfb007ba176cde80" - integrity sha512-tGK1y3KIvdsQEEgq6xNn1DjiFJtl+wn8JJQiETtCbdQxw1vzjXyAaIkEmO2l6Nq24iy3uZBMFQjZ6ECf1QdgGw== + version "4.28.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-4.28.0.tgz#1a66f03b264844387beb7dc85e1f1d403bd1803f" + integrity sha512-KcF6p3zWhf1f8xO84tuBailV5cN92vhS+VT7UJsPzGBm9VnQqfI9AsiMUFUCYHTYPg1uCCo+HyiDnpDuvkAMfQ== dependencies: - "@typescript-eslint/experimental-utils" "4.23.0" - "@typescript-eslint/scope-manager" "4.23.0" - debug "^4.1.1" + "@typescript-eslint/experimental-utils" "4.28.0" + "@typescript-eslint/scope-manager" "4.28.0" + debug "^4.3.1" functional-red-black-tree "^1.0.1" - lodash "^4.17.15" - regexpp "^3.0.0" - semver "^7.3.2" - tsutils "^3.17.1" - -"@typescript-eslint/experimental-utils@4.23.0": - version "4.23.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/experimental-utils/-/experimental-utils-4.23.0.tgz#f2059434cd6e5672bfeab2fb03b7c0a20622266f" - integrity sha512-WAFNiTDnQfrF3Z2fQ05nmCgPsO5o790vOhmWKXbbYQTO9erE1/YsFot5/LnOUizLzU2eeuz6+U/81KV5/hFTGA== - dependencies: - "@types/json-schema" "^7.0.3" - "@typescript-eslint/scope-manager" "4.23.0" - "@typescript-eslint/types" "4.23.0" - "@typescript-eslint/typescript-estree" "4.23.0" - eslint-scope "^5.0.0" - eslint-utils "^2.0.0" + regexpp "^3.1.0" + semver "^7.3.5" + tsutils "^3.21.0" + +"@typescript-eslint/experimental-utils@4.28.0": + version "4.28.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/experimental-utils/-/experimental-utils-4.28.0.tgz#13167ed991320684bdc23588135ae62115b30ee0" + integrity sha512-9XD9s7mt3QWMk82GoyUpc/Ji03vz4T5AYlHF9DcoFNfJ/y3UAclRsfGiE2gLfXtyC+JRA3trR7cR296TEb1oiQ== + dependencies: + "@types/json-schema" "^7.0.7" + "@typescript-eslint/scope-manager" "4.28.0" + "@typescript-eslint/types" "4.28.0" + "@typescript-eslint/typescript-estree" "4.28.0" + eslint-scope "^5.1.1" + eslint-utils "^3.0.0" "@typescript-eslint/parser@^4.8.2": - version "4.23.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-4.23.0.tgz#239315d38e42e852bef43a4b0b01bef78f78911c" - integrity sha512-wsvjksHBMOqySy/Pi2Q6UuIuHYbgAMwLczRl4YanEPKW5KVxI9ZzDYh3B5DtcZPQTGRWFJrfcbJ6L01Leybwug== + version "4.28.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-4.28.0.tgz#2404c16751a28616ef3abab77c8e51d680a12caa" + integrity sha512-7x4D22oPY8fDaOCvkuXtYYTQ6mTMmkivwEzS+7iml9F9VkHGbbZ3x4fHRwxAb5KeuSkLqfnYjs46tGx2Nour4A== dependencies: - "@typescript-eslint/scope-manager" "4.23.0" - "@typescript-eslint/types" "4.23.0" - "@typescript-eslint/typescript-estree" "4.23.0" - debug "^4.1.1" + "@typescript-eslint/scope-manager" "4.28.0" + "@typescript-eslint/types" "4.28.0" + "@typescript-eslint/typescript-estree" "4.28.0" + debug "^4.3.1" -"@typescript-eslint/scope-manager@4.23.0": - version "4.23.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-4.23.0.tgz#8792ef7eacac122e2ec8fa2d30a59b8d9a1f1ce4" - integrity sha512-ZZ21PCFxPhI3n0wuqEJK9omkw51wi2bmeKJvlRZPH5YFkcawKOuRMQMnI8mH6Vo0/DoHSeZJnHiIx84LmVQY+w== +"@typescript-eslint/scope-manager@4.28.0": + version "4.28.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-4.28.0.tgz#6a3009d2ab64a30fc8a1e257a1a320067f36a0ce" + integrity sha512-eCALCeScs5P/EYjwo6se9bdjtrh8ByWjtHzOkC4Tia6QQWtQr3PHovxh3TdYTuFcurkYI4rmFsRFpucADIkseg== dependencies: - "@typescript-eslint/types" "4.23.0" - "@typescript-eslint/visitor-keys" "4.23.0" + "@typescript-eslint/types" "4.28.0" + "@typescript-eslint/visitor-keys" "4.28.0" -"@typescript-eslint/types@4.23.0": - version "4.23.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-4.23.0.tgz#da1654c8a5332f4d1645b2d9a1c64193cae3aa3b" - integrity sha512-oqkNWyG2SLS7uTWLZf6Sr7Dm02gA5yxiz1RP87tvsmDsguVATdpVguHr4HoGOcFOpCvx9vtCSCyQUGfzq28YCw== +"@typescript-eslint/types@4.28.0": + version "4.28.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-4.28.0.tgz#a33504e1ce7ac51fc39035f5fe6f15079d4dafb0" + integrity sha512-p16xMNKKoiJCVZY5PW/AfILw2xe1LfruTcfAKBj3a+wgNYP5I9ZEKNDOItoRt53p4EiPV6iRSICy8EPanG9ZVA== -"@typescript-eslint/typescript-estree@4.23.0": - version "4.23.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-4.23.0.tgz#0753b292097523852428a6f5a1aa8ccc1aae6cd9" - integrity sha512-5Sty6zPEVZF5fbvrZczfmLCOcby3sfrSPu30qKoY1U3mca5/jvU5cwsPb/CO6Q3ByRjixTMIVsDkqwIxCf/dMw== +"@typescript-eslint/typescript-estree@4.28.0": + version "4.28.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-4.28.0.tgz#e66d4e5aa2ede66fec8af434898fe61af10c71cf" + integrity sha512-m19UQTRtxMzKAm8QxfKpvh6OwQSXaW1CdZPoCaQuLwAq7VZMNuhJmZR4g5281s2ECt658sldnJfdpSZZaxUGMQ== dependencies: - "@typescript-eslint/types" "4.23.0" - "@typescript-eslint/visitor-keys" "4.23.0" - debug "^4.1.1" - globby "^11.0.1" + "@typescript-eslint/types" "4.28.0" + "@typescript-eslint/visitor-keys" "4.28.0" + debug "^4.3.1" + globby "^11.0.3" is-glob "^4.0.1" - semver "^7.3.2" - tsutils "^3.17.1" + semver "^7.3.5" + tsutils "^3.21.0" -"@typescript-eslint/visitor-keys@4.23.0": - version "4.23.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-4.23.0.tgz#7215cc977bd3b4ef22467b9023594e32f9e4e455" - integrity sha512-5PNe5cmX9pSifit0H+nPoQBXdbNzi5tOEec+3riK+ku4e3er37pKxMKDH5Ct5Y4fhWxcD4spnlYjxi9vXbSpwg== +"@typescript-eslint/visitor-keys@4.28.0": + version "4.28.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-4.28.0.tgz#255c67c966ec294104169a6939d96f91c8a89434" + integrity sha512-PjJyTWwrlrvM5jazxYF5ZPs/nl0kHDZMVbuIcbpawVXaDPelp3+S9zpOz5RmVUfS/fD5l5+ZXNKnWhNYjPzCvw== dependencies: - "@typescript-eslint/types" "4.23.0" + "@typescript-eslint/types" "4.28.0" eslint-visitor-keys "^2.0.0" "@uniswap/sdk-core@^1.0.11": @@ -1996,11 +1831,28 @@ accepts@~1.3.7: mime-types "~2.1.24" negotiator "0.6.2" +acorn-dynamic-import@^2.0.0: + version "2.0.2" + resolved "https://registry.yarnpkg.com/acorn-dynamic-import/-/acorn-dynamic-import-2.0.2.tgz#c752bd210bef679501b6c6cb7fc84f8f47158cc4" + integrity sha1-x1K9IQvvZ5UBtsbLf8hPj0cVjMQ= + dependencies: + acorn "^4.0.3" + acorn-jsx@^5.0.0, acorn-jsx@^5.3.1: version "5.3.1" resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.1.tgz#fc8661e11b7ac1539c47dbfea2e72b3af34d267b" integrity sha512-K0Ptm/47OKfQRpNQ2J/oIN/3QYiK6FwW+eJbILhsdxh2WTLdl+30o8aGdTbm5JbffpFFAg/g+zi1E+jvJha5ng== +acorn@^4.0.3: + version "4.0.13" + resolved "https://registry.yarnpkg.com/acorn/-/acorn-4.0.13.tgz#105495ae5361d697bd195c825192e1ad7f253787" + integrity sha1-EFSVrlNh1pe9GVyCUZLhrX8lN4c= + +acorn@^5.0.0: + version "5.7.4" + resolved "https://registry.yarnpkg.com/acorn/-/acorn-5.7.4.tgz#3e8d8a9947d0599a1796d10225d7432f4a4acf5e" + integrity sha512-1D++VG7BhrtvQpNbBzovKNc1FLGGEE/oGe7b9xJm/RFHMBeUaUGpluV9RLjZa47YFdPcDAenEYuq9pQPcMdLJg== + acorn@^6.0.7: version "6.4.2" resolved "https://registry.yarnpkg.com/acorn/-/acorn-6.4.2.tgz#35866fd710528e92de10cf06016498e47e39e1e6" @@ -2041,7 +1893,22 @@ aggregate-error@^3.0.0: 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: +ajv-keywords@^3.1.0: + version "3.5.2" + resolved "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-3.5.2.tgz#31f29da5ab6e00d1c2d329acf7b5929614d5014d" + integrity sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ== + +ajv@^5.2.2: + version "5.5.2" + resolved "https://registry.yarnpkg.com/ajv/-/ajv-5.5.2.tgz#73b5eeca3fab653e3d3f9422b341ad42205dc965" + integrity sha1-c7Xuyj+rZT49P5Qis0GtQiBdyWU= + dependencies: + co "^4.6.0" + fast-deep-equal "^1.0.0" + fast-json-stable-stringify "^2.0.0" + json-schema-traverse "^0.3.0" + +ajv@^6.1.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.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4" integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g== @@ -2052,15 +1919,24 @@ ajv@^6.10.0, ajv@^6.10.2, ajv@^6.12.3, ajv@^6.12.4, ajv@^6.6.1, ajv@^6.9.1: uri-js "^4.2.2" ajv@^8.0.1: - version "8.4.0" - resolved "https://registry.yarnpkg.com/ajv/-/ajv-8.4.0.tgz#48984fdb2ce225cab15795f0772a8d85669075e4" - integrity sha512-7QD2l6+KBSLwf+7MuYocbWvRPdOu63/trReTLu2KFwkgctnub1auoF+Y1WYcm09CTM7quuscrzqmASaLHC/K4Q== + version "8.6.0" + resolved "https://registry.yarnpkg.com/ajv/-/ajv-8.6.0.tgz#60cc45d9c46a477d80d92c48076d972c342e5720" + integrity sha512-cnUG4NSBiM4YFBxgZIj/In3/6KX+rQ2l2YPRVcvAMQGWEPKuXoPIhxzwqh31jA3IPbI4qEOp/5ILI4ynioXsGQ== dependencies: fast-deep-equal "^3.1.1" json-schema-traverse "^1.0.0" require-from-string "^2.0.2" uri-js "^4.2.2" +align-text@^0.1.1, align-text@^0.1.3: + version "0.1.4" + resolved "https://registry.yarnpkg.com/align-text/-/align-text-0.1.4.tgz#0cd90a561093f35d0a99256c22b7069433fad117" + integrity sha1-DNkKVhCT810KmSVsIrcGlDP60Rc= + dependencies: + kind-of "^3.0.2" + longest "^1.0.1" + repeat-string "^1.5.2" + ansi-colors@3.2.3: version "3.2.3" resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-3.2.3.tgz#57d35b8686e851e2cc04c403f1c00203976a1813" @@ -2133,12 +2009,38 @@ ansi-styles@^4.0.0, ansi-styles@^4.1.0: dependencies: color-convert "^2.0.1" +ansi-styles@^5.0.0: + version "5.2.0" + resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-5.2.0.tgz#07449690ad45777d1924ac2abb2fc8895dba836b" + integrity sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA== + antlr4@4.7.1: version "4.7.1" resolved "https://registry.yarnpkg.com/antlr4/-/antlr4-4.7.1.tgz#69984014f096e9e775f53dd9744bf994d8959773" integrity sha512-haHyTW7Y9joE5MVs37P2lNYfU2RWBLfcRDD8OWldcdZm5TiCE91B5Xl1oWSwiDUSd4rlExpt2pu1fksYQjRBYQ== -anymatch@~3.1.1: +antlr4ts@^0.5.0-alpha.4: + version "0.5.0-alpha.4" + resolved "https://registry.yarnpkg.com/antlr4ts/-/antlr4ts-0.5.0-alpha.4.tgz#71702865a87478ed0b40c0709f422cf14d51652a" + integrity sha512-WPQDt1B74OfPv/IMS2ekXAKkTZIHl88uMetg6q3OTqgFxZ/dxDXI0EWLyZid/1Pe6hTftyg5N7gel5wNAGxXyQ== + +anymatch@^1.3.0: + version "1.3.2" + resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-1.3.2.tgz#553dcb8f91e3c889845dfdba34c77721b90b9d7a" + integrity sha512-0XNayC8lTHQ2OI8aljNCN3sSx6hsr/1+rlcDAotXJR7C1oZZHCNsfpbKwMjRA3Uqb5tF1Rae2oloTr4xpq+WjA== + dependencies: + micromatch "^2.1.5" + normalize-path "^2.0.0" + +anymatch@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-2.0.0.tgz#bcb24b4f37934d9aa7ac17b4adaf89e7c76ef2eb" + integrity sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw== + dependencies: + micromatch "^3.1.4" + normalize-path "^2.1.1" + +anymatch@~3.1.1, anymatch@~3.1.2: version "3.1.2" resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.2.tgz#c0557c096af32f106198f4f4e2a383537e378716" integrity sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg== @@ -2158,12 +2060,19 @@ argparse@^1.0.7: dependencies: sprintf-js "~1.0.2" +arr-diff@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/arr-diff/-/arr-diff-2.0.0.tgz#8f3b827f955a8bd669697e4a4256ac3ceae356cf" + integrity sha1-jzuCf5Vai9ZpaX5KQlasPOrjVs8= + dependencies: + arr-flatten "^1.0.1" + arr-diff@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/arr-diff/-/arr-diff-4.0.0.tgz#d6461074febfec71e7e15235761a329a5dc7c520" integrity sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA= -arr-flatten@^1.1.0: +arr-flatten@^1.0.1, arr-flatten@^1.1.0: version "1.1.0" resolved "https://registry.yarnpkg.com/arr-flatten/-/arr-flatten-1.1.0.tgz#36048bbff4e7b47e136644316c99669ea5ae91f1" integrity sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg== @@ -2187,11 +2096,6 @@ array-back@^2.0.0: dependencies: typical "^2.6.1" -array-filter@^1.0.0: - version "1.0.0" - resolved "https://registry.yarnpkg.com/array-filter/-/array-filter-1.0.0.tgz#baf79e62e6ef4c2a4c0b831232daffec251f9d83" - integrity sha1-uveeYubvTCpMC4MSMtr/7CUfnYM= - array-flatten@1.1.1: version "1.1.1" resolved "https://registry.yarnpkg.com/array-flatten/-/array-flatten-1.1.1.tgz#9a5f699051b1e7073328f2a008968b64ea2955d2" @@ -2218,6 +2122,11 @@ array-uniq@^1.0.3: resolved "https://registry.yarnpkg.com/array-uniq/-/array-uniq-1.0.3.tgz#af6ac877a25cc7f74e058894753858dfdb24fdb6" integrity sha1-r2rId6Jcx/dOBYiUdThY39sk/bY= +array-unique@^0.2.1: + version "0.2.1" + resolved "https://registry.yarnpkg.com/array-unique/-/array-unique-0.2.1.tgz#a1d97ccafcbc2625cc70fadceb36a50c58b01a53" + integrity sha1-odl8yvy8JiXMcPrc6zalDFiwGlM= + array-unique@^0.3.2: version "0.3.2" resolved "https://registry.yarnpkg.com/array-unique/-/array-unique-0.3.2.tgz#a894b75d4bc4f6cd679ef3244a9fd8f46ae2d428" @@ -2259,6 +2168,14 @@ assert-plus@1.0.0, assert-plus@^1.0.0: resolved "https://registry.yarnpkg.com/assert-plus/-/assert-plus-1.0.0.tgz#f12e0f3c5d77b0b1cdd9146942e4e96c1e4dd525" integrity sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU= +assert@^1.1.1: + version "1.5.0" + resolved "https://registry.yarnpkg.com/assert/-/assert-1.5.0.tgz#55c109aaf6e0aefdb3dc4b71240c70bf574b18eb" + integrity sha512-EDsgawzwoun2CZkCgtxJbv392v4nbk9XDD06zI+kQYoBM/3RBWLlEyJARDOmhAAosBjWACEkKL6S+lIZtcAubA== + dependencies: + object-assign "^4.1.1" + util "0.10.3" + assertion-error@^1.1.0: version "1.1.0" resolved "https://registry.yarnpkg.com/assertion-error/-/assertion-error-1.1.0.tgz#e60b6b0e8f301bd97e5375215bda406c85118c0b" @@ -2284,6 +2201,11 @@ astral-regex@^2.0.0: resolved "https://registry.yarnpkg.com/astral-regex/-/astral-regex-2.0.0.tgz#483143c567aeed4785759c0865786dc77d7d2e31" integrity sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ== +async-each@^1.0.0, async-each@^1.0.1: + version "1.0.3" + resolved "https://registry.yarnpkg.com/async-each/-/async-each-1.0.3.tgz#b727dbf87d7651602f06f4d4ac387f47d91b0cbf" + integrity sha512-z/WhQ5FPySLdvREByI2vZiTWwCnF0moMJ1hK9YQwDTHKh6I7/uSckMetoRGb5UBZPC1z0jlw+n/XCgjeH7y1AQ== + async-eventemitter@^0.2.2, async-eventemitter@^0.2.4: version "0.2.4" resolved "https://registry.yarnpkg.com/async-eventemitter/-/async-eventemitter-0.2.4.tgz#f5e7c8ca7d3e46aab9ec40a292baf686a0bafaca" @@ -2331,11 +2253,9 @@ atob@^2.1.2: integrity sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg== available-typed-arrays@^1.0.2: - version "1.0.2" - resolved "https://registry.yarnpkg.com/available-typed-arrays/-/available-typed-arrays-1.0.2.tgz#6b098ca9d8039079ee3f77f7b783c4480ba513f5" - integrity sha512-XWX3OX8Onv97LMk/ftVyBibpGwY5a8SmuxZPzeOxqmuEqUCOM9ZE+uIaD1VNJ5QnvU2UQusvmKbuM1FR8QWGfQ== - dependencies: - array-filter "^1.0.0" + version "1.0.4" + resolved "https://registry.yarnpkg.com/available-typed-arrays/-/available-typed-arrays-1.0.4.tgz#9e0ae84ecff20caae6a94a1c3bc39b955649b7a9" + integrity sha512-SA5mXJWrId1TaQjfxUYghbqQ/hYioKmLJvPJyDuYRtXXenFNMjj4hSSt1Cf1xsuXSXrtxrVC5Ot4eU6cOtBDdA== aws-sign2@~0.7.0: version "0.7.0" @@ -3096,7 +3016,7 @@ base-x@^3.0.2, base-x@^3.0.8: dependencies: safe-buffer "^5.0.1" -base64-js@^1.3.1: +base64-js@^1.0.2, base64-js@^1.3.1: version "1.5.1" resolved "https://registry.yarnpkg.com/base64-js/-/base64-js-1.5.1.tgz#1b1b440160a5bf7ad40b650f095963481903930a" integrity sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA== @@ -3121,11 +3041,16 @@ bcrypt-pbkdf@^1.0.0: dependencies: tweetnacl "^0.14.3" -bech32@1.1.4: +bech32@1.1.4, bech32@^1.1.3: version "1.1.4" resolved "https://registry.yarnpkg.com/bech32/-/bech32-1.1.4.tgz#e38c9f37bf179b8eb16ae3a772b40c356d4832e9" integrity sha512-s0IrSOzLlbvX7yp4WBfPITzpAU8sqQcpsmwXDiKwrG4r491vwCO/XpejasRNl0piBMe/DvP4Tz0mIS/X1DPJBQ== +big-integer@1.6.36: + version "1.6.36" + resolved "https://registry.yarnpkg.com/big-integer/-/big-integer-1.6.36.tgz#78631076265d4ae3555c04f85e7d9d2f3a071a36" + integrity sha512-t70bfa7HYEA1D9idDbmuv7YbsbVkQ+Hp+8KFSul4aE5e/i1bjCNIRYJZlA8Q8p0r9T8cF/RVvwUgRA//FydEyg== + big.js@^5.2.2: version "5.2.2" resolved "https://registry.yarnpkg.com/big.js/-/big.js-5.2.2.tgz#65f0af382f578bcdc742bd9c281e9cb2d7768328" @@ -3141,6 +3066,11 @@ bignumber.js@^9.0.0, bignumber.js@^9.0.1: resolved "https://registry.yarnpkg.com/bignumber.js/-/bignumber.js-9.0.1.tgz#8d7ba124c882bfd8e43260c67475518d0689e4e5" integrity sha512-IdZR9mh6ahOBv/hYGiXyVuyCetmGJhtYkqLBpTStdhEGjegpPlUawydyaF3pbIOFynJTpllEs+NP+CS9jKFLjA== +binary-extensions@^1.0.0: + version "1.13.1" + resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-1.13.1.tgz#598afe54755b2868a5330d2aff9d4ebb53209b65" + integrity sha512-Un7MIEDdUC5gNpcGDV97op1Ywk748MpHcFTHoYs6qnj1Z3j7I53VG3nwZhKzoBZmbdRNnb6WRdFlwl7tSDuZGw== + binary-extensions@^2.0.0: version "2.2.0" resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-2.2.0.tgz#75f502eeaf9ffde42fc98829645be4ea76bd9e2d" @@ -3186,6 +3116,11 @@ bn.js@4.11.6: resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-4.11.6.tgz#53344adb14617a13f6e8dd2ce28905d1c0ba3215" integrity sha1-UzRK2xRhehP26N0s4okF0cC6MhU= +bn.js@4.11.8: + version "4.11.8" + resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-4.11.8.tgz#2cde09eb5ee341f484746bb0309b3253b1b1442f" + integrity sha512-ItfYfPLkWHUjckQCk8xC+LwxgK8NYcXywGigJgSwOP8Y2iyWT4f2vsZnoOXTTbo+o5yXmIUJ4gn5538SO5S3gA== + bn.js@^4.0.0, bn.js@^4.1.0, bn.js@^4.10.0, bn.js@^4.11.0, bn.js@^4.11.1, bn.js@^4.11.6, bn.js@^4.11.8, bn.js@^4.11.9, bn.js@^4.4.0, bn.js@^4.8.0: version "4.12.0" resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-4.12.0.tgz#775b3f278efbb9718eec7361f483fb36fbbfea88" @@ -3217,6 +3152,19 @@ boolbase@^1.0.0: resolved "https://registry.yarnpkg.com/boolbase/-/boolbase-1.0.0.tgz#68dff5fbe60c51eb37725ea9e3ed310dcc1e776e" integrity sha1-aN/1++YMUes3cl6p4+0xDcwed24= +borc@^2.1.2: + version "2.1.2" + resolved "https://registry.yarnpkg.com/borc/-/borc-2.1.2.tgz#6ce75e7da5ce711b963755117dd1b187f6f8cf19" + integrity sha512-Sy9eoUi4OiKzq7VovMn246iTo17kzuyHJKomCfpWMlI6RpfN1gk95w7d7gH264nApVLg0HZfcpz62/g4VH1Y4w== + dependencies: + bignumber.js "^9.0.0" + buffer "^5.5.0" + commander "^2.15.0" + ieee754 "^1.1.13" + iso-url "~0.4.7" + json-text-sequence "~0.1.0" + readable-stream "^3.6.0" + brace-expansion@^1.1.7: version "1.1.11" resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd" @@ -3225,7 +3173,16 @@ brace-expansion@^1.1.7: balanced-match "^1.0.0" concat-map "0.0.1" -braces@^2.3.1: +braces@^1.8.2: + version "1.8.5" + resolved "https://registry.yarnpkg.com/braces/-/braces-1.8.5.tgz#ba77962e12dff969d6b76711e914b737857bf6a7" + integrity sha1-uneWLhLf+WnWt2cR6RS3N4V79qc= + dependencies: + expand-range "^1.8.1" + preserve "^0.2.0" + repeat-element "^1.1.2" + +braces@^2.3.1, braces@^2.3.2: version "2.3.2" resolved "https://registry.yarnpkg.com/braces/-/braces-2.3.2.tgz#5979fd3f14cd531565e5fa2df1abfff1dfaee729" integrity sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w== @@ -3253,6 +3210,11 @@ brorand@^1.0.1, brorand@^1.1.0: resolved "https://registry.yarnpkg.com/brorand/-/brorand-1.1.0.tgz#12c25efe40a45e3c323eb8675a0a0ce57b22371f" integrity sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8= +browser-stdout@1.3.0: + version "1.3.0" + resolved "https://registry.yarnpkg.com/browser-stdout/-/browser-stdout-1.3.0.tgz#f351d32969d32fa5d7a5567154263d928ae3bd1f" + integrity sha1-81HTKWnTL6XXpVZxVCY9korjvR8= + browser-stdout@1.3.1: version "1.3.1" resolved "https://registry.yarnpkg.com/browser-stdout/-/browser-stdout-1.3.1.tgz#baa559ee14ced73452229bad7326467c61fabd60" @@ -3312,6 +3274,13 @@ browserify-sign@^4.0.0: readable-stream "^3.6.0" safe-buffer "^5.2.0" +browserify-zlib@^0.2.0: + version "0.2.0" + resolved "https://registry.yarnpkg.com/browserify-zlib/-/browserify-zlib-0.2.0.tgz#2869459d9aa3be245fe8fe2ca1f46e2e7f54d73f" + integrity sha512-Z942RysHXmJrhqk88FmKBVq/v5tqmSkDz7p54G/MGyjMnCFFnC79XWNbg+Vta8W6Wb2qtSZTSxIGkJrRpCFEiA== + dependencies: + pako "~1.0.5" + browserslist@^3.2.6: version "3.2.8" resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-3.2.8.tgz#b0005361d6471f0f5952797a76fc985f1f978fc6" @@ -3320,7 +3289,7 @@ browserslist@^3.2.6: caniuse-lite "^1.0.30000844" electron-to-chromium "^1.3.47" -bs58@^4.0.0: +bs58@^4.0.0, bs58@^4.0.1: version "4.0.1" resolved "https://registry.yarnpkg.com/bs58/-/bs58-4.0.1.tgz#be161e76c354f6f788ae4071f63f34e8c4f0a42a" integrity sha1-vhYedsNU9veIrkBx9j806MTwpCo= @@ -3358,6 +3327,23 @@ buffer-xor@^2.0.1: dependencies: safe-buffer "^5.1.1" +buffer@6.0.3: + version "6.0.3" + resolved "https://registry.yarnpkg.com/buffer/-/buffer-6.0.3.tgz#2ace578459cc8fbe2a70aaa8f52ee63b6a74c6c6" + integrity sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA== + dependencies: + base64-js "^1.3.1" + ieee754 "^1.2.1" + +buffer@^4.3.0: + version "4.9.2" + resolved "https://registry.yarnpkg.com/buffer/-/buffer-4.9.2.tgz#230ead344002988644841ab0244af8c44bbe3ef8" + integrity sha512-xq+q3SRMOxGivLhBNaUdC64hDTQwejJ+H0T/NB1XMtTVEwNTrfFF3gAxiyW0Bu/xWEGhjVKgUcMhCrUy2+uCWg== + dependencies: + base64-js "^1.0.2" + ieee754 "^1.1.4" + isarray "^1.0.0" + buffer@^5.0.5, buffer@^5.2.1, buffer@^5.5.0, buffer@^5.6.0: version "5.7.1" resolved "https://registry.yarnpkg.com/buffer/-/buffer-5.7.1.tgz#ba62e7c13133053582197160851a8f648e99eed0" @@ -3373,6 +3359,11 @@ bufferutil@^4.0.1: dependencies: node-gyp-build "^4.2.0" +builtin-status-codes@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/builtin-status-codes/-/builtin-status-codes-3.0.0.tgz#85982878e21b98e1c66425e03d0174788f569ee8" + integrity sha1-hZgoeOIbmOHGZCXgPQF0eI9Wnug= + bytes@3.1.0: version "3.1.0" resolved "https://registry.yarnpkg.com/bytes/-/bytes-3.1.0.tgz#f6cf7933a360e0588fa9fde85651cdc7f805d1f6" @@ -3461,6 +3452,11 @@ callsites@^3.0.0: resolved "https://registry.yarnpkg.com/callsites/-/callsites-3.1.0.tgz#b3630abd8943432f54b3f0519238e33cd7df2f73" integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ== +camelcase@^1.0.2: + version "1.2.1" + resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-1.2.1.tgz#9bb5304d2e0b56698b2c758b08a3eaa9daa58a39" + integrity sha1-m7UwTS4LVmmLLHWLCKPqqdqlijk= + camelcase@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-3.0.0.tgz#32fc4b9fcdaf845fcdf7e73bb97cac2261f0ab0a" @@ -3477,9 +3473,9 @@ camelcase@^5.0.0: integrity sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg== caniuse-lite@^1.0.30000844: - version "1.0.30001228" - resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001228.tgz#bfdc5942cd3326fa51ee0b42fbef4da9d492a7fa" - integrity sha512-QQmLOGJ3DEgokHbMSA8cj2a+geXqmnpyOFT0lhQV6P3/YOJvGDEwoedcwxEQ30gJIwIIunHIicunJ2rzK5gB2A== + version "1.0.30001239" + resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001239.tgz#66e8669985bb2cb84ccb10f68c25ce6dd3e4d2b8" + integrity sha512-cyBkXJDMeI4wthy8xJ2FvDU6+0dtcZSJW3voUF8+e9f1bBeuvyZfc3PNbkOETyhbR+dGCPzn9E7MA3iwzusOhQ== caseless@^0.12.0, caseless@~0.12.0: version "0.12.0" @@ -3494,6 +3490,14 @@ cbor@^5.0.2, cbor@^5.1.0: bignumber.js "^9.0.1" nofilter "^1.0.4" +center-align@^0.1.1: + version "0.1.3" + resolved "https://registry.yarnpkg.com/center-align/-/center-align-0.1.3.tgz#aa0d32629b6ee972200411cbd4461c907bc2b7ad" + integrity sha1-qg0yYptu6XIgBBHL1EYckHvCt60= + dependencies: + align-text "^0.1.3" + lazy-cache "^1.0.3" + chai-as-promised@^7.1.1: version "7.1.1" resolved "https://registry.yarnpkg.com/chai-as-promised/-/chai-as-promised-7.1.1.tgz#08645d825deb8696ee61725dbf590c012eb00ca0" @@ -3563,24 +3567,24 @@ checkpoint-store@^1.1.0: dependencies: functional-red-black-tree "^1.0.1" -cheerio-select@^1.4.0: - version "1.4.0" - resolved "https://registry.yarnpkg.com/cheerio-select/-/cheerio-select-1.4.0.tgz#3a16f21e37a2ef0f211d6d1aa4eff054bb22cdc9" - integrity sha512-sobR3Yqz27L553Qa7cK6rtJlMDbiKPdNywtR95Sj/YgfpLfy0u6CGJuaBKe5YE/vTc23SCRKxWSdlon/w6I/Ew== +cheerio-select@^1.5.0: + version "1.5.0" + resolved "https://registry.yarnpkg.com/cheerio-select/-/cheerio-select-1.5.0.tgz#faf3daeb31b17c5e1a9dabcee288aaf8aafa5823" + integrity sha512-qocaHPv5ypefh6YNxvnbABM07KMxExbtbfuJoIie3iZXX1ERwYmJcIiRrr9H05ucQP1k28dav8rpdDgjQd8drg== dependencies: - css-select "^4.1.2" - css-what "^5.0.0" + css-select "^4.1.3" + css-what "^5.0.1" domelementtype "^2.2.0" domhandler "^4.2.0" - domutils "^2.6.0" + domutils "^2.7.0" cheerio@^1.0.0-rc.2: - version "1.0.0-rc.9" - resolved "https://registry.yarnpkg.com/cheerio/-/cheerio-1.0.0-rc.9.tgz#a3ae6b7ce7af80675302ff836f628e7cb786a67f" - integrity sha512-QF6XVdrLONO6DXRF5iaolY+odmhj2CLj+xzNod7INPWMi/x9X4SOylH0S/vaPpX+AUU6t04s34SQNh7DbkuCng== + version "1.0.0-rc.10" + resolved "https://registry.yarnpkg.com/cheerio/-/cheerio-1.0.0-rc.10.tgz#2ba3dcdfcc26e7956fc1f440e61d51c643379f3e" + integrity sha512-g0J0q/O6mW8z5zxQ3A8E8J1hUgp4SMOvEoW/x84OwyHKe/Zccz83PVT4y5Crcr530FV6NgmKI1qvGTKVl9XXVw== dependencies: - cheerio-select "^1.4.0" - dom-serializer "^1.3.1" + cheerio-select "^1.5.0" + dom-serializer "^1.3.2" domhandler "^4.2.0" htmlparser2 "^6.1.0" parse5 "^6.0.1" @@ -3602,20 +3606,55 @@ chokidar@3.3.0: optionalDependencies: fsevents "~2.1.1" -chokidar@^3.4.0: - version "3.5.1" - resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.5.1.tgz#ee9ce7bbebd2b79f49f304799d5468e31e14e68a" - integrity sha512-9+s+Od+W0VJJzawDma/gvBNQqkTiqYTWLuZoyAsivsI4AaWTCzHG06/TMjsf1cYe9Cb97UCEhjz7HvnPk2p/tw== +chokidar@^1.6.0: + version "1.7.0" + resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-1.7.0.tgz#798e689778151c8076b4b360e5edd28cda2bb468" + integrity sha1-eY5ol3gVHIB2tLNg5e3SjNortGg= dependencies: - anymatch "~3.1.1" + anymatch "^1.3.0" + async-each "^1.0.0" + glob-parent "^2.0.0" + inherits "^2.0.1" + is-binary-path "^1.0.0" + is-glob "^2.0.0" + path-is-absolute "^1.0.0" + readdirp "^2.0.0" + optionalDependencies: + fsevents "^1.0.0" + +chokidar@^2.1.8: + version "2.1.8" + resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-2.1.8.tgz#804b3a7b6a99358c3c5c61e71d8728f041cff917" + integrity sha512-ZmZUazfOzf0Nve7duiCKD23PFSCs4JPoYyccjUFF3aQkQadqBhfzhjkwBH2mNOG9cTBwhamM37EIsIkZw3nRgg== + dependencies: + anymatch "^2.0.0" + async-each "^1.0.1" + braces "^2.3.2" + glob-parent "^3.1.0" + inherits "^2.0.3" + is-binary-path "^1.0.0" + is-glob "^4.0.0" + normalize-path "^3.0.0" + path-is-absolute "^1.0.0" + readdirp "^2.2.1" + upath "^1.1.1" + optionalDependencies: + fsevents "^1.2.7" + +chokidar@^3.4.0, chokidar@^3.4.1: + version "3.5.2" + resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.5.2.tgz#dba3976fcadb016f66fd365021d91600d01c1e75" + integrity sha512-ekGhOnNVPgT77r4K/U3GDhu+FQ2S8TnK/s2KbIGXi0SZWuwkZ2QNyfWdZW+TVfn84DpEP7rLeCt2UI6bJ8GwbQ== + dependencies: + anymatch "~3.1.2" braces "~3.0.2" - glob-parent "~5.1.0" + glob-parent "~5.1.2" is-binary-path "~2.1.0" is-glob "~4.0.1" normalize-path "~3.0.0" - readdirp "~3.5.0" + readdirp "~3.6.0" optionalDependencies: - fsevents "~2.3.1" + fsevents "~2.3.2" chownr@^1.1.1: version "1.1.4" @@ -3718,6 +3757,15 @@ cli-width@^2.0.0: resolved "https://registry.yarnpkg.com/cli-width/-/cli-width-2.2.1.tgz#b0433d0b4e9c847ef18868a4ef16fd5fc8271c48" integrity sha512-GRMWDxpOB6Dgk2E5Uo+3eEBvtOOlimMmpbFiKuLFnQzYDavtLFY3K5ona41jgN/WdRZtG7utuVSVTL4HbZHGkw== +cliui@^2.1.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/cliui/-/cliui-2.1.0.tgz#4b475760ff80264c762c3a1719032e91c7fea0d1" + integrity sha1-S0dXYP+AJkx2LDoXGQMukcf+oNE= + dependencies: + center-align "^0.1.1" + right-align "^0.1.1" + wordwrap "0.0.2" + cliui@^3.2.0: version "3.2.0" resolved "https://registry.yarnpkg.com/cliui/-/cliui-3.2.0.tgz#120601537a916d29940f934da3b48d585a39213d" @@ -3727,6 +3775,15 @@ cliui@^3.2.0: strip-ansi "^3.0.1" wrap-ansi "^2.0.0" +cliui@^4.0.0: + version "4.1.0" + resolved "https://registry.yarnpkg.com/cliui/-/cliui-4.1.0.tgz#348422dbe82d800b3022eef4f6ac10bf2e4d1b49" + integrity sha512-4FG+RSG9DL7uEwRUZXZn3SS34DiDPfzP0VOiEwtUWlE+AR2EIg+hSyvrIgUUfhdgR/UkAeW2QHgeP+hWrXs7jQ== + dependencies: + string-width "^2.1.1" + strip-ansi "^4.0.0" + wrap-ansi "^2.0.0" + cliui@^5.0.0: version "5.0.0" resolved "https://registry.yarnpkg.com/cliui/-/cliui-5.0.0.tgz#deefcfdb2e800784aa34f46fa08e06851c7bbbc5" @@ -3748,6 +3805,11 @@ clone@2.1.2, clone@^2.0.0: resolved "https://registry.yarnpkg.com/clone/-/clone-2.1.2.tgz#1b7f4b9f591f1e8f83670401600345a02887435f" integrity sha1-G39Ln1kfHo+DZwQBYANFoCiHQ18= +co@^4.6.0: + version "4.6.0" + resolved "https://registry.yarnpkg.com/co/-/co-4.6.0.tgz#6ea6bdf3d853ae54ccb8e47bfa0bf3f9031fb184" + integrity sha1-bqa989hTrlTMuOR7+gvz+QMfsYQ= + code-point-at@^1.0.0: version "1.1.0" resolved "https://registry.yarnpkg.com/code-point-at/-/code-point-at-1.1.0.tgz#0d070b4d043a5bea33a2f1a40e2edb3d9a4ccf77" @@ -3785,6 +3847,11 @@ color-name@~1.1.4: resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2" integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA== +colorette@^1.2.2: + version "1.2.2" + resolved "https://registry.yarnpkg.com/colorette/-/colorette-1.2.2.tgz#cbcc79d5e99caea2dbf10eb3a26fd8b3e6acfa94" + integrity sha512-MKGMzyfeuutC/ZJ1cba9NqcNpfeqMUcYmyF1ZFY6/Cn7CNSAKx6a+s48sqLqyAiZuaP2TcqMhoo+dlwFnVxT9w== + colors@^1.1.2, colors@^1.4.0: version "1.4.0" resolved "https://registry.yarnpkg.com/colors/-/colors-1.4.0.tgz#c50491479d4c1bdaed2c9ced32cf7c7dc2360f78" @@ -3811,6 +3878,11 @@ command-line-args@^4.0.7: find-replace "^1.0.3" typical "^2.6.1" +commander@2.11.0: + version "2.11.0" + resolved "https://registry.yarnpkg.com/commander/-/commander-2.11.0.tgz#157152fd1e7a6c8d98a5b715cf376df928004563" + integrity sha512-b0553uYA5YAEGgyYIGYROzKQ7X5RAqedkfjiZxwi0kL1g3bOaBNNZfYkzt/CL0umgD5wc9Jec2FbB98CjkMRvQ== + commander@2.18.0: version "2.18.0" resolved "https://registry.yarnpkg.com/commander/-/commander-2.18.0.tgz#2bf063ddee7c7891176981a2cc798e5754bc6970" @@ -3821,6 +3893,11 @@ commander@3.0.2: resolved "https://registry.yarnpkg.com/commander/-/commander-3.0.2.tgz#6837c3fb677ad9933d1cfba42dd14d5117d6b39e" integrity sha512-Gar0ASD4BDyKC4hl4DwHqDrmvjoxWKZigVnAbn5H1owvm4CxCPdb0HQDehwNYMJpla5+M2tPmPARzhtYuwpHow== +commander@^2.15.0, commander@^2.9.0: + version "2.20.3" + resolved "https://registry.yarnpkg.com/commander/-/commander-2.20.3.tgz#fd485e84c03eb4881c20722ba48035e8531aeb33" + integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ== + commander@^6.1.0, commander@^6.2.0: version "6.2.1" resolved "https://registry.yarnpkg.com/commander/-/commander-6.2.1.tgz#0792eb682dfbc325999bb2b84fddddba110ac73c" @@ -3851,13 +3928,15 @@ concat-stream@^1.5.1, concat-stream@^1.6.0, concat-stream@^1.6.2: readable-stream "^2.2.2" typedarray "^0.0.6" -contains-path@^1.0.0: - version "1.0.0" - resolved "https://registry.yarnpkg.com/contains-path/-/contains-path-1.0.0.tgz#3458b332185603e8eed18f518d4a10888a3abc91" - integrity sha1-NFizMhhWA+ju0Y9RjUoQiIo6vJE= - dependencies: - normalize-path "^2.1.1" - path-starts-with "^1.0.0" +console-browserify@^1.1.0: + version "1.2.0" + resolved "https://registry.yarnpkg.com/console-browserify/-/console-browserify-1.2.0.tgz#67063cef57ceb6cf4993a2ab3a55840ae8c49336" + integrity sha512-ZMkYO/LkF17QvCPqM0gxw8yUzigAOZOSWSHg91FH6orS7vcEj5dVZTidN2fQ14yBSdg97RqhSNwLUXInd52OTA== + +constants-browserify@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/constants-browserify/-/constants-browserify-1.0.0.tgz#c20b96d8c617748aaf1c16021760cd27fcb8cb75" + integrity sha1-wguW2MYXdIqvHBYCF2DNJ/y4y3U= content-disposition@0.5.3: version "0.5.3" @@ -3881,9 +3960,9 @@ content-type@~1.0.4: integrity sha512-hIP3EEPs8tB9AT1L+NUqtwOAps4mk2Zob89MWXMHjHWg9milF/j4osnnQLXBCBFBk/tvIG/tUc9mOUJiPBhPXA== convert-source-map@^1.5.1: - version "1.7.0" - resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.7.0.tgz#17a2cb882d7f77d3490585e2ce6c524424a3a442" - integrity sha512-4FJkXzKXEDB1snCFZlLP4gpC3JILicCpGbzG9f9G7tGqGCzETQ2hWPrcinA9oU4wtf2biUaEH5065UnMeR33oA== + 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" @@ -3913,9 +3992,9 @@ copy-descriptor@^0.1.0: integrity sha1-Z29us8OZl8LuGsOpJP1hJHSPV40= core-js-pure@^3.0.1: - version "3.12.1" - resolved "https://registry.yarnpkg.com/core-js-pure/-/core-js-pure-3.12.1.tgz#934da8b9b7221e2a2443dc71dfa5bd77a7ea00b8" - integrity sha512-1cch+qads4JnDSWsvc7d6nzlKAippwjUlf6vykkTLW53VSV+NkE6muGBToAjEA8pG90cSfcud3JgVmW2ds5TaQ== + version "3.15.0" + resolved "https://registry.yarnpkg.com/core-js-pure/-/core-js-pure-3.15.0.tgz#c19349ae0be197b8bcf304acf4d91c5e29ae2091" + integrity sha512-RO+LFAso8DB6OeBX9BAcEGvyth36QtxYon1OyVsITNVtSKr/Hos0BXZwnsOJ7o+O6KHtK+O+cJIEj9NGg6VwFA== core-js@^2.4.0, core-js@^2.5.0: version "2.6.12" @@ -4017,7 +4096,7 @@ cross-spawn@^5.0.1: shebang-command "^1.2.0" which "^1.2.9" -cross-spawn@^6.0.5: +cross-spawn@^6.0.0, cross-spawn@^6.0.5: version "6.0.5" resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-6.0.5.tgz#4a5ec7c64dfae22c3a14124dbacdee846d80cbc4" integrity sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ== @@ -4053,7 +4132,20 @@ cross-var@^1.1.0: resolved "https://registry.yarnpkg.com/crypt/-/crypt-0.0.2.tgz#88d7ff7ec0dfb86f713dc87bbb42d044d3e6c41b" integrity sha1-iNf/fsDfuG9xPch7u0LQRNPmxBs= -crypto-browserify@3.12.0: +crypto-addr-codec@^0.1.7: + version "0.1.7" + resolved "https://registry.yarnpkg.com/crypto-addr-codec/-/crypto-addr-codec-0.1.7.tgz#e16cea892730178fe25a38f6d15b680cab3124ae" + integrity sha512-X4hzfBzNhy4mAc3UpiXEC/L0jo5E8wAa9unsnA8nNXYzXjCcGk83hfC5avJWCSGT8V91xMnAS9AKMHmjw5+XCg== + dependencies: + base-x "^3.0.8" + big-integer "1.6.36" + blakejs "^1.1.0" + bs58 "^4.0.1" + ripemd160-min "0.0.6" + safe-buffer "^5.2.0" + sha3 "^2.1.1" + +crypto-browserify@3.12.0, crypto-browserify@^3.11.0: version "3.12.0" resolved "https://registry.yarnpkg.com/crypto-browserify/-/crypto-browserify-3.12.0.tgz#396cf9f3137f03e4b8e532c58f698254e00f80ec" integrity sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg== @@ -4075,10 +4167,10 @@ crypto-js@^3.1.9-1: resolved "https://registry.yarnpkg.com/crypto-js/-/crypto-js-3.3.0.tgz#846dd1cce2f68aacfa156c8578f926a609b7976b" integrity sha512-DIT51nX0dCfKltpRiXV+/TVZq+Qq2NgF4644+K7Ttnla7zEzqc+kjJyiB96BHNyUTBxyjzRcZYpUdZa+QAqi6Q== -css-select@^4.1.2: - version "4.1.2" - resolved "https://registry.yarnpkg.com/css-select/-/css-select-4.1.2.tgz#8b52b6714ed3a80d8221ec971c543f3b12653286" - integrity sha512-nu5ye2Hg/4ISq4XqdLY2bEatAcLIdt3OYGFc9Tm9n7VSlFBcfRv0gBNksHRgSdUDQGtN3XrZ94ztW+NfzkFSUw== +css-select@^4.1.3: + version "4.1.3" + resolved "https://registry.yarnpkg.com/css-select/-/css-select-4.1.3.tgz#a70440f70317f2669118ad74ff105e65849c7067" + integrity sha512-gT3wBNd9Nj49rAbmtFHj1cljIAOLYSX1nZ8CB7TBO3INYckygm5B7LISU/szY//YmdiSLbJvDLOx9VnMVpMBxA== dependencies: boolbase "^1.0.0" css-what "^5.0.0" @@ -4086,7 +4178,7 @@ css-select@^4.1.2: domutils "^2.6.0" nth-check "^2.0.0" -css-what@^5.0.0: +css-what@^5.0.0, css-what@^5.0.1: version "5.0.1" resolved "https://registry.yarnpkg.com/css-what/-/css-what-5.0.1.tgz#3efa820131f4669a8ac2408f9c32e7c7de9f4cad" integrity sha512-FYDTSHb/7KXsWICVsxdmiExPjCfRC4qRFBdVwv7Ax9hMnvMmEjP9RfxTEZ3qPZGmADDn2vAKSo9UcN1jKVYscg== @@ -4113,6 +4205,13 @@ debug@2.6.9, debug@^2.2.0, debug@^2.3.3, debug@^2.6.8, debug@^2.6.9: dependencies: ms "2.0.0" +debug@3.1.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/debug/-/debug-3.1.0.tgz#5bb5a0672628b64149566ba16819e61518c67261" + integrity sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g== + dependencies: + ms "2.0.0" + debug@3.2.6: version "3.2.6" resolved "https://registry.yarnpkg.com/debug/-/debug-3.2.6.tgz#e83d17de16d8a7efb7717edbe5fb10135eee629b" @@ -4120,7 +4219,7 @@ debug@3.2.6: dependencies: ms "^2.1.1" -debug@4, debug@^4.0.1, debug@^4.1.1, debug@^4.2.0, debug@^4.3.1: +debug@4, debug@^4.0.1, debug@^4.1.0, debug@^4.1.1, debug@^4.2.0, debug@^4.3.1: version "4.3.1" resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.1.tgz#f0d229c505e0c6d8c49ac553d1b13dc183f6b2ee" integrity sha512-doEwdvm4PCeK4K3RQN2ZC2BYUBaxwLARCqZmMjtF8a51J2Rb0xpVloFRnCODwqjpwnAoao4pelN8l3RJdv3gRQ== @@ -4134,7 +4233,7 @@ debug@^3.1.0, debug@^3.2.7: dependencies: ms "^2.1.1" -decamelize@^1.1.1, decamelize@^1.2.0: +decamelize@^1.0.0, decamelize@^1.1.1, decamelize@^1.2.0: version "1.2.0" resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-1.2.0.tgz#f6534d15148269b20352e7bee26f501f9a191290" integrity sha1-9lNNFRSCabIDUue+4m9QH5oZEpA= @@ -4252,6 +4351,11 @@ delayed-stream@~1.0.0: resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619" integrity sha1-3zrhmayt+31ECqrgsp4icrJOxhk= +delimit-stream@0.1.0: + version "0.1.0" + resolved "https://registry.yarnpkg.com/delimit-stream/-/delimit-stream-0.1.0.tgz#9b8319477c0e5f8aeb3ce357ae305fc25ea1cd2b" + integrity sha1-m4MZR3wOX4rrPONXrjBfwl6hzSs= + depd@~1.1.2: version "1.1.2" resolved "https://registry.yarnpkg.com/depd/-/depd-1.1.2.tgz#9bcd52e14c097763e749b274c4346ed2e560b5a9" @@ -4282,12 +4386,17 @@ detect-indent@^5.0.0: resolved "https://registry.yarnpkg.com/detect-indent/-/detect-indent-5.0.0.tgz#3871cc0a6a002e8c3e5b3cf7f336264675f06b9d" integrity sha1-OHHMCmoALow+Wzz38zYmRnXwa50= -diff-sequences@^26.6.2: - version "26.6.2" - resolved "https://registry.yarnpkg.com/diff-sequences/-/diff-sequences-26.6.2.tgz#48ba99157de1923412eed41db6b6d4aa9ca7c0b1" - integrity sha512-Mv/TDa3nZ9sbc5soK+OoA74BsS3mL37yixCvUAQkiuA4Wz6YtwP/K47n2rv2ovzHZvoiQeA5FTQOschKkEwB0Q== +diff-sequences@^27.0.1: + version "27.0.1" + resolved "https://registry.yarnpkg.com/diff-sequences/-/diff-sequences-27.0.1.tgz#9c9801d52ed5f576ff0a20e3022a13ee6e297e7c" + integrity sha512-XPLijkfJUh/PIBnfkcSHgvD6tlYixmcMAn3osTk6jt+H0v/mgURto1XUiD9DKuGX5NDoVS6dSlA23gd9FUaCFg== + +diff@3.3.1: + version "3.3.1" + resolved "https://registry.yarnpkg.com/diff/-/diff-3.3.1.tgz#aa8567a6eed03c531fc89d3f711cd0e5259dec75" + integrity sha512-MKPHZDMB0o6yHyDryUOScqZibp914ksXwAMYMTHj6KO8UeKsRYNJD3oNCKjTqZon+V488P7N/HzXF8t7ZR95ww== -diff@3.5.0: +diff@3.5.0, diff@^3.5.0: version "3.5.0" resolved "https://registry.yarnpkg.com/diff/-/diff-3.5.0.tgz#800c0dd1e0a8bfbc95835c202ad220fe317e5a12" integrity sha512-A46qtFgd+g7pDZinpnwiRJtxbC1hpgf0uzP3iG89scHk0AUC7A1TGxf5OiiOUv/JMZR8GOt8hL900hV0bOy5xA== @@ -4313,11 +4422,6 @@ dir-glob@^3.0.1: dependencies: path-type "^4.0.0" -dir-to-object@^2.0.0: - version "2.0.0" - resolved "https://registry.yarnpkg.com/dir-to-object/-/dir-to-object-2.0.0.tgz#29723e9bd1c3e58e4f307bd04ff634c0370c8f8a" - integrity sha512-sXs0JKIhymON7T1UZuO2Ud6VTNAx/VTBXIl4+3mjb2RgfOpt+hectX0x04YqPOPdkeOAKoJuKqwqnXXURNPNEA== - disklet@^0.4.6: version "0.4.6" resolved "https://registry.yarnpkg.com/disklet/-/disklet-0.4.6.tgz#5315b62e331423f97f609bf34e5868665d988f4e" @@ -4325,6 +4429,13 @@ disklet@^0.4.6: dependencies: rfc4648 "^1.3.0" +dns-packet@^5.2.4: + version "5.2.4" + resolved "https://registry.yarnpkg.com/dns-packet/-/dns-packet-5.2.4.tgz#e004f409eadfa8ec861964dcb9eb395884fcf67d" + integrity sha512-vgu5Bx5IV8mXmh/9cn1lzn+J7okFlXe1vBRp+kCBJXg1nBED6Z/Q4e+QaDxQRSozMr14p/VQmdXwsf/I2wGjUA== + dependencies: + ip "^1.1.5" + doctrine@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-2.1.0.tgz#5cd01fc101621b42c4cd7f5d1a66243716d3f39d" @@ -4339,13 +4450,13 @@ doctrine@^3.0.0: dependencies: esutils "^2.0.2" -dom-serializer@^1.0.1, dom-serializer@^1.3.1: - version "1.3.1" - resolved "https://registry.yarnpkg.com/dom-serializer/-/dom-serializer-1.3.1.tgz#d845a1565d7c041a95e5dab62184ab41e3a519be" - integrity sha512-Pv2ZluG5ife96udGgEDovOOOA5UELkltfJpnIExPrAk1LTvecolUGn6lIaoLh86d83GiB86CjzciMd9BuRB71Q== +dom-serializer@^1.0.1, dom-serializer@^1.3.2: + version "1.3.2" + resolved "https://registry.yarnpkg.com/dom-serializer/-/dom-serializer-1.3.2.tgz#6206437d32ceefaec7161803230c7a20bc1b4d91" + integrity sha512-5c54Bk5Dw4qAxNOI1pFEizPSjVsx5+bpJKmL2kPn8JhBUq2q09tTCa3mjijun2NfK78NMouDYNMBkOrPZiS+ig== dependencies: domelementtype "^2.0.1" - domhandler "^4.0.0" + domhandler "^4.2.0" entities "^2.0.0" dom-walk@^0.1.0: @@ -4353,6 +4464,11 @@ dom-walk@^0.1.0: resolved "https://registry.yarnpkg.com/dom-walk/-/dom-walk-0.1.2.tgz#0c548bef048f4d1f2a97249002236060daa3fd84" integrity sha512-6QvTW9mrGeIegrFXdtQi9pk7O/nSK6lSdXW2eqUspN5LWD7UTji2Fqw5V2YLjBpHEoU9Xl/eUWNpDeZvoyOv2w== +domain-browser@^1.1.1: + version "1.2.0" + resolved "https://registry.yarnpkg.com/domain-browser/-/domain-browser-1.2.0.tgz#3d31f50191a6749dd1375a7f522e823d42e54eda" + integrity sha512-jnjyiM6eRyZl2H+W8Q/zLMA481hzi0eszAaBUzIVnmYVDBbnLxVNnfu1HgEBvCbL+71FrxMl3E6lpKH7Ge3OXA== + domelementtype@^2.0.1, domelementtype@^2.2.0: version "2.2.0" resolved "https://registry.yarnpkg.com/domelementtype/-/domelementtype-2.2.0.tgz#9a0b6c2782ed6a1c7323d42267183df9bd8b1d57" @@ -4365,10 +4481,10 @@ domhandler@^4.0.0, domhandler@^4.2.0: dependencies: domelementtype "^2.2.0" -domutils@^2.5.2, domutils@^2.6.0: - version "2.6.0" - resolved "https://registry.yarnpkg.com/domutils/-/domutils-2.6.0.tgz#2e15c04185d43fb16ae7057cb76433c6edb938b7" - integrity sha512-y0BezHuy4MDYxh6OvolXYsH+1EMGmFbwv5FKW7ovwMG6zTPWqNPq3WF9ayZssFq+UlKdffGLbOEaghNdaOm1WA== +domutils@^2.5.2, domutils@^2.6.0, domutils@^2.7.0: + version "2.7.0" + resolved "https://registry.yarnpkg.com/domutils/-/domutils-2.7.0.tgz#8ebaf0c41ebafcf55b0b72ec31c56323712c5442" + integrity sha512-8eaHa17IwJUPAiB+SoTYBo5mCdeMgdcAoXJ59m6DT1vw+5iLS3gNoqYaRowaBKtGVrOF1Jz4yDTgYKLK2kvfJg== dependencies: dom-serializer "^1.0.1" domelementtype "^2.2.0" @@ -4429,9 +4545,9 @@ ee-first@1.1.1: integrity sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0= electron-to-chromium@^1.3.47: - version "1.3.727" - resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.3.727.tgz#857e310ca00f0b75da4e1db6ff0e073cc4a91ddf" - integrity sha512-Mfz4FIB4FSvEwBpDfdipRIrwd6uo8gUDoRDF4QEYb4h4tSuI3ov594OrjU6on042UlFHouIJpClDODGkPcBSbg== + version "1.3.754" + resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.3.754.tgz#afbe69177ad7aae968c3bbeba129dc70dcc37cf4" + integrity sha512-Q50dJbfYYRtwK3G9mFP/EsJVzlgcYwKxFjbXmvVa1lDAbdviPcT9QOpFoufDApub4j0hBfDRL6v3lWNLEdEDXQ== elliptic@6.5.3: version "6.5.3" @@ -4474,6 +4590,11 @@ emoji-regex@^9.2.2: resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-9.2.2.tgz#840c8803b0d8047f4ff0cf963176b32d4ef3ed72" integrity sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg== +emojis-list@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/emojis-list/-/emojis-list-3.0.0.tgz#5570662046ad29e2e916e71aae260abdff4f6a78" + integrity sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q== + encode-utf8@^1.0.2: version "1.0.3" resolved "https://registry.yarnpkg.com/encode-utf8/-/encode-utf8-1.0.3.tgz#f30fdd31da07fb596f281beb2f6b027851994cda" @@ -4519,6 +4640,16 @@ end-of-stream@^1.1.0: dependencies: once "^1.4.0" +enhanced-resolve@^3.4.0: + version "3.4.1" + resolved "https://registry.yarnpkg.com/enhanced-resolve/-/enhanced-resolve-3.4.1.tgz#0421e339fd71419b3da13d129b3979040230476e" + integrity sha1-BCHjOf1xQZs9oT0Smzl5BAIwR24= + dependencies: + graceful-fs "^4.1.2" + memory-fs "^0.4.0" + object-assign "^4.0.1" + tapable "^0.2.7" + enquirer@^2.3.0, enquirer@^2.3.4, enquirer@^2.3.5, enquirer@^2.3.6: version "2.3.6" resolved "https://registry.yarnpkg.com/enquirer/-/enquirer-2.3.6.tgz#2a7fe5dd634a1e4125a975ec994ff5456dc3734d" @@ -4536,7 +4667,12 @@ env-paths@^2.2.0: resolved "https://registry.yarnpkg.com/env-paths/-/env-paths-2.2.1.tgz#420399d416ce1fbe9bc0a07c62fa68d67fd0f8f2" integrity sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A== -errno@~0.1.1: +eol@^0.9.1: + version "0.9.1" + resolved "https://registry.yarnpkg.com/eol/-/eol-0.9.1.tgz#f701912f504074be35c6117a5c4ade49cd547acd" + integrity sha512-Ds/TEoZjwggRoz/Q2O7SE3i4Jm66mqTDfmdHdq/7DKVk3bro9Q8h6WdXKdPqFLMoqxrDK5SVRzHVPOS6uuGtrg== + +errno@^0.1.3, errno@~0.1.1: version "0.1.8" resolved "https://registry.yarnpkg.com/errno/-/errno-0.1.8.tgz#8bb3e9c7d463be4976ff888f76b4809ebc2e811f" integrity sha512-dJ6oBr5SQ1VSd9qkk7ByRgb/1SH4JZjCHSW/mr63/QcXO9zLVxvJ6Oy13nio03rxpSnVDDjFor75SjVeZWPW/A== @@ -4550,10 +4686,10 @@ error-ex@^1.2.0, error-ex@^1.3.1: dependencies: is-arrayish "^0.2.1" -es-abstract@^1.18.0-next.1, es-abstract@^1.18.0-next.2: - version "1.18.0" - resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.18.0.tgz#ab80b359eecb7ede4c298000390bc5ac3ec7b5a4" - integrity sha512-LJzK7MrQa8TS0ja2w3YNLzUgJCGPdPOV1yVvezjNnS89D+VR08+Szt2mz3YB2Dck/+w5tfIq/RoUAFqJJGM2yw== +es-abstract@^1.18.0-next.1, es-abstract@^1.18.0-next.2, es-abstract@^1.18.2: + version "1.18.3" + resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.18.3.tgz#25c4c3380a27aa203c44b2b685bba94da31b63e0" + integrity sha512-nQIr12dxV7SSxE6r6f1l3DtAeEYdsGpps13dR0TwJg1S8gyp4ZPgy3FZcHBgbiQqnoqSTb+oC+kO4UQ0C/J8vw== dependencies: call-bind "^1.0.2" es-to-primitive "^1.2.1" @@ -4563,14 +4699,14 @@ es-abstract@^1.18.0-next.1, es-abstract@^1.18.0-next.2: has-symbols "^1.0.2" is-callable "^1.2.3" is-negative-zero "^2.0.1" - is-regex "^1.1.2" - is-string "^1.0.5" - object-inspect "^1.9.0" + is-regex "^1.1.3" + is-string "^1.0.6" + object-inspect "^1.10.3" 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.0" + unbox-primitive "^1.0.1" es-to-primitive@^1.2.1: version "1.2.1" @@ -4581,7 +4717,7 @@ es-to-primitive@^1.2.1: is-date-object "^1.0.1" is-symbol "^1.0.2" -es5-ext@^0.10.35, es5-ext@^0.10.50: +es5-ext@^0.10.35, es5-ext@^0.10.46, es5-ext@^0.10.50, es5-ext@~0.10.14: version "0.10.53" resolved "https://registry.yarnpkg.com/es5-ext/-/es5-ext-0.10.53.tgz#93c5a3acfdbef275220ad72644ad02ee18368de1" integrity sha512-Xs2Stw6NiNHWypzRTY1MtaG/uJlwCk8kH81920ma8mvN8Xq1gsfhZvpkImLQArw8AHnv8MT2I45J3c0R8slE+Q== @@ -4590,7 +4726,7 @@ es5-ext@^0.10.35, es5-ext@^0.10.50: es6-symbol "~3.1.3" next-tick "~1.0.0" -es6-iterator@~2.0.3: +es6-iterator@^2.0.3, es6-iterator@~2.0.1, es6-iterator@~2.0.3: version "2.0.3" resolved "https://registry.yarnpkg.com/es6-iterator/-/es6-iterator-2.0.3.tgz#a7de889141a05a94b0854403b2d0a0fbfa98f3b7" integrity sha1-p96IkUGgWpSwhUQDstCg+/qY87c= @@ -4599,7 +4735,38 @@ es6-iterator@~2.0.3: es5-ext "^0.10.35" es6-symbol "^3.1.1" -es6-symbol@^3.1.1, es6-symbol@~3.1.3: +es6-map@^0.1.3: + version "0.1.5" + resolved "https://registry.yarnpkg.com/es6-map/-/es6-map-0.1.5.tgz#9136e0503dcc06a301690f0bb14ff4e364e949f0" + integrity sha1-kTbgUD3MBqMBaQ8LsU/042TpSfA= + dependencies: + d "1" + es5-ext "~0.10.14" + es6-iterator "~2.0.1" + es6-set "~0.1.5" + es6-symbol "~3.1.1" + event-emitter "~0.3.5" + +es6-set@~0.1.5: + version "0.1.5" + resolved "https://registry.yarnpkg.com/es6-set/-/es6-set-0.1.5.tgz#d2b3ec5d4d800ced818db538d28974db0a73ccb1" + integrity sha1-0rPsXU2ADO2BjbU40ol02wpzzLE= + dependencies: + d "1" + es5-ext "~0.10.14" + es6-iterator "~2.0.1" + es6-symbol "3.1.1" + event-emitter "~0.3.5" + +es6-symbol@3.1.1: + version "3.1.1" + resolved "https://registry.yarnpkg.com/es6-symbol/-/es6-symbol-3.1.1.tgz#bf00ef4fdab6ba1b46ecb7b629b4c7ed5715cc77" + integrity sha1-vwDvT9q2uhtG7Le2KbTH7VcVzHc= + dependencies: + d "1" + es5-ext "~0.10.14" + +es6-symbol@^3.1.1, es6-symbol@~3.1.1, es6-symbol@~3.1.3: version "3.1.3" resolved "https://registry.yarnpkg.com/es6-symbol/-/es6-symbol-3.1.3.tgz#bad5d3c1bcdac28269f4cb331e431c78ac705d18" integrity sha512-NJ6Yn3FuDinBaBRWl/q5X/s4koRHBrgKAu+yGI6JCBeiu3qrcbJhwT2GeR/EXVfylRk8dpQVJoLEFhK+Mu31NA== @@ -4607,6 +4774,16 @@ es6-symbol@^3.1.1, es6-symbol@~3.1.3: d "^1.0.1" ext "^1.1.2" +es6-weak-map@^2.0.1: + version "2.0.3" + resolved "https://registry.yarnpkg.com/es6-weak-map/-/es6-weak-map-2.0.3.tgz#b6da1f16cc2cc0d9be43e6bdbfc5e7dfcdf31d53" + integrity sha512-p5um32HOTO1kP+w7PRnB+5lQ43Z6muuMuIMffvDN8ZB4GcnjLBV6zGStpbASIMk4DCAvEaamhe2zhyCb/QXXsA== + dependencies: + d "1" + es5-ext "^0.10.46" + es6-iterator "^2.0.3" + es6-symbol "^3.1.1" + escape-html@~1.0.3: version "1.0.3" resolved "https://registry.yarnpkg.com/escape-html/-/escape-html-1.0.3.tgz#0258eae4d3d0c0974de1c169188ef0051d1d1988" @@ -4627,6 +4804,16 @@ escape-string-regexp@^4.0.0: resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz#14ba83a5d373e3d311e5afca29cf5bfad965bf34" integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA== +escope@^3.6.0: + version "3.6.0" + resolved "https://registry.yarnpkg.com/escope/-/escope-3.6.0.tgz#e01975e812781a163a6dadfdd80398dc64c889c3" + integrity sha1-4Bl16BJ4GhY6ba392AOY3GTIicM= + dependencies: + es6-map "^0.1.3" + es6-weak-map "^2.0.1" + esrecurse "^4.1.0" + estraverse "^4.1.1" + eslint-config-standard-kit@0.15.1: version "0.15.1" resolved "https://registry.yarnpkg.com/eslint-config-standard-kit/-/eslint-config-standard-kit-0.15.1.tgz#5a5224a35424729519a519729bbb3fc804e50a3c" @@ -4657,13 +4844,12 @@ eslint-plugin-es@^3.0.0: regexpp "^3.0.0" eslint-plugin-import@^2.22.1: - version "2.23.0" - resolved "https://registry.yarnpkg.com/eslint-plugin-import/-/eslint-plugin-import-2.23.0.tgz#557160f501e4beaefb768fb4165d36eb2a4e543a" - integrity sha512-W5v1f7Cbam6BwbSSKtN6+yoUAms07ozbqAEhLOtf5erEqRv7w67PeZuAuBThaUkzdq2GfBx/5GBvxF+NWJshrQ== + version "2.23.4" + resolved "https://registry.yarnpkg.com/eslint-plugin-import/-/eslint-plugin-import-2.23.4.tgz#8dceb1ed6b73e46e50ec9a5bb2411b645e7d3d97" + integrity sha512-6/wP8zZRsnQFiR3iaPFgh5ImVRM1WN5NUWfTIRqwOdeiGJlBcSk82o1FEVq8yXmy4lkIzTo7YhHCIxlU/2HyEQ== dependencies: array-includes "^3.1.3" array.prototype.flat "^1.2.4" - contains-path "^1.0.0" debug "^2.6.9" doctrine "^2.1.0" eslint-import-resolver-node "^0.3.4" @@ -4715,7 +4901,7 @@ eslint-scope@^4.0.3: esrecurse "^4.1.0" estraverse "^4.1.1" -eslint-scope@^5.0.0, eslint-scope@^5.1.1: +eslint-scope@^5.1.1: version "5.1.1" resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-5.1.1.tgz#e786e59a66cb92b3f6c1fb0d508aab174848f48c" integrity sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw== @@ -4737,6 +4923,13 @@ eslint-utils@^2.0.0, eslint-utils@^2.1.0: dependencies: eslint-visitor-keys "^1.1.0" +eslint-utils@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/eslint-utils/-/eslint-utils-3.0.0.tgz#8aebaface7345bb33559db0a1f13a1d2d48c3672" + integrity sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA== + dependencies: + eslint-visitor-keys "^2.0.0" + eslint-visitor-keys@^1.0.0, eslint-visitor-keys@^1.1.0, eslint-visitor-keys@^1.3.0: version "1.3.0" resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz#30ebd1ef7c2fdff01c3a4f151044af25fab0523e" @@ -4790,27 +4983,29 @@ eslint@^5.6.0: text-table "^0.2.0" eslint@^7.14.0: - version "7.26.0" - resolved "https://registry.yarnpkg.com/eslint/-/eslint-7.26.0.tgz#d416fdcdcb3236cd8f282065312813f8c13982f6" - integrity sha512-4R1ieRf52/izcZE7AlLy56uIHHDLT74Yzz2Iv2l6kDaYvEu9x+wMB5dZArVL8SYGXSYV2YAg70FcW5Y5nGGNIg== + version "7.29.0" + resolved "https://registry.yarnpkg.com/eslint/-/eslint-7.29.0.tgz#ee2a7648f2e729485e4d0bd6383ec1deabc8b3c0" + integrity sha512-82G/JToB9qIy/ArBzIWG9xvvwL3R86AlCjtGw+A29OMZDqhTybz/MByORSukGxeI+YPCR4coYyITKk8BFH9nDA== dependencies: "@babel/code-frame" "7.12.11" - "@eslint/eslintrc" "^0.4.1" + "@eslint/eslintrc" "^0.4.2" ajv "^6.10.0" chalk "^4.0.0" cross-spawn "^7.0.2" debug "^4.0.1" doctrine "^3.0.0" enquirer "^2.3.5" + escape-string-regexp "^4.0.0" eslint-scope "^5.1.1" eslint-utils "^2.1.0" eslint-visitor-keys "^2.0.0" espree "^7.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 "^5.0.0" + glob-parent "^5.1.2" globals "^13.6.0" ignore "^4.0.6" import-fresh "^3.0.0" @@ -4819,7 +5014,7 @@ eslint@^7.14.0: js-yaml "^3.13.1" json-stable-stringify-without-jsonify "^1.0.1" levn "^0.4.1" - lodash "^4.17.21" + lodash.merge "^4.6.2" minimatch "^3.0.4" natural-compare "^1.4.0" optionator "^0.9.1" @@ -4828,7 +5023,7 @@ eslint@^7.14.0: semver "^7.2.1" strip-ansi "^6.0.0" strip-json-comments "^3.1.0" - table "^6.0.4" + table "^6.0.9" text-table "^0.2.0" v8-compile-cache "^2.0.3" @@ -4960,6 +5155,15 @@ eth-json-rpc-middleware@^1.5.0: promise-to-callback "^1.0.0" tape "^4.6.3" +eth-lib@0.2.7: + version "0.2.7" + resolved "https://registry.yarnpkg.com/eth-lib/-/eth-lib-0.2.7.tgz#2f93f17b1e23aec3759cd4a3fe20c1286a3fc1ca" + integrity sha1-L5Pxex4jrsN1nNSj/iDBKGo/wco= + dependencies: + bn.js "^4.11.6" + elliptic "^6.4.0" + xhr-request-promise "^0.1.2" + eth-lib@0.2.8: version "0.2.8" resolved "https://registry.yarnpkg.com/eth-lib/-/eth-lib-0.2.8.tgz#b194058bef4b220ad12ea497431d6cb6aa0623c8" @@ -5046,9 +5250,9 @@ ethashjs@~0.0.7: miller-rabin "^4.0.0" ethereum-bloom-filters@^1.0.6: - version "1.0.9" - resolved "https://registry.yarnpkg.com/ethereum-bloom-filters/-/ethereum-bloom-filters-1.0.9.tgz#4a59dead803af0c9e33834170bd7695df67061ec" - integrity sha512-GiK/RQkAkcVaEdxKVkPcG07PQ5vD7v2MFSHgZmBJSfMzNRHimntdBithsHAT89tAXnIpzVDWt8iaCD1DvkaxGg== + version "1.0.10" + resolved "https://registry.yarnpkg.com/ethereum-bloom-filters/-/ethereum-bloom-filters-1.0.10.tgz#3ca07f4aed698e75bd134584850260246a5fed8a" + integrity sha512-rxJ5OFN3RwjQxDcFP2Z5+Q9ho4eIdEmSc2ht0fCu8Se9nbXjZ7/031uXoUYJ87KHCOdVeiUuwSnoS7hmYAGVHA== dependencies: js-sha3 "^0.8.0" @@ -5095,15 +5299,15 @@ ethereum-ens@^0.8.0: underscore "^1.8.3" web3 "^1.0.0-beta.34" -ethereum-waffle@^3.2.1: - version "3.3.0" - resolved "https://registry.yarnpkg.com/ethereum-waffle/-/ethereum-waffle-3.3.0.tgz#166a0cc1d3b2925f117b20ef0951b3fe72e38e79" - integrity sha512-4xm3RWAPCu5LlaVxYEg0tG3L7g5ovBw1GY/UebrzZ+OTx22vcPjI+bvelFlGBpkdnO5yOIFXjH2eK59tNAe9IA== +ethereum-waffle@^3.1.1, ethereum-waffle@^3.2.1: + version "3.4.0" + resolved "https://registry.yarnpkg.com/ethereum-waffle/-/ethereum-waffle-3.4.0.tgz#990b3c6c26db9c2dd943bf26750a496f60c04720" + integrity sha512-ADBqZCkoSA5Isk486ntKJVjFEawIiC+3HxNqpJqONvh3YXBTNiRfXvJtGuAFLXPG91QaqkGqILEHANAo7j/olQ== dependencies: - "@ethereum-waffle/chai" "^3.3.0" - "@ethereum-waffle/compiler" "^3.3.0" - "@ethereum-waffle/mock-contract" "^3.2.2" - "@ethereum-waffle/provider" "^3.3.0" + "@ethereum-waffle/chai" "^3.4.0" + "@ethereum-waffle/compiler" "^3.4.0" + "@ethereum-waffle/mock-contract" "^3.3.0" + "@ethereum-waffle/provider" "^3.4.0" ethers "^5.0.1" ethereumjs-abi@0.6.5: @@ -5124,7 +5328,7 @@ ethereumjs-abi@0.6.8, ethereumjs-abi@^0.6.8: "ethereumjs-abi@git+https://github.com/ethereumjs/ethereumjs-abi.git": version "0.6.8" - resolved "git+https://github.com/ethereumjs/ethereumjs-abi.git#1a27c59c15ab1e95ee8e5c4ed6ad814c49cc439e" + resolved "git+https://github.com/ethereumjs/ethereumjs-abi.git#ee3994657fa7a427238e6ba92a84d0b529bbcde0" dependencies: bn.js "^4.11.8" ethereumjs-util "^6.0.0" @@ -5195,6 +5399,13 @@ ethereumjs-common@^1.1.0, ethereumjs-common@^1.3.2, ethereumjs-common@^1.5.0: resolved "https://registry.yarnpkg.com/ethereumjs-common/-/ethereumjs-common-1.5.2.tgz#2065dbe9214e850f2e955a80e650cb6999066979" integrity sha512-hTfZjwGX52GS2jcVO6E2sx4YuFnf0Fhp5ylo4pEPhEffNln7vS59Hr5sLnp3/QCazFLluuBZ+FZ6J5HTp0EqCA== +ethereumjs-testrpc@^6.0.3: + version "6.0.3" + resolved "https://registry.yarnpkg.com/ethereumjs-testrpc/-/ethereumjs-testrpc-6.0.3.tgz#7a0b87bf3670f92f607f98fa6a78801d9741b124" + integrity sha512-lAxxsxDKK69Wuwqym2K49VpXtBvLEsXr1sryNG4AkvL5DomMdeCBbu3D87UEevKenLHBiT8GTjARwN6Yj039gA== + dependencies: + webpack "^3.0.0" + ethereumjs-tx@2.1.2, ethereumjs-tx@^2.1.1, ethereumjs-tx@^2.1.2: version "2.1.2" resolved "https://registry.yarnpkg.com/ethereumjs-tx/-/ethereumjs-tx-2.1.2.tgz#5dfe7688bf177b45c9a23f86cf9104d47ea35fed" @@ -5261,7 +5472,7 @@ ethereumjs-util@^5.0.0, ethereumjs-util@^5.0.1, ethereumjs-util@^5.1.1, ethereum rlp "^2.0.0" safe-buffer "^5.1.1" -ethereumjs-util@^7.0.10, ethereumjs-util@^7.0.2, ethereumjs-util@^7.0.7, ethereumjs-util@^7.0.8, ethereumjs-util@^7.0.9: +ethereumjs-util@^7.0.10, ethereumjs-util@^7.0.2, ethereumjs-util@^7.0.7, ethereumjs-util@^7.0.9: version "7.0.10" resolved "https://registry.yarnpkg.com/ethereumjs-util/-/ethereumjs-util-7.0.10.tgz#5fb7b69fa1fda0acc59634cf39d6b0291180fc1f" integrity sha512-c/xThw6A+EAnej5Xk5kOzFzyoSnw0WX0tSlZ6pAsfGVvQj3TItaDg9b1+Fz1RJXA+y2YksKwQnuzgt1eY6LKzw== @@ -5326,7 +5537,7 @@ ethereumjs-wallet@0.6.5: utf8 "^3.0.0" uuid "^3.3.2" -ethers@^4.0.32, ethers@^4.0.40, ethers@^4.0.45: +ethers@^4.0.0-beta.1, ethers@^4.0.32, ethers@^4.0.45: version "4.0.48" resolved "https://registry.yarnpkg.com/ethers/-/ethers-4.0.48.tgz#330c65b8133e112b0613156e57e92d9009d8fbbe" integrity sha512-sZD5K8H28dOrcidzx9f8KYh8083n5BexIO3+SbE4jK83L85FxtpXZBCQdXb8gkg+7sBqomcLhhkU7UHL+F7I2g== @@ -5341,77 +5552,92 @@ ethers@^4.0.32, ethers@^4.0.40, ethers@^4.0.45: uuid "2.0.1" xmlhttprequest "1.8.0" -ethers@^5.0.0, ethers@^5.0.1, ethers@^5.0.2: - version "5.1.4" - resolved "https://registry.yarnpkg.com/ethers/-/ethers-5.1.4.tgz#8ae973705ed962f8f41dc59693704002a38dd18b" - integrity sha512-EAPQ/fgGRu0PoR/VNFnHTMOtG/IZ0AItdW55C9T8ffmVu0rnyllZL404eBF66elJehOLz2kxnUrhXpE7TCpW7g== - dependencies: - "@ethersproject/abi" "5.1.2" - "@ethersproject/abstract-provider" "5.1.0" - "@ethersproject/abstract-signer" "5.1.0" - "@ethersproject/address" "5.1.0" - "@ethersproject/base64" "5.1.0" - "@ethersproject/basex" "5.1.0" - "@ethersproject/bignumber" "5.1.1" - "@ethersproject/bytes" "5.1.0" - "@ethersproject/constants" "5.1.0" - "@ethersproject/contracts" "5.1.1" - "@ethersproject/hash" "5.1.0" - "@ethersproject/hdnode" "5.1.0" - "@ethersproject/json-wallets" "5.1.0" - "@ethersproject/keccak256" "5.1.0" - "@ethersproject/logger" "5.1.0" - "@ethersproject/networks" "5.1.0" - "@ethersproject/pbkdf2" "5.1.0" - "@ethersproject/properties" "5.1.0" - "@ethersproject/providers" "5.1.2" - "@ethersproject/random" "5.1.0" - "@ethersproject/rlp" "5.1.0" - "@ethersproject/sha2" "5.1.0" - "@ethersproject/signing-key" "5.1.0" - "@ethersproject/solidity" "5.1.0" - "@ethersproject/strings" "5.1.0" - "@ethersproject/transactions" "5.1.1" - "@ethersproject/units" "5.1.0" - "@ethersproject/wallet" "5.1.0" - "@ethersproject/web" "5.1.0" - "@ethersproject/wordlists" "5.1.0" - -ethers@^5.0.26: - version "5.2.0" - resolved "https://registry.yarnpkg.com/ethers/-/ethers-5.2.0.tgz#13452e35947ab5d77053286d1f7161ee666c85ba" - integrity sha512-HqFGU2Qab0mAg3y1eHKVMXS4i1gTObMY0/4+x4LiO72NHhJL3Z795gnqyivmwG1J8e5NLSlRSfyIR7TL0Hw3ig== - dependencies: - "@ethersproject/abi" "5.2.0" - "@ethersproject/abstract-provider" "5.2.0" - "@ethersproject/abstract-signer" "5.2.0" - "@ethersproject/address" "5.2.0" - "@ethersproject/base64" "5.2.0" - "@ethersproject/basex" "5.2.0" - "@ethersproject/bignumber" "5.2.0" - "@ethersproject/bytes" "5.2.0" - "@ethersproject/constants" "5.2.0" - "@ethersproject/contracts" "5.2.0" - "@ethersproject/hash" "5.2.0" - "@ethersproject/hdnode" "5.2.0" - "@ethersproject/json-wallets" "5.2.0" - "@ethersproject/keccak256" "5.2.0" - "@ethersproject/logger" "5.2.0" - "@ethersproject/networks" "5.2.0" - "@ethersproject/pbkdf2" "5.2.0" - "@ethersproject/properties" "5.2.0" - "@ethersproject/providers" "5.2.0" - "@ethersproject/random" "5.2.0" - "@ethersproject/rlp" "5.2.0" - "@ethersproject/sha2" "5.2.0" - "@ethersproject/signing-key" "5.2.0" - "@ethersproject/solidity" "5.2.0" - "@ethersproject/strings" "5.2.0" - "@ethersproject/transactions" "5.2.0" - "@ethersproject/units" "5.2.0" - "@ethersproject/wallet" "5.2.0" - "@ethersproject/web" "5.2.0" - "@ethersproject/wordlists" "5.2.0" +ethers@^4.0.40: + version "4.0.49" + resolved "https://registry.yarnpkg.com/ethers/-/ethers-4.0.49.tgz#0eb0e9161a0c8b4761be547396bbe2fb121a8894" + 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.0, ethers@^5.0.1, ethers@^5.0.13, ethers@^5.0.2, ethers@^5.0.26: + version "5.3.1" + resolved "https://registry.yarnpkg.com/ethers/-/ethers-5.3.1.tgz#1f018f0aeb651576cd84fd987a45f0b99646d761" + integrity sha512-xCKmC0gsZ9gks89ZfK3B1y6LlPdvX5fxDtu9SytnpdDJR1M7pmJI+4H0AxQPMgUYr7GtQdmECLR0gWdJQ+lZYw== + dependencies: + "@ethersproject/abi" "5.3.1" + "@ethersproject/abstract-provider" "5.3.0" + "@ethersproject/abstract-signer" "5.3.0" + "@ethersproject/address" "5.3.0" + "@ethersproject/base64" "5.3.0" + "@ethersproject/basex" "5.3.0" + "@ethersproject/bignumber" "5.3.0" + "@ethersproject/bytes" "5.3.0" + "@ethersproject/constants" "5.3.0" + "@ethersproject/contracts" "5.3.0" + "@ethersproject/hash" "5.3.0" + "@ethersproject/hdnode" "5.3.0" + "@ethersproject/json-wallets" "5.3.0" + "@ethersproject/keccak256" "5.3.0" + "@ethersproject/logger" "5.3.0" + "@ethersproject/networks" "5.3.1" + "@ethersproject/pbkdf2" "5.3.0" + "@ethersproject/properties" "5.3.0" + "@ethersproject/providers" "5.3.1" + "@ethersproject/random" "5.3.0" + "@ethersproject/rlp" "5.3.0" + "@ethersproject/sha2" "5.3.0" + "@ethersproject/signing-key" "5.3.0" + "@ethersproject/solidity" "5.3.0" + "@ethersproject/strings" "5.3.0" + "@ethersproject/transactions" "5.3.0" + "@ethersproject/units" "5.3.0" + "@ethersproject/wallet" "5.3.0" + "@ethersproject/web" "5.3.0" + "@ethersproject/wordlists" "5.3.0" + +ethers@^5.0.17: + version "5.4.0" + resolved "https://registry.yarnpkg.com/ethers/-/ethers-5.4.0.tgz#e9fe4b39350bcce5edd410c70bd57ba328ecf474" + integrity sha512-hqN1x0CV8VMpQ25WnNEjaMqtB3nA4DRAb2FSmmNaUbD1dF6kWbHs8YaXbVvD37FCg3GTEyc4rV9Pxafk1ByHKw== + dependencies: + "@ethersproject/abi" "5.4.0" + "@ethersproject/abstract-provider" "5.4.0" + "@ethersproject/abstract-signer" "5.4.0" + "@ethersproject/address" "5.4.0" + "@ethersproject/base64" "5.4.0" + "@ethersproject/basex" "5.4.0" + "@ethersproject/bignumber" "5.4.0" + "@ethersproject/bytes" "5.4.0" + "@ethersproject/constants" "5.4.0" + "@ethersproject/contracts" "5.4.0" + "@ethersproject/hash" "5.4.0" + "@ethersproject/hdnode" "5.4.0" + "@ethersproject/json-wallets" "5.4.0" + "@ethersproject/keccak256" "5.4.0" + "@ethersproject/logger" "5.4.0" + "@ethersproject/networks" "5.4.0" + "@ethersproject/pbkdf2" "5.4.0" + "@ethersproject/properties" "5.4.0" + "@ethersproject/providers" "5.4.0" + "@ethersproject/random" "5.4.0" + "@ethersproject/rlp" "5.4.0" + "@ethersproject/sha2" "5.4.0" + "@ethersproject/signing-key" "5.4.0" + "@ethersproject/solidity" "5.4.0" + "@ethersproject/strings" "5.4.0" + "@ethersproject/transactions" "5.4.0" + "@ethersproject/units" "5.4.0" + "@ethersproject/wallet" "5.4.0" + "@ethersproject/web" "5.4.0" + "@ethersproject/wordlists" "5.4.0" ethjs-unit@0.1.6: version "0.1.6" @@ -5429,6 +5655,14 @@ ethjs-util@0.1.6, ethjs-util@^0.1.3: is-hex-prefixed "1.0.0" strip-hex-prefix "1.0.0" +event-emitter@~0.3.5: + version "0.3.5" + resolved "https://registry.yarnpkg.com/event-emitter/-/event-emitter-0.3.5.tgz#df8c69eef1647923c7157b9ce83840610b02cc39" + integrity sha1-34xp7vFkeSPHFXuc6DhAYQsCzDk= + dependencies: + d "1" + es5-ext "~0.10.14" + event-target-shim@^5.0.0: version "5.0.1" resolved "https://registry.yarnpkg.com/event-target-shim/-/event-target-shim-5.0.1.tgz#5d4d3ebdf9583d63a5333ce2deb7480ab2b05789" @@ -5452,6 +5686,32 @@ evp_bytestokey@^1.0.0, evp_bytestokey@^1.0.3: md5.js "^1.3.4" safe-buffer "^5.1.1" +execa@^0.7.0: + version "0.7.0" + resolved "https://registry.yarnpkg.com/execa/-/execa-0.7.0.tgz#944becd34cc41ee32a63a9faf27ad5a65fc59777" + integrity sha1-lEvs00zEHuMqY6n68nrVpl/Fl3c= + dependencies: + cross-spawn "^5.0.1" + get-stream "^3.0.0" + is-stream "^1.1.0" + npm-run-path "^2.0.0" + p-finally "^1.0.0" + signal-exit "^3.0.0" + strip-eof "^1.0.0" + +execa@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/execa/-/execa-1.0.0.tgz#c6236a5bb4df6d6f15e88e7f017798216749ddd8" + integrity sha512-adbxcyWV46qiHyvSp50TKt05tB4tK3HcmF7/nxfAdhnox83seTDbwnaqKO4sXRy7roHAIFqJP/Rw/AuEbX61LA== + dependencies: + cross-spawn "^6.0.0" + get-stream "^4.0.0" + is-stream "^1.1.0" + npm-run-path "^2.0.0" + p-finally "^1.0.0" + signal-exit "^3.0.0" + strip-eof "^1.0.0" + execa@^4.1.0: version "4.1.0" resolved "https://registry.yarnpkg.com/execa/-/execa-4.1.0.tgz#4e5491ad1572f2f17a77d388c6c857135b22847a" @@ -5477,6 +5737,13 @@ exit@^0.1.2: resolved "https://registry.yarnpkg.com/exit/-/exit-0.1.2.tgz#0632638f8d877cc82107d30a0fff1a17cba1cd0c" integrity sha1-BjJjj42HfMghB9MKD/8aF8uhzQw= +expand-brackets@^0.1.4: + version "0.1.5" + resolved "https://registry.yarnpkg.com/expand-brackets/-/expand-brackets-0.1.5.tgz#df07284e342a807cd733ac5af72411e581d1177b" + integrity sha1-3wcoTjQqgHzXM6xa9yQR5YHRF3s= + dependencies: + is-posix-bracket "^0.1.0" + expand-brackets@^2.1.4: version "2.1.4" resolved "https://registry.yarnpkg.com/expand-brackets/-/expand-brackets-2.1.4.tgz#b77735e315ce30f6b6eff0f83b04151a22449622" @@ -5490,17 +5757,24 @@ expand-brackets@^2.1.4: snapdragon "^0.8.1" to-regex "^3.0.1" +expand-range@^1.8.1: + version "1.8.2" + resolved "https://registry.yarnpkg.com/expand-range/-/expand-range-1.8.2.tgz#a299effd335fe2721ebae8e257ec79644fc85337" + integrity sha1-opnv/TNf4nIeuujiV+x5ZE/IUzc= + dependencies: + fill-range "^2.1.0" + expect@*: - version "26.6.2" - resolved "https://registry.yarnpkg.com/expect/-/expect-26.6.2.tgz#c6b996bf26bf3fe18b67b2d0f51fc981ba934417" - integrity sha512-9/hlOBkQl2l/PLHJx6JjoDF6xPKcJEsUlWKb23rKE7KzeDqUZKXKNMW27KIue5JMdBV9HgmoJPcc8HtO85t9IA== + version "27.0.2" + resolved "https://registry.yarnpkg.com/expect/-/expect-27.0.2.tgz#e66ca3a4c9592f1c019fa1d46459a9d2084f3422" + integrity sha512-YJFNJe2+P2DqH+ZrXy+ydRQYO87oxRUonZImpDodR1G7qo3NYd3pL+NQ9Keqpez3cehczYwZDBC3A7xk3n7M/w== dependencies: - "@jest/types" "^26.6.2" - ansi-styles "^4.0.0" - jest-get-type "^26.3.0" - jest-matcher-utils "^26.6.2" - jest-message-util "^26.6.2" - jest-regex-util "^26.0.0" + "@jest/types" "^27.0.2" + ansi-styles "^5.0.0" + jest-get-type "^27.0.1" + jest-matcher-utils "^27.0.2" + jest-message-util "^27.0.2" + jest-regex-util "^27.0.1" express@^4.14.0: version "4.17.1" @@ -5574,6 +5848,13 @@ external-editor@^3.0.3: iconv-lite "^0.4.24" tmp "^0.0.33" +extglob@^0.3.1: + version "0.3.2" + resolved "https://registry.yarnpkg.com/extglob/-/extglob-0.3.2.tgz#2e18ff3d2f49ab2765cec9023f011daa8d8349a1" + integrity sha1-Lhj/PS9JqydlzskCPwEdqo2DSaE= + dependencies: + is-extglob "^1.0.0" + extglob@^2.0.4: version "2.0.4" resolved "https://registry.yarnpkg.com/extglob/-/extglob-2.0.4.tgz#ad00fe4dc612a9232e8718711dc5cb5ab0285543" @@ -5605,7 +5886,12 @@ fake-merkle-patricia-tree@^1.0.1: dependencies: checkpoint-store "^1.1.0" -fast-deep-equal@^3.1.1: +fast-deep-equal@^1.0.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-1.1.0.tgz#c053477817c86b51daa853c81e059b733d023614" + integrity sha1-wFNHeBfIa1HaqFPIHgWbcz0CNhQ= + +fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3: version "3.1.3" resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525" integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q== @@ -5658,13 +5944,6 @@ figures@^2.0.0: dependencies: escape-string-regexp "^1.0.5" -figures@^3.2.0: - version "3.2.0" - resolved "https://registry.yarnpkg.com/figures/-/figures-3.2.0.tgz#625c18bd293c604dc4a8ddb2febf0c88341746af" - integrity sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg== - dependencies: - escape-string-regexp "^1.0.5" - file-entry-cache@^5.0.1: version "5.0.1" resolved "https://registry.yarnpkg.com/file-entry-cache/-/file-entry-cache-5.0.1.tgz#ca0f6efa6dd3d561333fb14515065c2fafdf439c" @@ -5684,6 +5963,22 @@ file-uri-to-path@1.0.0: resolved "https://registry.yarnpkg.com/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz#553a7b8446ff6f684359c445f1e37a05dacc33dd" integrity sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw== +filename-regex@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/filename-regex/-/filename-regex-2.0.1.tgz#c1c4b9bee3e09725ddb106b75c1e301fe2f18b26" + integrity sha1-wcS5vuPglyXdsQa3XB4wH+LxiyY= + +fill-range@^2.1.0: + version "2.2.4" + resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-2.2.4.tgz#eb1e773abb056dcd8df2bfdf6af59b8b3a936565" + integrity sha512-cnrcCbj01+j2gTG921VZPnHbjmdAf8oQV/iGeV2kZxGSyfYjjTyY79ErsK1WJWMpw6DaApEX72binqJE+/d+5Q== + dependencies: + is-number "^2.1.0" + isobject "^2.0.0" + randomatic "^3.0.0" + repeat-element "^1.1.2" + repeat-string "^1.5.2" + fill-range@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-4.0.0.tgz#d544811d428f98eb06a63dc402d2403c328c38f7" @@ -5832,11 +6127,18 @@ for-each@^0.3.3, for-each@~0.3.3: dependencies: is-callable "^1.1.3" -for-in@^1.0.2: +for-in@^1.0.1, for-in@^1.0.2: version "1.0.2" resolved "https://registry.yarnpkg.com/for-in/-/for-in-1.0.2.tgz#81068d295a8142ec0ac726c6e2200c30fb6d5e80" integrity sha1-gQaNKVqBQuwKxybG4iAMMPttXoA= +for-own@^0.1.4: + version "0.1.5" + resolved "https://registry.yarnpkg.com/for-own/-/for-own-0.1.5.tgz#5265c681a4f294dabbf17c9509b6763aa84510ce" + integrity sha1-UmXGgaTylNq78XyVCbZ2OqhFEM4= + dependencies: + for-in "^1.0.1" + foreach@^2.0.5: version "2.0.5" resolved "https://registry.yarnpkg.com/foreach/-/foreach-2.0.5.tgz#0bee005018aeb260d0a3af3ae658dd0136ec1b99" @@ -5883,10 +6185,10 @@ form-data@~2.3.2: combined-stream "^1.0.6" mime-types "^2.1.12" -forwarded@~0.1.2: - version "0.1.2" - resolved "https://registry.yarnpkg.com/forwarded/-/forwarded-0.1.2.tgz#98c23dab1175657b8c0573e8ceccd91b0ff18c84" - integrity sha1-mMI9qxF1ZXuMBXPozszZGw/xjIQ= +forwarded@0.2.0: + version "0.2.0" + resolved "https://registry.yarnpkg.com/forwarded/-/forwarded-0.2.0.tgz#2269936428aad4c15c7ebe9779a84bf0b2a81811" + integrity sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow== fp-ts@1.19.3: version "1.19.3" @@ -5975,12 +6277,20 @@ fs.realpath@^1.0.0: resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f" integrity sha1-FQStJSMVjKpA20onh8sBQRmU6k8= +fsevents@^1.0.0, fsevents@^1.2.7: + version "1.2.13" + resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-1.2.13.tgz#f325cb0455592428bcf11b383370ef70e3bfcc38" + integrity sha512-oWb1Z6mkHIskLzEJ/XWX0srkpkTQ7vaopMQkyaEIoq0fmtFVxOthb8cCxeT+p3ynTdkk/RZwbgG4brR5BeWECw== + dependencies: + bindings "^1.5.0" + nan "^2.12.1" + fsevents@~2.1.1: version "2.1.3" resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.1.3.tgz#fb738703ae8d2f9fe900c33836ddebee8b97f23e" integrity sha512-Auw9a4AxqWpa9GUfj370BMPzzyncfBABW8Mab7BGWBYDj4Isgq+cDKtx0i6u9jcX9pQDnswsaaOTgTmA5pEjuQ== -fsevents@~2.3.1: +fsevents@~2.3.2: version "2.3.2" resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.2.tgz#8a526f78b8fdf4623b709e0b975c52c24c02fd1a" integrity sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA== @@ -5995,6 +6305,15 @@ functional-red-black-tree@^1.0.1, functional-red-black-tree@~1.0.1: resolved "https://registry.yarnpkg.com/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz#1b0ab3bd553b2a0d6399d29c0e3ea0b252078327" integrity sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc= +ganache-cli@^6.1.0: + version "6.12.2" + resolved "https://registry.yarnpkg.com/ganache-cli/-/ganache-cli-6.12.2.tgz#c0920f7db0d4ac062ffe2375cb004089806f627a" + integrity sha512-bnmwnJDBDsOWBUP8E/BExWf85TsdDEFelQSzihSJm9VChVO1SHp94YXLP5BlA4j/OTxp0wR4R1Tje9OHOuAJVw== + dependencies: + ethereumjs-util "6.2.1" + source-map-support "0.5.12" + yargs "13.2.4" + ganache-core@^2.13.2: version "2.13.2" resolved "https://registry.yarnpkg.com/ganache-core/-/ganache-core-2.13.2.tgz#27e6fc5417c10e6e76e2e646671869d7665814a3" @@ -6071,7 +6390,7 @@ get-stream@^3.0.0: resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-3.0.0.tgz#8e943d1358dc37555054ecbe2edb05aa174ede14" integrity sha1-jpQ9E1jcN1VQVOy+LtsFqhdO3hQ= -get-stream@^4.1.0: +get-stream@^4.0.0, get-stream@^4.1.0: version "4.1.0" resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-4.1.0.tgz#c1b255575f3dc21d59bfc79cd3d2b46b1c3a54b5" integrity sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w== @@ -6097,13 +6416,48 @@ getpass@^0.1.1: dependencies: assert-plus "^1.0.0" -glob-parent@^5.0.0, glob-parent@^5.1.0, glob-parent@~5.1.0: +glob-base@^0.3.0: + version "0.3.0" + resolved "https://registry.yarnpkg.com/glob-base/-/glob-base-0.3.0.tgz#dbb164f6221b1c0b1ccf82aea328b497df0ea3c4" + integrity sha1-27Fk9iIbHAscz4Kuoyi0l98Oo8Q= + dependencies: + glob-parent "^2.0.0" + is-glob "^2.0.0" + +glob-parent@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-2.0.0.tgz#81383d72db054fcccf5336daa902f182f6edbb28" + integrity sha1-gTg9ctsFT8zPUzbaqQLxgvbtuyg= + dependencies: + is-glob "^2.0.0" + +glob-parent@^3.1.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-3.1.0.tgz#9e6af6299d8d3bd2bd40430832bd113df906c5ae" + integrity sha1-nmr2KZ2NO9K9QEMIMr0RPfkGxa4= + dependencies: + is-glob "^3.1.0" + path-dirname "^1.0.0" + +glob-parent@^5.1.0, glob-parent@^5.1.2, glob-parent@~5.1.0, glob-parent@~5.1.2: version "5.1.2" resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4" integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow== dependencies: is-glob "^4.0.1" +glob@7.1.2: + version "7.1.2" + resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.2.tgz#c19c9df9a028702d678612384a6552404c636d15" + integrity sha512-MJTUg1kjuLeQCJ+ccE4Vpa6kKVXkPYJ2mOCQyUuKLcLQsdrMCpBPUi8qVE6+YuaJkozeA9NusTAw3hLr8Xe5EQ== + 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.3: version "7.1.3" resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.3.tgz#3960832d3f1574108342dafd3a67b332c0969df1" @@ -6141,17 +6495,10 @@ globals@^11.7.0: resolved "https://registry.yarnpkg.com/globals/-/globals-11.12.0.tgz#ab8795338868a0babd8525758018c2a7eb95c42e" integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA== -globals@^12.1.0: - version "12.4.0" - resolved "https://registry.yarnpkg.com/globals/-/globals-12.4.0.tgz#a18813576a41b00a24a97e7f815918c2e19925f8" - integrity sha512-BWICuzzDvDoH54NHKCseDanAhE3CeDorgDL5MT6LMXXj2WCnd9UC2szdk4AWLfjdgNBCXLUanXYcpBBKOSWGwg== - dependencies: - type-fest "^0.8.1" - -globals@^13.6.0: - version "13.8.0" - resolved "https://registry.yarnpkg.com/globals/-/globals-13.8.0.tgz#3e20f504810ce87a8d72e55aecf8435b50f4c1b3" - integrity sha512-rHtdA6+PDBIjeEvA91rpqzEvk/k3/i7EeNQiryiWuJH0Hw9cpyJMAt2jtbAwUaRdhD+573X4vWw6IcjKPasi9Q== +globals@^13.6.0, globals@^13.9.0: + version "13.9.0" + resolved "https://registry.yarnpkg.com/globals/-/globals-13.9.0.tgz#4bf2bf635b334a173fb1daf7c5e6b218ecdc06cb" + integrity sha512-74/FduwI/JaIrr1H8e71UbDE+5x7pIPs1C2rrwC52SszOo043CsWOZEMW7o2Y58xwm9b+0RBKDxY5n2sUpEFxA== dependencies: type-fest "^0.20.2" @@ -6160,10 +6507,10 @@ globals@^9.18.0: resolved "https://registry.yarnpkg.com/globals/-/globals-9.18.0.tgz#aa3896b3e69b487f17e31ed2143d69a8e30c2d8a" integrity sha512-S0nG3CLEQiY/ILxqtztTWH/3iRRdyBLw6KMDxnKMchrtbj2OFmehVh0WUCfW3DUrIgx/qFrJPICrq4Z4sTR9UQ== -globby@^11.0.1: - version "11.0.3" - resolved "https://registry.yarnpkg.com/globby/-/globby-11.0.3.tgz#9b1f0cb523e171dd1ad8c7b2a9fb4b644b9593cb" - integrity sha512-ffdmosjA807y7+lA1NM0jELARVmYul/715xiILEjo3hBLPTcirgQNnXECn5g3mtR8TOLCVbkfua1Hpen25/Xcg== +globby@^11.0.3: + version "11.0.4" + resolved "https://registry.yarnpkg.com/globby/-/globby-11.0.4.tgz#2cbaff77c2f2a62e71e9b2813a67b97a3a3001a5" + integrity sha512-9O4MVG9ioZJ08ffbcyVYyLOJLk5JQ688pJ4eMGLpdWLHq/Wr1D9BlriLQyL0E+jbkuePVZXYFj47QM/v093wHg== dependencies: array-union "^2.1.0" dir-glob "^3.0.1" @@ -6214,6 +6561,11 @@ graceful-fs@^4.1.11, graceful-fs@^4.1.2, graceful-fs@^4.1.6, graceful-fs@^4.1.9, resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.6.tgz#ff040b2b0853b23c3d31027523706f1885d76bee" integrity sha512-nTnJ528pbqxYanhpDYsi4Rd8MAeaBA67+RZ10CM1m3bTAVFEDcd5AuA4a6W5YkGZ1iNXHzZz8T6TBKLeBuNriQ== +growl@1.10.3: + version "1.10.3" + resolved "https://registry.yarnpkg.com/growl/-/growl-1.10.3.tgz#1926ba90cf3edfe2adb4927f5880bc22c66c790f" + integrity sha512-hKlsbA5Vu3xsh1Cg3J7jSmX/WaW6A5oBeqzM88oNbCRQFz+zUaXm6yxS4RVytp1scBoJzSYl4YAEOQIt6O8V1Q== + growl@1.10.5: version "1.10.5" resolved "https://registry.yarnpkg.com/growl/-/growl-1.10.5.tgz#f2735dc2283674fa67478b10181059355c369e5e" @@ -6283,16 +6635,70 @@ hardhat-shorthand@^1.0.0: debug "^4.1.1" semver "^6.3.0" +hardhat@^2.0.4: + version "2.4.1" + resolved "https://registry.yarnpkg.com/hardhat/-/hardhat-2.4.1.tgz#2cd1e86ee6ca3a6a473eeb0f55bd3124c8c59250" + integrity sha512-vwllrFypukeE/Q+4ZfWj7j7nUo4ncUhRpsAYUM0Ruuuk6pQlKmRa0A6c0kxRSvvVgQsMud6j+/weYhbMX1wPmQ== + dependencies: + "@ethereumjs/block" "^3.3.0" + "@ethereumjs/blockchain" "^5.3.0" + "@ethereumjs/common" "^2.3.1" + "@ethereumjs/tx" "^3.2.1" + "@ethereumjs/vm" "^5.3.2" + "@ethersproject/abi" "^5.1.2" + "@sentry/node" "^5.18.1" + "@solidity-parser/parser" "^0.11.0" + "@types/bn.js" "^5.1.0" + "@types/lru-cache" "^5.1.0" + abort-controller "^3.0.0" + adm-zip "^0.4.16" + 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" + eth-sig-util "^2.5.2" + ethereum-cryptography "^0.1.2" + ethereumjs-abi "^0.6.8" + ethereumjs-util "^7.0.10" + find-up "^2.1.0" + fp-ts "1.19.3" + fs-extra "^7.0.1" + glob "^7.1.3" + https-proxy-agent "^5.0.0" + immutable "^4.0.0-rc.12" + io-ts "1.10.4" + lodash "^4.17.11" + merkle-patricia-tree "^4.2.0" + mnemonist "^0.38.0" + mocha "^7.1.2" + node-fetch "^2.6.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" + uuid "^3.3.2" + ws "^7.4.6" + hardhat@^2.3.0: - version "2.3.0" - resolved "https://registry.yarnpkg.com/hardhat/-/hardhat-2.3.0.tgz#5c29f8b4d08155c3dc8c908af9713fd5079522d5" - integrity sha512-nc4ro2bM4wPaA6/0Y22o5F5QrifQk2KCyPUUKLPUeFFZoGNGYB8vmeW/k9gV9DdMukdWTzfYlKc2Jn4bfb6tDQ== + version "2.4.0" + resolved "https://registry.yarnpkg.com/hardhat/-/hardhat-2.4.0.tgz#b0db7a6e07fa72414665634ced149bbb10252499" + integrity sha512-IMh7Ws/7fIO5RRkm4nhqS2JWEct0690K35BcFVuIOoIRMcDLKc/7+JSxhey3RkXc5M4qUvdxfQI0LRQx4aqBZw== dependencies: - "@ethereumjs/block" "^3.2.1" - "@ethereumjs/blockchain" "^5.2.1" - "@ethereumjs/common" "^2.2.0" - "@ethereumjs/tx" "^3.1.3" + "@ethereumjs/block" "^3.3.0" + "@ethereumjs/blockchain" "^5.3.0" + "@ethereumjs/common" "^2.3.1" + "@ethereumjs/tx" "^3.2.1" "@ethereumjs/vm" "^5.3.2" + "@ethersproject/abi" "^5.1.2" "@sentry/node" "^5.18.1" "@solidity-parser/parser" "^0.11.0" "@types/bn.js" "^5.1.0" @@ -6314,10 +6720,11 @@ hardhat@^2.3.0: fp-ts "1.19.3" fs-extra "^7.0.1" glob "^7.1.3" + https-proxy-agent "^5.0.0" immutable "^4.0.0-rc.12" io-ts "1.10.4" lodash "^4.17.11" - merkle-patricia-tree "^4.1.0" + merkle-patricia-tree "^4.2.0" mnemonist "^0.38.0" mocha "^7.1.2" node-fetch "^2.6.0" @@ -6332,7 +6739,7 @@ hardhat@^2.3.0: "true-case-path" "^2.2.1" tsort "0.0.1" uuid "^3.3.2" - ws "^7.2.1" + ws "^7.4.6" has-ansi@^2.0.0: version "2.0.0" @@ -6346,6 +6753,11 @@ has-bigints@^1.0.1: resolved "https://registry.yarnpkg.com/has-bigints/-/has-bigints-1.0.1.tgz#64fe6acb020673e3b78db035a5af69aa9d07b113" integrity sha512-LSBS2LjbNBTf6287JEbEzvJgftkF5qFkmCo9hDRpAzKhUOlJ+hx8dd4USs00SgsUNwc4617J9ki5YtEClM2ffA== +has-flag@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-2.0.0.tgz#e8207af1cc7b30d446cc70b734b5e8be18f88d51" + integrity sha1-6CB68cx7MNRGzHC3NLXovhj4jVE= + has-flag@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd" @@ -6420,6 +6832,11 @@ hash-base@^3.0.0: readable-stream "^3.6.0" safe-buffer "^5.2.0" +hash-test-vectors@^1.3.2: + version "1.3.2" + resolved "https://registry.yarnpkg.com/hash-test-vectors/-/hash-test-vectors-1.3.2.tgz#f050fde1aff46ec28dcf4f70e4e3238cd5000f4c" + integrity sha1-8FD94a/0bsKNz09w5OMjjNUAD0w= + hash.js@1.1.3: version "1.1.3" resolved "https://registry.yarnpkg.com/hash.js/-/hash.js-1.1.3.tgz#340dedbe6290187151c1ea1d777a3448935df846" @@ -6436,6 +6853,11 @@ hash.js@1.1.7, hash.js@^1.0.0, hash.js@^1.0.3, hash.js@^1.1.7: inherits "^2.0.3" minimalistic-assert "^1.0.1" +he@1.1.1: + version "1.1.1" + resolved "https://registry.yarnpkg.com/he/-/he-1.1.1.tgz#93410fd21b009735151f8868c2f271f3427e23fd" + integrity sha1-k0EP0hsAlzUVH4howvJx80J+I/0= + he@1.2.0, he@^1.1.1: version "1.2.0" resolved "https://registry.yarnpkg.com/he/-/he-1.2.0.tgz#84ae65fa7eafb165fddb61566ae14baf05664f0f" @@ -6447,14 +6869,19 @@ heap@0.2.6: integrity sha1-CH4fELBGky/IWU3Z5tN4r8nR5aw= highlight.js@^10.4.0, highlight.js@^10.4.1: - version "10.7.2" - resolved "https://registry.yarnpkg.com/highlight.js/-/highlight.js-10.7.2.tgz#89319b861edc66c48854ed1e6da21ea89f847360" - integrity sha512-oFLl873u4usRM9K63j4ME9u3etNF0PLiJhSQ8rdfuL51Wn3zkD6drf9ZW0dOzjnZI22YYG24z30JcmfCZjMgYg== + version "10.7.3" + resolved "https://registry.yarnpkg.com/highlight.js/-/highlight.js-10.7.3.tgz#697272e3991356e40c3cac566a74eef681756531" + integrity sha512-tzcUFauisWKNHaRkN4Wjl/ZA07gENAjFl3J/c480dprkGTg5EQstgaNFqBfUqCq54kZRIEcreTsAgF/m2quD7A== -highlightjs-solidity@^1.0.22: - version "1.0.22" - resolved "https://registry.yarnpkg.com/highlightjs-solidity/-/highlightjs-solidity-1.0.22.tgz#da3537cfcd4d49505bdc56700132422f403f5924" - integrity sha512-Ha1TDrtOwCDCSa+D99CMCdm2fOlpMqcEzC45rpwyr6SOPvor69tqhecolUA7TjnfHU8zJswH3lnxI1ti0tLmFw== +highlight.js@^9.15.8: + version "9.18.5" + resolved "https://registry.yarnpkg.com/highlight.js/-/highlight.js-9.18.5.tgz#d18a359867f378c138d6819edfc2a8acd5f29825" + integrity sha512-a5bFyofd/BHCX52/8i8uJkjr9DYwXIPnM/plwI6W7ezItLGqzt7X2G2nXuYSfsIJdkwwj/g9DG1LkcGJI/dDoA== + +highlightjs-solidity@^1.0.18, highlightjs-solidity@^1.1.1: + version "1.1.1" + resolved "https://registry.yarnpkg.com/highlightjs-solidity/-/highlightjs-solidity-1.1.1.tgz#ed0f246d0f8cba647291baff68fb131252067424" + integrity sha512-NNcuj6GC0OP8qIrXVaqUA33d/nQoGvwRPS3FR2juIT+I1LAcNkebLbEp1AxzH0TiQ9InPxG62P/FnON8Ns15sQ== hmac-drbg@^1.0.0, hmac-drbg@^1.0.1: version "1.0.1" @@ -6546,6 +6973,11 @@ http-signature@~1.2.0: jsprim "^1.2.2" sshpk "^1.7.0" +https-browserify@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/https-browserify/-/https-browserify-1.0.0.tgz#ec06c10e0a34c0f2faf199f7fd7fc78fffd03c73" + integrity sha1-7AbBDgo0wPL68Zn3/X/Hj//QPHM= + https-proxy-agent@^5.0.0: version "5.0.0" resolved "https://registry.yarnpkg.com/https-proxy-agent/-/https-proxy-agent-5.0.0.tgz#e2a90542abb68a762e0a0850f6c9edadfd8506b2" @@ -6583,9 +7015,9 @@ iconv-lite@0.4.24, iconv-lite@^0.4.24: safer-buffer ">= 2.1.2 < 3" iconv-lite@^0.6.2: - version "0.6.2" - resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.6.2.tgz#ce13d1875b0c3a674bd6a04b7f76b01b1b6ded01" - integrity sha512-2y91h5OpQlolefMPmUlivelittSWy0rP+oYVpn6A7GwVHNE8AWzoYOBNmlwks3LobaJxgHCYZAnyNo2GgpNRNQ== + version "0.6.3" + resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.6.3.tgz#a52f80bf38da1952eb5c681790719871a1a72501" + integrity sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw== dependencies: safer-buffer ">= 2.1.2 < 3.0.0" @@ -6596,7 +7028,7 @@ idna-uts46-hx@^2.3.1: dependencies: punycode "2.1.0" -ieee754@^1.1.13: +ieee754@^1.1.13, ieee754@^1.1.4, ieee754@^1.2.1: version "1.2.1" resolved "https://registry.yarnpkg.com/ieee754/-/ieee754-1.2.1.tgz#8eb7a10a63fff25d15a57b001586d177d1b0d352" integrity sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA== @@ -6670,6 +7102,11 @@ inherits@2, inherits@2.0.4, inherits@^2.0.1, inherits@^2.0.3, inherits@^2.0.4, i resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c" integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ== +inherits@2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.1.tgz#b17d08d326b4423e568eff719f91b0b1cbdf69f1" + integrity sha1-sX0I0ya0Qj5Wjv9xn5GwscvfafE= + inherits@2.0.3: version "2.0.3" resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.3.tgz#633c2c83e3da42a502f52466022480f4208261de" @@ -6694,6 +7131,11 @@ inquirer@^6.2.2: strip-ansi "^5.1.0" through "^2.3.6" +interpret@^1.0.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/interpret/-/interpret-1.4.0.tgz#665ab8bc4da27a774a40584e812e3e0fa45b1a1e" + integrity sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA== + invariant@^2.2.2: version "2.2.4" resolved "https://registry.yarnpkg.com/invariant/-/invariant-2.2.4.tgz#610f3c92c9359ce1db616e538008d23ff35158e6" @@ -6706,6 +7148,11 @@ invert-kv@^1.0.0: resolved "https://registry.yarnpkg.com/invert-kv/-/invert-kv-1.0.0.tgz#104a8e4aaca6d3d8cd157a8ef8bfab2d7a3ffdb6" integrity sha1-EEqOSqym09jNFXqO+L+rLXo//bY= +invert-kv@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/invert-kv/-/invert-kv-2.0.0.tgz#7393f5afa59ec9ff5f67a27620d11c226e3eec02" + integrity sha512-wPVv/y/QQ/Uiirj/vh3oP+1Ww+AWehmi1g5fFWGPF6IpCBCDVrhgHRMvrLfdYcwDh3QJbGXDW4JAuzxElLSqKA== + io-ts@1.10.4: version "1.10.4" resolved "https://registry.yarnpkg.com/io-ts/-/io-ts-1.10.4.tgz#cd5401b138de88e4f920adbcb7026e2d1967e6e2" @@ -6713,6 +7160,11 @@ io-ts@1.10.4: dependencies: fp-ts "^1.0.0" +ip@^1.1.5: + version "1.1.5" + resolved "https://registry.yarnpkg.com/ip/-/ip-1.1.5.tgz#bdded70114290828c0a039e72ef25f5aaec4354a" + integrity sha1-vd7XARQpCCjAoDnnLvJfWq7ENUo= + ipaddr.js@1.9.1: version "1.9.1" resolved "https://registry.yarnpkg.com/ipaddr.js/-/ipaddr.js-1.9.1.tgz#bff38543eeb8984825079ff3a2a8e6cbd46781b3" @@ -6749,6 +7201,13 @@ is-bigint@^1.0.1: resolved "https://registry.yarnpkg.com/is-bigint/-/is-bigint-1.0.2.tgz#ffb381442503235ad245ea89e45b3dbff040ee5a" integrity sha512-0JV5+SOCQkIdzjBK9buARcV804Ddu7A0Qet6sHi3FimE9ne6m4BGQZfRn+NZiXbBk4F4XmHfDZIipLj9pX8dSA== +is-binary-path@^1.0.0: + version "1.0.1" + resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-1.0.1.tgz#75f16642b480f187a711c814161fd3a4a7655898" + integrity sha1-dfFmQrSA8YenEcgUFh/TpKdlWJg= + dependencies: + binary-extensions "^1.0.0" + is-binary-path@~2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-2.1.0.tgz#ea1f7f3b80f064236e83470f86c09c254fb45b09" @@ -6839,6 +7298,18 @@ is-docker@^2.0.0: resolved "https://registry.yarnpkg.com/is-docker/-/is-docker-2.2.1.tgz#33eeabe23cfe86f14bde4408a02c0cfb853acdaa" integrity sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ== +is-dotfile@^1.0.0: + version "1.0.3" + resolved "https://registry.yarnpkg.com/is-dotfile/-/is-dotfile-1.0.3.tgz#a6a2f32ffd2dfb04f5ca25ecd0f6b83cf798a1e1" + integrity sha1-pqLzL/0t+wT1yiXs0Pa4PPeYoeE= + +is-equal-shallow@^0.1.3: + version "0.1.3" + resolved "https://registry.yarnpkg.com/is-equal-shallow/-/is-equal-shallow-0.1.3.tgz#2238098fc221de0bcfa5d9eac4c45d638aa1c534" + integrity sha1-IjgJj8Ih3gvPpdnqxMRdY4qhxTQ= + dependencies: + is-primitive "^2.0.0" + is-extendable@^0.1.0, is-extendable@^0.1.1: version "0.1.1" resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-0.1.1.tgz#62b110e289a471418e3ec36a617d472e301dfc89" @@ -6851,7 +7322,12 @@ is-extendable@^1.0.1: dependencies: is-plain-object "^2.0.4" -is-extglob@^2.1.1: +is-extglob@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-1.0.0.tgz#ac468177c4943405a092fc8f29760c6ffc6206c0" + integrity sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA= + +is-extglob@^2.1.0, is-extglob@^2.1.1: version "2.1.1" resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2" integrity sha1-qIwCU1eR8C7TfHahueqXc8gz+MI= @@ -6893,6 +7369,20 @@ is-generator-function@^1.0.7: resolved "https://registry.yarnpkg.com/is-generator-function/-/is-generator-function-1.0.9.tgz#e5f82c2323673e7fcad3d12858c83c4039f6399c" integrity sha512-ZJ34p1uvIfptHCN7sFTjGibB9/oBg17sHqzDLfuwhvmN/qLVvIQXRQ8licZQ35WJ8KuEQt/etnnzQFI9C9Ue/A== +is-glob@^2.0.0, is-glob@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-2.0.1.tgz#d096f926a3ded5600f3fdfd91198cb0888c2d863" + integrity sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM= + dependencies: + is-extglob "^1.0.0" + +is-glob@^3.1.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-3.1.0.tgz#7ba5ae24217804ac70707b96922567486cc3e84a" + integrity sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo= + dependencies: + is-extglob "^2.1.0" + is-glob@^4.0.0, is-glob@^4.0.1, is-glob@~4.0.1: version "4.0.1" resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.1.tgz#7567dbe9f2f5e2467bc77ab83c4a29482407a5dc" @@ -6915,6 +7405,13 @@ is-number-object@^1.0.4: resolved "https://registry.yarnpkg.com/is-number-object/-/is-number-object-1.0.5.tgz#6edfaeed7950cff19afedce9fbfca9ee6dd289eb" integrity sha512-RU0lI/n95pMoUKu9v1BZP5MBcZuNSVJkMkAG2dJqC4z2GlkGUNeH68SuHuBKBD/XFe+LHZ+f9BKkLET60Niedw== +is-number@^2.1.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/is-number/-/is-number-2.1.0.tgz#01fcbbb393463a548f2f466cce16dece49db908f" + integrity sha1-Afy7s5NGOlSPL0ZszhbezknbkI8= + dependencies: + kind-of "^3.0.2" + is-number@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/is-number/-/is-number-3.0.0.tgz#24fd6201a4782cf50561c810276afc7d12d71195" @@ -6922,6 +7419,11 @@ is-number@^3.0.0: dependencies: kind-of "^3.0.2" +is-number@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/is-number/-/is-number-4.0.0.tgz#0026e37f5454d73e356dfe6564699867c6a7f0ff" + integrity sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ== + is-number@^7.0.0: version "7.0.0" resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b" @@ -6949,7 +7451,17 @@ is-plain-object@^2.0.3, is-plain-object@^2.0.4: dependencies: isobject "^3.0.1" -is-regex@^1.0.4, is-regex@^1.1.2: +is-posix-bracket@^0.1.0: + version "0.1.1" + resolved "https://registry.yarnpkg.com/is-posix-bracket/-/is-posix-bracket-0.1.1.tgz#3334dc79774368e92f016e6fbc0a88f5cd6e6bc4" + integrity sha1-MzTceXdDaOkvAW5vvAqI9c1ua8Q= + +is-primitive@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/is-primitive/-/is-primitive-2.0.0.tgz#207bab91638499c07b2adf240a41a87210034575" + integrity sha1-IHurkWOEmcB7Kt8kCkGochADRXU= + +is-regex@^1.0.4, is-regex@^1.1.3: version "1.1.3" resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.1.3.tgz#d029f9aff6448b93ebbe3f33dac71511fdcbef9f" integrity sha512-qSVXFz28HM7y+IWX6vLCsexdlvzT1PJNFSBuaQLQ5o0IEw8UDYW6/2+eCMVyIsbM8CNLX2a/QWmSpyxYEHY7CQ== @@ -6974,7 +7486,7 @@ is-retry-allowed@^1.0.0: resolved "https://registry.yarnpkg.com/is-retry-allowed/-/is-retry-allowed-1.2.0.tgz#d778488bd0a4666a3be8a1482b9f2baafedea8b4" integrity sha512-RUbUeKwvm3XG2VYamhJL1xFktgjvPzL0Hq8C+6yrWIswDy3BIXGqCxhxkc30N9jqK311gVU137K8Ei55/zVJRg== -is-stream@^1.0.0, is-stream@^1.0.1: +is-stream@^1.0.0, is-stream@^1.0.1, is-stream@^1.1.0: version "1.1.0" resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-1.1.0.tgz#12d4a3dd4e68e0b79ceb8dbc84173ae80d91ca44" integrity sha1-EtSj3U5o4Lec6428hBc66A2RykQ= @@ -6984,7 +7496,7 @@ is-stream@^2.0.0: resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.0.tgz#bde9c32680d6fae04129d6ac9d921ce7815f78e3" integrity sha512-XCoy+WlUr7d1+Z8GgSuXmpuUFC9fOhRXglJMx+dwLKTkL44Cjd4W1Z5P+BQZpr+cR93aGP4S/s7Ftw6Nd/kiEw== -is-string@^1.0.5: +is-string@^1.0.5, is-string@^1.0.6: version "1.0.6" resolved "https://registry.yarnpkg.com/is-string/-/is-string-1.0.6.tgz#3fe5d5992fb0d93404f32584d4b0179a71b54a5f" integrity sha512-2gdzbKUuqtQ3lYNrUTQYoClPhm7oQu4UdpSZMp1/DGgkHBT8E2Z1l0yMdb6D4zNAxwDiMv8MdulKROJGNl0Q0w== @@ -7044,7 +7556,7 @@ isarray@0.0.1: resolved "https://registry.yarnpkg.com/isarray/-/isarray-0.0.1.tgz#8a18acfca9a8f4177e09abfc6038939b05d1eedf" integrity sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8= -isarray@1.0.0, isarray@~1.0.0: +isarray@1.0.0, isarray@^1.0.0, isarray@~1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11" integrity sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE= @@ -7054,6 +7566,11 @@ isexe@^2.0.0: resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10" integrity sha1-6PvzdNxVb/iUehDcsFctYz8s+hA= +iso-url@~0.4.7: + version "0.4.7" + resolved "https://registry.yarnpkg.com/iso-url/-/iso-url-0.4.7.tgz#de7e48120dae46921079fe78f325ac9e9217a385" + integrity sha512-27fFRDnPAMnHGLq36bWTpKET+eiXct3ENlCcdcMdk+mjXrb2kw3mhBUg1B7ewAC0kVzlOPhADzQgz1SE6Tglog== + isobject@^2.0.0: version "2.1.0" resolved "https://registry.yarnpkg.com/isobject/-/isobject-2.1.0.tgz#f065561096a3f1da2ef46272f815c840d87e0c89" @@ -7079,50 +7596,50 @@ isurl@^1.0.0-alpha5: has-to-string-tag-x "^1.2.0" is-object "^1.0.1" -jest-diff@^26.6.2: - version "26.6.2" - resolved "https://registry.yarnpkg.com/jest-diff/-/jest-diff-26.6.2.tgz#1aa7468b52c3a68d7d5c5fdcdfcd5e49bd164394" - integrity sha512-6m+9Z3Gv9wN0WFVasqjCL/06+EFCMTqDEUl/b87HYK2rAPTyfz4ZIuSlPhY51PIQRWx5TaxeF1qmXKe9gfN3sA== +jest-diff@^27.0.2: + version "27.0.2" + resolved "https://registry.yarnpkg.com/jest-diff/-/jest-diff-27.0.2.tgz#f315b87cee5dc134cf42c2708ab27375cc3f5a7e" + integrity sha512-BFIdRb0LqfV1hBt8crQmw6gGQHVDhM87SpMIZ45FPYKReZYG5er1+5pIn2zKqvrJp6WNox0ylR8571Iwk2Dmgw== dependencies: chalk "^4.0.0" - diff-sequences "^26.6.2" - jest-get-type "^26.3.0" - pretty-format "^26.6.2" + diff-sequences "^27.0.1" + jest-get-type "^27.0.1" + pretty-format "^27.0.2" -jest-get-type@^26.3.0: - version "26.3.0" - resolved "https://registry.yarnpkg.com/jest-get-type/-/jest-get-type-26.3.0.tgz#e97dc3c3f53c2b406ca7afaed4493b1d099199e0" - integrity sha512-TpfaviN1R2pQWkIihlfEanwOXK0zcxrKEE4MlU6Tn7keoXdN6/3gK/xl0yEh8DOunn5pOVGKf8hB4R9gVh04ig== +jest-get-type@^27.0.1: + version "27.0.1" + resolved "https://registry.yarnpkg.com/jest-get-type/-/jest-get-type-27.0.1.tgz#34951e2b08c8801eb28559d7eb732b04bbcf7815" + integrity sha512-9Tggo9zZbu0sHKebiAijyt1NM77Z0uO4tuWOxUCujAiSeXv30Vb5D4xVF4UR4YWNapcftj+PbByU54lKD7/xMg== -jest-matcher-utils@^26.6.2: - version "26.6.2" - resolved "https://registry.yarnpkg.com/jest-matcher-utils/-/jest-matcher-utils-26.6.2.tgz#8e6fd6e863c8b2d31ac6472eeb237bc595e53e7a" - integrity sha512-llnc8vQgYcNqDrqRDXWwMr9i7rS5XFiCwvh6DTP7Jqa2mqpcCBBlpCbn+trkG0KNhPu/h8rzyBkriOtBstvWhw== +jest-matcher-utils@^27.0.2: + version "27.0.2" + resolved "https://registry.yarnpkg.com/jest-matcher-utils/-/jest-matcher-utils-27.0.2.tgz#f14c060605a95a466cdc759acc546c6f4cbfc4f0" + integrity sha512-Qczi5xnTNjkhcIB0Yy75Txt+Ez51xdhOxsukN7awzq2auZQGPHcQrJ623PZj0ECDEMOk2soxWx05EXdXGd1CbA== dependencies: chalk "^4.0.0" - jest-diff "^26.6.2" - jest-get-type "^26.3.0" - pretty-format "^26.6.2" + jest-diff "^27.0.2" + jest-get-type "^27.0.1" + pretty-format "^27.0.2" -jest-message-util@^26.6.2: - version "26.6.2" - resolved "https://registry.yarnpkg.com/jest-message-util/-/jest-message-util-26.6.2.tgz#58173744ad6fc0506b5d21150b9be56ef001ca07" - integrity sha512-rGiLePzQ3AzwUshu2+Rn+UMFk0pHN58sOG+IaJbk5Jxuqo3NYO1U2/MIR4S1sKgsoYSXSzdtSa0TgrmtUwEbmA== +jest-message-util@^27.0.2: + version "27.0.2" + resolved "https://registry.yarnpkg.com/jest-message-util/-/jest-message-util-27.0.2.tgz#181c9b67dff504d8f4ad15cba10d8b80f272048c" + integrity sha512-rTqWUX42ec2LdMkoUPOzrEd1Tcm+R1KfLOmFK+OVNo4MnLsEaxO5zPDb2BbdSmthdM/IfXxOZU60P/WbWF8BTw== dependencies: - "@babel/code-frame" "^7.0.0" - "@jest/types" "^26.6.2" + "@babel/code-frame" "^7.12.13" + "@jest/types" "^27.0.2" "@types/stack-utils" "^2.0.0" chalk "^4.0.0" graceful-fs "^4.2.4" - micromatch "^4.0.2" - pretty-format "^26.6.2" + micromatch "^4.0.4" + pretty-format "^27.0.2" slash "^3.0.0" - stack-utils "^2.0.2" + stack-utils "^2.0.3" -jest-regex-util@^26.0.0: - version "26.0.0" - resolved "https://registry.yarnpkg.com/jest-regex-util/-/jest-regex-util-26.0.0.tgz#d25e7184b36e39fd466c3bc41be0971e821fee28" - integrity sha512-Gv3ZIs/nA48/Zvjrl34bf+oD76JHiGDUxNOVgUjh3j890sblXryjY4rss71fPtD/njchl6PSE2hIhvyWa1eT0A== +jest-regex-util@^27.0.1: + version "27.0.1" + resolved "https://registry.yarnpkg.com/jest-regex-util/-/jest-regex-util-27.0.1.tgz#69d4b1bf5b690faa3490113c47486ed85dd45b68" + integrity sha512-6nY6QVcpTgEKQy1L41P4pr3aOddneK17kn3HJw6SdwGiKfgCGTvH02hVXL0GU8GEKtPH83eD2DIDgxHXOxVohQ== js-sha3@0.5.7, js-sha3@^0.5.7: version "0.5.7" @@ -7134,6 +7651,11 @@ js-sha3@0.8.0, js-sha3@^0.8.0: resolved "https://registry.yarnpkg.com/js-sha3/-/js-sha3-0.8.0.tgz#b9b7a5da73afad7dedd0f8c463954cbde6818840" integrity sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q== +js-string-escape@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/js-string-escape/-/js-string-escape-1.0.1.tgz#e2625badbc0d67c7533e9edc1068c587ae4137ef" + integrity sha1-4mJbrbwNZ8dTPp7cEGjFh65BN+8= + "js-tokens@^3.0.0 || ^4.0.0", js-tokens@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499" @@ -7161,9 +7683,9 @@ js-yaml@^3.12.0, js-yaml@^3.13.0, js-yaml@^3.13.1, js-yaml@^3.14.0: esprima "^4.0.0" jsbi@^3.1.1, jsbi@^3.1.4: - version "3.1.4" - resolved "https://registry.yarnpkg.com/jsbi/-/jsbi-3.1.4.tgz#9654dd02207a66a4911b4e4bb74265bc2cbc9dd0" - integrity sha512-52QRRFSsi9impURE8ZUbzAMCLjPm4THO7H2fcuIvaaeFTbSysvkodbQQXIVsNgq/ypDbq6dJiuGKL0vZ/i9hUg== + version "3.1.5" + resolved "https://registry.yarnpkg.com/jsbi/-/jsbi-3.1.5.tgz#70c2aaa2f75e1dc7604fed45298061ca23724046" + integrity sha512-w2BY0VOYC1ahe+w6Qhl4SFoPvPsZ9NPHY4bwass+LCgU7RK3PBoVQlQ3G1s7vI8W3CYyJiEXcbKF7FIM/L8q3Q== jsbn@~0.1.0: version "0.1.1" @@ -7185,6 +7707,11 @@ json-buffer@3.0.0: resolved "https://registry.yarnpkg.com/json-buffer/-/json-buffer-3.0.0.tgz#5b1f397afc75d677bde8bcfc0e47e1f9a3d9a898" integrity sha1-Wx85evx11ne96Lz8Dkfh+aPZqJg= +json-loader@^0.5.4: + version "0.5.7" + resolved "https://registry.yarnpkg.com/json-loader/-/json-loader-0.5.7.tgz#dca14a70235ff82f0ac9a3abeb60d337a365185d" + integrity sha512-QLPs8Dj7lnf3e3QYS1zkCo+4ZwqOiF9d/nZnYozTISxXWCfNs9yuky5rJw4/W34s7POaNlbZmQGaB5NiXCbP4w== + json-parse-better-errors@^1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz#bb867cfb3450e69107c131d1c514bab3dc8bcaa9" @@ -7219,6 +7746,11 @@ json-rpc-random-id@^1.0.0: resolved "https://registry.yarnpkg.com/json-rpc-random-id/-/json-rpc-random-id-1.0.1.tgz#ba49d96aded1444dbb8da3d203748acbbcdec8c8" integrity sha1-uknZat7RRE27jaPSA3SKy7zeyMg= +json-schema-traverse@^0.3.0: + version "0.3.1" + resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.3.1.tgz#349a6d44c53a51de89b40805c5d5e59b417d3340" + integrity sha1-NJptRMU6Ud6JtAgFxdXlm0F9M0A= + json-schema-traverse@^0.4.1: version "0.4.1" resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660" @@ -7251,6 +7783,13 @@ json-stringify-safe@~5.0.1: resolved "https://registry.yarnpkg.com/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz#1296a2d58fd45f19a0f6ce01d65701e2c735b6eb" integrity sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus= +json-text-sequence@~0.1.0: + version "0.1.1" + resolved "https://registry.yarnpkg.com/json-text-sequence/-/json-text-sequence-0.1.1.tgz#a72f217dc4afc4629fff5feb304dc1bd51a2f3d2" + integrity sha1-py8hfcSvxGKf/1/rME3BvVGi89I= + dependencies: + delimit-stream "0.1.0" + json2csv@^5.0.6: version "5.0.6" resolved "https://registry.yarnpkg.com/json2csv/-/json2csv-5.0.6.tgz#590e0e1b9579e59baa53bda0c0d840f4d8009687" @@ -7378,6 +7917,11 @@ klaw@^1.0.0: optionalDependencies: graceful-fs "^4.1.9" +lazy-cache@^1.0.3: + version "1.0.4" + resolved "https://registry.yarnpkg.com/lazy-cache/-/lazy-cache-1.0.4.tgz#a1d78fc3a50474cb80845d3b3b6e1da49a446e8e" + integrity sha1-odePw6UEdMuAhF07O24dpJpEbo4= + lcid@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/lcid/-/lcid-1.0.0.tgz#308accafa0bc483a3867b4b6f2b9506251d1b835" @@ -7385,6 +7929,13 @@ lcid@^1.0.0: dependencies: invert-kv "^1.0.0" +lcid@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/lcid/-/lcid-2.0.0.tgz#6ef5d2df60e52f82eb228a4c373e8d1f397253cf" + integrity sha512-avPEb8P8EGnwXKClwsNUgryVjllcRqtMYa49NTsbQagYuT1DcXnl1915oxWjoyGrXR6zH/Y0Zc96xWsPcoDKeA== + dependencies: + invert-kv "^2.0.0" + level-codec@^9.0.0: version "9.0.2" resolved "https://registry.yarnpkg.com/level-codec/-/level-codec-9.0.2.tgz#fd60df8c64786a80d44e63423096ffead63d8cbc" @@ -7625,14 +8176,12 @@ lint-staged@^10.5.3: stringify-object "^3.3.0" listr2@^3.2.2: - version "3.8.2" - resolved "https://registry.yarnpkg.com/listr2/-/listr2-3.8.2.tgz#99b138ad1cfb08f1b0aacd422972e49b2d814b99" - integrity sha512-E28Fw7Zd3HQlCJKzb9a8C8M0HtFWQeucE+S8YrSrqZObuCLPRHMRrR8gNmYt65cU9orXYHwvN5agXC36lYt7VQ== + version "3.10.0" + resolved "https://registry.yarnpkg.com/listr2/-/listr2-3.10.0.tgz#58105a53ed7fa1430d1b738c6055ef7bb006160f" + integrity sha512-eP40ZHihu70sSmqFNbNy2NL1YwImmlMmPh9WO5sLmPDleurMHt3n+SwEWNu2kzKScexZnkyFtc1VI0z/TGlmpw== dependencies: - chalk "^4.1.1" cli-truncate "^2.1.0" - figures "^3.2.0" - indent-string "^4.0.0" + colorette "^1.2.2" log-update "^4.0.0" p-map "^4.0.0" rxjs "^6.6.7" @@ -7650,6 +8199,16 @@ load-json-file@^1.0.0: pinkie-promise "^2.0.0" strip-bom "^2.0.0" +load-json-file@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/load-json-file/-/load-json-file-2.0.0.tgz#7947e42149af80d696cbf797bcaabcfe1fe29ca8" + integrity sha1-eUfkIUmvgNaWy/eXvKq8/h/inKg= + dependencies: + graceful-fs "^4.1.2" + parse-json "^2.2.0" + pify "^2.0.0" + strip-bom "^3.0.0" + load-json-file@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/load-json-file/-/load-json-file-4.0.0.tgz#2f5f45ab91e33216234fd53adab668eb4ec0993b" @@ -7660,6 +8219,20 @@ load-json-file@^4.0.0: pify "^3.0.0" strip-bom "^3.0.0" +loader-runner@^2.3.0: + version "2.4.0" + resolved "https://registry.yarnpkg.com/loader-runner/-/loader-runner-2.4.0.tgz#ed47066bfe534d7e84c4c7b9998c2a75607d9357" + integrity sha512-Jsmr89RcXGIwivFY21FcRrisYZfvLMTWx5kOLc+JTxtpBOG6xML0vzbc6SEQG2FO9/4Fc3wW4LVcB5DmGflaRw== + +loader-utils@^1.1.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/loader-utils/-/loader-utils-1.4.0.tgz#c579b5e34cb34b1a74edc6c1fb36bfa371d5a613" + integrity sha512-qH0WSMBtn/oHuwjy/NucEgbx5dbxxnxup9s4PVXJUDHZBQY+s0NWA9rJf53RBnQZxfch7euUui7hpoAPvALZdA== + dependencies: + big.js "^5.2.2" + emojis-list "^3.0.0" + json5 "^1.0.1" + locate-path@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-2.0.0.tgz#2b568b265eec944c6d9c0de9c3dbbbca0354cd8e" @@ -7728,7 +8301,7 @@ lodash@4.17.20: resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.20.tgz#b44a9b6297bcb698f1c51a3545a2b3b368d59c52" integrity sha512-PlhdFcillOINfeV7Ni6oF1TAEayyZBoZ8bcshTHqOYJYlrqzRK5hagpagky5o4HfCzzd1TRkXPMFq6cKk9rGmA== -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: +lodash@^4.14.2, lodash@^4.17.11, lodash@^4.17.12, lodash@^4.17.14, lodash@^4.17.15, lodash@^4.17.19, lodash@^4.17.4: version "4.17.21" resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c" integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg== @@ -7758,6 +8331,11 @@ log-update@^4.0.0: slice-ansi "^4.0.0" wrap-ansi "^6.2.0" +longest@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/longest/-/longest-1.0.1.tgz#30a0b2da38f73770e8294a0d22e6625ed77d0097" + integrity sha1-MKCy2jj3N3DoKUoNIuZiXtd9AJc= + looper@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/looper/-/looper-2.0.0.tgz#66cd0c774af3d4fedac53794f742db56da8f09ec" @@ -7834,6 +8412,13 @@ make-error@^1.1.1: resolved "https://registry.yarnpkg.com/make-error/-/make-error-1.3.6.tgz#2eb2e37ea9b67c4891f684a1394799af484cf7a2" integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw== +map-age-cleaner@^0.1.1: + version "0.1.3" + resolved "https://registry.yarnpkg.com/map-age-cleaner/-/map-age-cleaner-0.1.3.tgz#7d583a7306434c055fe474b0f45078e6e1b4b92a" + integrity sha512-bJzx6nMoP6PDLPBFmg7+xRKeFZvFboMrGlxmNj9ClvX53KrmvM5bXFXEWjbz4cz1AFn+jWJ9z/DJSz7hrs0w3w== + dependencies: + p-defer "^1.0.0" + map-cache@^0.2.2: version "0.2.2" resolved "https://registry.yarnpkg.com/map-cache/-/map-cache-0.2.2.tgz#c32abd0bd6525d9b051645bb4f26ac5dc98a0dbf" @@ -7856,10 +8441,17 @@ match-all@^1.2.6: resolved "https://registry.yarnpkg.com/match-all/-/match-all-1.2.6.tgz#66d276ad6b49655551e63d3a6ee53e8be0566f8d" integrity sha512-0EESkXiTkWzrQQntBu2uzKvLu6vVkUGz40nGPbSZuegcfE5UuSzNjLaIu76zJWuaT/2I3Z/8M06OlUOZLGwLlQ== +math-random@^1.0.1: + version "1.0.4" + resolved "https://registry.yarnpkg.com/math-random/-/math-random-1.0.4.tgz#5dd6943c938548267016d4e34f057583080c514c" + integrity sha512-rUxjysqif/BZQH2yhd5Aaq7vXMSx9NdEsQcyA07uEzIvxgI7zIr33gGsh+RU0/XjmQpCW7RsVof1vlkvQVCK5A== + mcl-wasm@^0.7.1: - version "0.7.7" - resolved "https://registry.yarnpkg.com/mcl-wasm/-/mcl-wasm-0.7.7.tgz#fd463dd1641a37f9f55b6ca8e5a38e95be2bc58f" - integrity sha512-jDGiCQA++5hX37gdH6RDZ3ZsA0raet7xyY/R5itj5cbcdf4Gvw+YyxWX/ZZ0Z2UPxJiw1ktRsCJZzpnqlQILdw== + version "0.7.8" + resolved "https://registry.yarnpkg.com/mcl-wasm/-/mcl-wasm-0.7.8.tgz#4d0dc5a92f7bd20892fd3fcd41764acf86fd1e6e" + integrity sha512-qNHlYO6wuEtSoH5A8TcZfCEHtw8gGPqF6hLZpQn2SVd/Mck0ELIKOkmj072D98S9B9CI/jZybTUC96q1P2/ZDw== + dependencies: + typescript "^4.3.4" md5.js@^1.3.4: version "1.3.5" @@ -7875,6 +8467,22 @@ media-typer@0.3.0: resolved "https://registry.yarnpkg.com/media-typer/-/media-typer-0.3.0.tgz#8710d7af0aa626f8fffa1ce00168545263255748" integrity sha1-hxDXrwqmJvj/+hzgAWhUUmMlV0g= +mem@^1.1.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/mem/-/mem-1.1.0.tgz#5edd52b485ca1d900fe64895505399a0dfa45f76" + integrity sha1-Xt1StIXKHZAP5kiVUFOZoN+kX3Y= + dependencies: + mimic-fn "^1.0.0" + +mem@^4.0.0: + version "4.3.0" + resolved "https://registry.yarnpkg.com/mem/-/mem-4.3.0.tgz#461af497bc4ae09608cdb2e60eefb69bff744178" + integrity sha512-qX2bG48pTqYRVmDB37rn/6PT7LcR8T7oAX3bf99u1Tt1nzxYfxkgqDwUwolPlXweM0XzBOBFzSx4kfp7KP1s/w== + dependencies: + map-age-cleaner "^0.1.1" + mimic-fn "^2.0.0" + p-is-promise "^2.0.0" + memdown@^1.0.0: version "1.4.1" resolved "https://registry.yarnpkg.com/memdown/-/memdown-1.4.1.tgz#b4e4e192174664ffbae41361aa500f3119efe215" @@ -7911,6 +8519,14 @@ memdown@~3.0.0: ltgt "~2.2.0" safe-buffer "~5.1.1" +memory-fs@^0.4.0, memory-fs@~0.4.1: + version "0.4.1" + resolved "https://registry.yarnpkg.com/memory-fs/-/memory-fs-0.4.1.tgz#3a9a20b8462523e447cfbc7e8bb80ed667bfc552" + integrity sha1-OpoguEYlI+RHz7x+i7gO1me/xVI= + dependencies: + errno "^0.1.3" + readable-stream "^2.0.1" + memorystream@^0.3.1: version "0.3.1" resolved "https://registry.yarnpkg.com/memorystream/-/memorystream-0.3.1.tgz#86d7090b30ce455d63fbae12dda51a47ddcaf9b2" @@ -7958,17 +8574,17 @@ merkle-patricia-tree@^2.1.2, merkle-patricia-tree@^2.3.2: rlp "^2.0.0" semaphore ">=1.0.1" -merkle-patricia-tree@^4.1.0: - version "4.1.0" - resolved "https://registry.yarnpkg.com/merkle-patricia-tree/-/merkle-patricia-tree-4.1.0.tgz#010636c4cfd68682df33a2e3186b7d0be7b98b9d" - integrity sha512-vmP1J7FwIpprFMVjjSMM1JAwFce85Q+tp0TYIedYv8qaMh2oLUZ3ETXn9wbgi9S6elySzKzGa+Ai6VNKGEwSlg== +merkle-patricia-tree@^4.2.0: + version "4.2.0" + resolved "https://registry.yarnpkg.com/merkle-patricia-tree/-/merkle-patricia-tree-4.2.0.tgz#a204b9041be5c25e8d14f0ff47021de090e811a1" + integrity sha512-0sBVXs7z1Q1/kxzWZ3nPnxSPiaHKF/f497UQzt9O7isRcS10tel9jM/4TivF6Jv7V1yFq4bWyoATxbDUOen5vQ== dependencies: "@types/levelup" "^4.3.0" - ethereumjs-util "^7.0.8" + ethereumjs-util "^7.0.10" level-mem "^5.0.1" level-ws "^2.0.0" readable-stream "^3.6.0" - rlp "^2.2.3" + rlp "^2.2.4" semaphore-async-await "^1.5.1" methods@~1.1.2: @@ -7976,7 +8592,26 @@ methods@~1.1.2: resolved "https://registry.yarnpkg.com/methods/-/methods-1.1.2.tgz#5529a4d67654134edcc5266656835b0f851afcee" integrity sha1-VSmk1nZUE07cxSZmVoNbD4Ua/O4= -micromatch@^3.1.4: +micromatch@^2.1.5: + version "2.3.11" + resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-2.3.11.tgz#86677c97d1720b363431d04d0d15293bd38c1565" + integrity sha1-hmd8l9FyCzY0MdBNDRUpO9OMFWU= + dependencies: + arr-diff "^2.0.0" + array-unique "^0.2.1" + braces "^1.8.2" + expand-brackets "^0.1.4" + extglob "^0.3.1" + filename-regex "^2.0.0" + is-extglob "^1.0.0" + is-glob "^2.0.1" + kind-of "^3.0.2" + normalize-path "^2.0.1" + object.omit "^2.0.0" + parse-glob "^3.0.4" + regex-cache "^0.4.2" + +micromatch@^3.1.10, micromatch@^3.1.4: version "3.1.10" resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-3.1.10.tgz#70859bc95c9840952f359a068a3fc49f9ecfac23" integrity sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg== @@ -7995,7 +8630,7 @@ micromatch@^3.1.4: snapdragon "^0.8.1" to-regex "^3.0.2" -micromatch@^4.0.2: +micromatch@^4.0.2, micromatch@^4.0.4: version "4.0.4" resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.4.tgz#896d519dfe9db25fce94ceb7a500919bf881ebf9" integrity sha512-pRmzw/XUcwXGpD9aI9q/0XOwLNygjETJ8y0ao0wdqprrzDa4YnxLcz7fQRZr8voh8V10kGhABbNcHVk5wHgWwg== @@ -8011,30 +8646,18 @@ miller-rabin@^4.0.0: bn.js "^4.0.0" brorand "^1.0.1" -mime-db@1.47.0: - version "1.47.0" - resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.47.0.tgz#8cb313e59965d3c05cfbf898915a267af46a335c" - integrity sha512-QBmA/G2y+IfeS4oktet3qRZ+P5kPhCKRXxXnQEudYqUaEioAU1/Lq2us3D/t1Jfo4hE9REQPrbB7K5sOczJVIw== - mime-db@1.48.0: version "1.48.0" resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.48.0.tgz#e35b31045dd7eada3aaad537ed88a33afbef2d1d" integrity sha512-FM3QwxV+TnZYQ2aRqhlKBMHxk10lTbMt3bBkMAp54ddrNeVSfcQYOOKuGuy3Ddrm38I04If834fOUSq1yzslJQ== -mime-types@^2.1.12: +mime-types@^2.1.12, mime-types@^2.1.16, mime-types@~2.1.19, mime-types@~2.1.24: version "2.1.31" resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.31.tgz#a00d76b74317c61f9c2db2218b8e9f8e9c5c9e6b" integrity sha512-XGZnNzm3QvgKxa8dpzyhFTHmpP3l5YNusmne07VUOXxou9CqUqYa/HBy124RqtVh/O2pECas/MOcsDgpilPOPg== dependencies: mime-db "1.48.0" -mime-types@^2.1.16, mime-types@~2.1.19, mime-types@~2.1.24: - version "2.1.30" - resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.30.tgz#6e7be8b4c479825f85ed6326695db73f9305d62d" - integrity sha512-crmjA4bLtR8m9qLpHvgxSChT+XoSlZi8J4n/aIdn3z92e/U47Z0V/yl+Wh9W046GgFVAmoNR/fmdbZYcSSIUeg== - dependencies: - mime-db "1.47.0" - mime@1.6.0: version "1.6.0" resolved "https://registry.yarnpkg.com/mime/-/mime-1.6.0.tgz#32cd9e5c64553bd58d19a568af452acff04981b1" @@ -8045,7 +8668,7 @@ mimic-fn@^1.0.0: resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-1.2.0.tgz#820c86a39334640e99516928bd03fca88057d022" integrity sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ== -mimic-fn@^2.1.0: +mimic-fn@^2.0.0, mimic-fn@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-2.1.0.tgz#7ed2c2ccccaf84d3ffcb7a69b57711fc2083401b" integrity sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg== @@ -8084,6 +8707,11 @@ minimatch@3.0.4, minimatch@^3.0.4: dependencies: brace-expansion "^1.1.7" +minimist@0.0.8: + version "0.0.8" + resolved "https://registry.yarnpkg.com/minimist/-/minimist-0.0.8.tgz#857fcabfc3397d2625b8228262e86aa7a011b05d" + integrity sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0= + minimist@^1.1.3, minimist@^1.2.0, minimist@^1.2.5, minimist@~1.2.5: version "1.2.5" resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.5.tgz#67d66014b66a6a8aaa0c083c5fd58df4e4e97602" @@ -8124,7 +8752,14 @@ mkdirp@*, mkdirp@^1.0.3: resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-1.0.4.tgz#3eb5ed62622756d79a5f0e2a221dfebad75c2f7e" integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw== -mkdirp@0.5.5, mkdirp@^0.5.0, mkdirp@^0.5.1: +mkdirp@0.5.1: + version "0.5.1" + resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.1.tgz#30057438eac6cf7f8c4767f38648d6697d75c903" + integrity sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM= + dependencies: + minimist "0.0.8" + +mkdirp@0.5.5, mkdirp@^0.5.0, mkdirp@^0.5.1, mkdirp@~0.5.0: version "0.5.5" resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.5.tgz#d91cefd62d1436ca0f41620e251288d420099def" integrity sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ== @@ -8138,6 +8773,22 @@ mnemonist@^0.38.0: dependencies: obliterator "^1.6.1" +mocha@^4.0.1: + version "4.1.0" + resolved "https://registry.yarnpkg.com/mocha/-/mocha-4.1.0.tgz#7d86cfbcf35cb829e2754c32e17355ec05338794" + integrity sha512-0RVnjg1HJsXY2YFDoTNzcc1NKhYuXKRrBAG2gDygmJJA136Cs2QlRliZG1mA0ap7cuaT30mw16luAeln+4RiNA== + dependencies: + browser-stdout "1.3.0" + commander "2.11.0" + debug "3.1.0" + diff "3.3.1" + escape-string-regexp "1.0.5" + glob "7.1.2" + growl "1.10.3" + he "1.1.1" + mkdirp "0.5.1" + supports-color "4.4.0" + mocha@^7.1.0, mocha@^7.1.1, mocha@^7.1.2: version "7.2.0" resolved "https://registry.yarnpkg.com/mocha/-/mocha-7.2.0.tgz#01cc227b00d875ab1eed03a75106689cfed5a604" @@ -8252,11 +8903,34 @@ mute-stream@0.0.7: resolved "https://registry.yarnpkg.com/mute-stream/-/mute-stream-0.0.7.tgz#3075ce93bc21b8fab43e1bc4da7e8115ed1e7bab" integrity sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s= -nan@^2.14.0: +name-wrapper@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/name-wrapper/-/name-wrapper-1.0.0.tgz#6e064a29b9c7806e18032fdbf620a01de48cdfbb" + integrity sha512-7wTdz1ees+Q3GXFu/Mp76owXzWqYp+k2bB/W0yRnfFtnzU5Y8ga6VKbgl+UWYuCfndy0ylRSQpHPom/mEsDVqg== + dependencies: + "@ensdomains/ens-contracts" "0.0.3" + "@nomiclabs/hardhat-ethers" "^2.0.0" + "@nomiclabs/hardhat-waffle" "^2.0.0" + "@openzeppelin/contracts" "^4.0.0" + chalk "^4.1.0" + ethereum-waffle "^3.1.1" + ethers "^5.0.17" + hardhat "^2.0.4" + node-watch "^0.7.0" + qrcode-terminal "^0.12.0" + ramda "^0.27.1" + solium "^1.2.5" + +nan@^2.12.1, nan@^2.14.0: version "2.14.2" resolved "https://registry.yarnpkg.com/nan/-/nan-2.14.2.tgz#f5376400695168f4cc694ac9393d0c9585eeea19" integrity sha512-M2ufzIiINKCuDfBSAUr1vWQ+vuVcA9kqx8JJUsbQi6yf1uGRyb7HfpdfUr5qLXf3B/t8dPvcjhKMmlfnP47EzQ== +nano-base32@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/nano-base32/-/nano-base32-1.0.1.tgz#ba548c879efcfb90da1c4d9e097db4a46c9255ef" + integrity sha1-ulSMh578+5DaHE2eCX20pGySVe8= + nano-json-stream-parser@^0.1.2: version "0.1.2" resolved "https://registry.yarnpkg.com/nano-json-stream-parser/-/nano-json-stream-parser-0.1.2.tgz#0cc8f6d0e2b622b479c40d499c46d64b755c6f5f" @@ -8289,6 +8963,11 @@ negotiator@0.6.2: resolved "https://registry.yarnpkg.com/negotiator/-/negotiator-0.6.2.tgz#feacf7ccf525a77ae9634436a64883ffeca346fb" integrity sha512-hZXc7K2e+PgeI1eDBe/10Ard4ekbfrrqG8Ep+8Jmf4JID2bNg7NvCPOZN+kfF574pFQI7mum2AUqDidoKqcTOw== +neo-async@^2.5.0: + version "2.6.2" + resolved "https://registry.yarnpkg.com/neo-async/-/neo-async-2.6.2.tgz#b4aafb93e3aeb2d8174ca53cf163ab7d7308305f" + integrity sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw== + next-tick@~1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/next-tick/-/next-tick-1.0.0.tgz#ca86d1fe8828169b0120208e3dc8424b9db8342c" @@ -8335,6 +9014,40 @@ node-gyp-build@^4.2.0: resolved "https://registry.yarnpkg.com/node-gyp-build/-/node-gyp-build-4.2.3.tgz#ce6277f853835f718829efb47db20f3e4d9c4739" integrity sha512-MN6ZpzmfNCRM+3t57PTJHgHyw/h4OWnZ6mR8P5j/uZtqQr46RRuDE/P+g3n0YR/AiYXeWixZZzaip77gdICfRg== +node-libs-browser@^2.0.0: + version "2.2.1" + resolved "https://registry.yarnpkg.com/node-libs-browser/-/node-libs-browser-2.2.1.tgz#b64f513d18338625f90346d27b0d235e631f6425" + integrity sha512-h/zcD8H9kaDZ9ALUWwlBUDo6TKF8a7qBSCSEGfjTVIYeqsioSKaAX+BN7NgiMGp6iSIXZ3PxgCu8KS3b71YK5Q== + dependencies: + assert "^1.1.1" + browserify-zlib "^0.2.0" + buffer "^4.3.0" + console-browserify "^1.1.0" + constants-browserify "^1.0.0" + crypto-browserify "^3.11.0" + domain-browser "^1.1.1" + events "^3.0.0" + https-browserify "^1.0.0" + os-browserify "^0.3.0" + path-browserify "0.0.1" + process "^0.11.10" + punycode "^1.2.4" + querystring-es3 "^0.2.0" + readable-stream "^2.3.3" + stream-browserify "^2.0.1" + stream-http "^2.7.2" + string_decoder "^1.0.0" + timers-browserify "^2.0.4" + tty-browserify "0.0.0" + url "^0.11.0" + util "^0.11.0" + vm-browserify "^1.0.1" + +node-watch@^0.7.0: + version "0.7.1" + resolved "https://registry.yarnpkg.com/node-watch/-/node-watch-0.7.1.tgz#0caaa6a6833b0d533487f953c52a6c787769ba7c" + integrity sha512-UWblPYuZYrkCQCW5PxAwYSxaELNBLUckrTBBk8xr1/bUgyOkYYTsUcV4e3ytcazFEOyiRyiUrsG37pu6I0I05g== + nofilter@^1.0.4: version "1.0.4" resolved "https://registry.yarnpkg.com/nofilter/-/nofilter-1.0.4.tgz#78d6f4b6a613e7ced8b015cec534625f7667006e" @@ -8350,7 +9063,7 @@ normalize-package-data@^2.3.2: semver "2 || 3 || 4 || 5" validate-npm-package-license "^3.0.1" -normalize-path@^2.1.1: +normalize-path@^2.0.0, normalize-path@^2.0.1, normalize-path@^2.1.1: version "2.1.1" resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-2.1.1.tgz#1ab28b556e198363a8c1a6f7e6fa20137fe6aed9" integrity sha1-GrKLVW4Zg2Oowab35vogE3/mrtk= @@ -8367,6 +9080,13 @@ normalize-url@^4.1.0: resolved "https://registry.yarnpkg.com/normalize-url/-/normalize-url-4.5.1.tgz#0dd90cf1288ee1d1313b87081c9a5932ee48518a" integrity sha512-9UZCFRHQdNrfTpGg8+1INIg93B6zE0aXMVFkw1WFwvO4SlZywU6aLg5Of0Ap/PgcbSw4LNxvMWXMeugwMCX0AA== +npm-run-path@^2.0.0: + version "2.0.2" + resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-2.0.2.tgz#35a9232dfa35d7067b4cb2ddf2357b1871536c5f" + integrity sha1-NakjLfo11wZ7TLLd8jV7GHFTbF8= + dependencies: + path-key "^2.0.0" + npm-run-path@^4.0.0: version "4.0.1" resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-4.0.1.tgz#b7ecd1e5ed53da8e37a55e1c2269e0b97ed748ea" @@ -8399,7 +9119,7 @@ oauth-sign@~0.9.0: resolved "https://registry.yarnpkg.com/oauth-sign/-/oauth-sign-0.9.0.tgz#47a7b016baa68b5fa0ecf3dee08a85c679ac6455" integrity sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ== -object-assign@^4, object-assign@^4.0.0, object-assign@^4.1.0, object-assign@^4.1.1: +object-assign@^4, object-assign@^4.0.0, object-assign@^4.0.1, object-assign@^4.1.0, object-assign@^4.1.1: version "4.1.1" resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863" integrity sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM= @@ -8413,7 +9133,7 @@ object-copy@^0.1.0: define-property "^0.2.5" kind-of "^3.0.3" -object-inspect@^1.9.0: +object-inspect@^1.10.3, object-inspect@^1.9.0: version "1.10.3" resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.10.3.tgz#c2aa7d2d09f50c99375704f7a0adf24c5782d369" integrity sha512-e5mCJlSH7poANfC8z8S9s9S2IN5/4Zb3aZ33f5s8YqoazCFzNLloLU8r5VCG+G7WoqLvAAZoVMcy3tp/3X0Plw== @@ -8477,6 +9197,14 @@ object.getownpropertydescriptors@^2.0.3, object.getownpropertydescriptors@^2.1.1 define-properties "^1.1.3" es-abstract "^1.18.0-next.2" +object.omit@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/object.omit/-/object.omit-2.0.1.tgz#1a9c744829f39dbb858c76ca3579ae2a54ebd1fa" + integrity sha1-Gpx0SCnznbuFjHbKNXmuKlTr0fo= + dependencies: + for-own "^0.1.4" + is-extendable "^0.1.1" + object.pick@^1.3.0: version "1.3.0" resolved "https://registry.yarnpkg.com/object.pick/-/object.pick-1.3.0.tgz#87a10ac4c1694bd2e1cbf53591a66141fb5dd747" @@ -8485,14 +9213,13 @@ object.pick@^1.3.0: isobject "^3.0.1" object.values@^1.1.3: - version "1.1.3" - resolved "https://registry.yarnpkg.com/object.values/-/object.values-1.1.3.tgz#eaa8b1e17589f02f698db093f7c62ee1699742ee" - integrity sha512-nkF6PfDB9alkOUxpf1HNm/QlkeW3SReqL5WXeBLpEJJnlPSvRaDQpW3gQTksTN3fgJX4hL42RzKyOin6ff3tyw== + version "1.1.4" + resolved "https://registry.yarnpkg.com/object.values/-/object.values-1.1.4.tgz#0d273762833e816b693a637d30073e7051535b30" + integrity sha512-TnGo7j4XSnKQoK3MfvkzqKCi0nVe/D9I9IjwTNYdb/fxYHpjrluHVOgw0AF6jrRFGMPHdfuidR09tIDiIvnaSg== dependencies: call-bind "^1.0.2" define-properties "^1.1.3" - es-abstract "^1.18.0-next.2" - has "^1.0.3" + es-abstract "^1.18.2" obliterator@^1.6.1: version "1.6.1" @@ -8578,6 +9305,11 @@ optionator@^0.9.1: type-check "^0.4.0" word-wrap "^1.2.3" +os-browserify@^0.3.0: + version "0.3.0" + resolved "https://registry.yarnpkg.com/os-browserify/-/os-browserify-0.3.0.tgz#854373c7f5c2315914fc9bfc6bd8238fdda1ec27" + integrity sha1-hUNzx/XCMVkU/Jv8a9gjj92h7Cc= + os-homedir@^1.0.0: version "1.0.2" resolved "https://registry.yarnpkg.com/os-homedir/-/os-homedir-1.0.2.tgz#ffbc4988336e0e833de0c168c7ef152121aa7fb3" @@ -8590,6 +9322,24 @@ os-locale@^1.4.0: dependencies: lcid "^1.0.0" +os-locale@^2.0.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/os-locale/-/os-locale-2.1.0.tgz#42bc2900a6b5b8bd17376c8e882b65afccf24bf2" + integrity sha512-3sslG3zJbEYcaC4YVAvDorjGxc7tv6KVATnLPZONiljsUncvihe9BQoVCEs0RZ1kmf4Hk9OBqlZfJZWI4GanKA== + dependencies: + execa "^0.7.0" + lcid "^1.0.0" + mem "^1.1.0" + +os-locale@^3.1.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/os-locale/-/os-locale-3.1.0.tgz#a802a6ee17f24c10483ab9935719cef4ed16bf1a" + integrity sha512-Z8l3R4wYWM40/52Z+S265okfFj8Kt2cC2MKY+xNi3kFs+XGI7WXu/I309QQQYbRW4ijiZ+yxs9pqEhJh0DqW3Q== + dependencies: + execa "^1.0.0" + lcid "^2.0.0" + mem "^4.0.0" + os-tmpdir@^1.0.1, os-tmpdir@~1.0.2: version "1.0.2" resolved "https://registry.yarnpkg.com/os-tmpdir/-/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274" @@ -8605,11 +9355,21 @@ p-cancelable@^1.0.0: resolved "https://registry.yarnpkg.com/p-cancelable/-/p-cancelable-1.1.0.tgz#d078d15a3af409220c886f1d9a0ca2e441ab26cc" integrity sha512-s73XxOZ4zpt1edZYZzvhqFa6uvQc1vwUa0K0BdtIZgQMAJj9IbebH+JkgKZc9h+B05PKHLOTl4ajG1BmNrVZlw== +p-defer@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/p-defer/-/p-defer-1.0.0.tgz#9f6eb182f6c9aa8cd743004a7d4f96b196b0fb0c" + integrity sha1-n26xgvbJqozXQwBKfU+WsZaw+ww= + p-finally@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/p-finally/-/p-finally-1.0.0.tgz#3fbcfb15b899a44123b34b6dcc18b724336a2cae" integrity sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4= +p-is-promise@^2.0.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/p-is-promise/-/p-is-promise-2.1.0.tgz#918cebaea248a62cf7ffab8e3bca8c5f882fc42e" + integrity sha512-Y3W0wlRPK8ZMRbNq97l4M5otioeA5lm1z7bkNkxCka8HSPjR0xRWmpCmc9utiaLP9Jb1eD8BgeIxTW4AIF45Pg== + p-limit@^1.1.0: version "1.3.0" resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-1.3.0.tgz#b86bd5f0c25690911c7590fcbfc2010d54b3ccb8" @@ -8676,7 +9436,7 @@ p-try@^2.0.0: resolved "https://registry.yarnpkg.com/p-try/-/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6" integrity sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ== -pako@^1.0.4: +pako@^1.0.4, pako@~1.0.5: version "1.0.11" resolved "https://registry.yarnpkg.com/pako/-/pako-1.0.11.tgz#6c9599d340d54dfd3946380252a35705a6b992bf" integrity sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw== @@ -8704,6 +9464,16 @@ parse-cache-control@^1.0.1: resolved "https://registry.yarnpkg.com/parse-cache-control/-/parse-cache-control-1.0.1.tgz#8eeab3e54fa56920fe16ba38f77fa21aacc2d74e" integrity sha1-juqz5U+laSD+Fro493+iGqzC104= +parse-glob@^3.0.4: + version "3.0.4" + resolved "https://registry.yarnpkg.com/parse-glob/-/parse-glob-3.0.4.tgz#b2c376cfb11f35513badd173ef0bb6e3a388391c" + integrity sha1-ssN2z7EfNVE7rdFz7wu246OIORw= + dependencies: + glob-base "^0.3.0" + is-dotfile "^1.0.0" + is-extglob "^1.0.0" + is-glob "^2.0.0" + parse-headers@^2.0.0: version "2.0.3" resolved "https://registry.yarnpkg.com/parse-headers/-/parse-headers-2.0.3.tgz#5e8e7512383d140ba02f0c7aa9f49b4399c92515" @@ -8793,11 +9563,21 @@ patch-package@^6.2.2: slash "^2.0.0" tmp "^0.0.33" +path-browserify@0.0.1: + version "0.0.1" + resolved "https://registry.yarnpkg.com/path-browserify/-/path-browserify-0.0.1.tgz#e6c4ddd7ed3aa27c68a20cc4e50e1a4ee83bbc4a" + integrity sha512-BapA40NHICOS+USX9SN4tyhq+A2RrN/Ws5F0Z5aMHDp98Fl86lX8Oti8B7uN93L4Ifv4fHOEA+pQw87gmMO/lQ== + path-browserify@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/path-browserify/-/path-browserify-1.0.1.tgz#d98454a9c3753d5790860f16f68867b9e46be1fd" integrity sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g== +path-dirname@^1.0.0: + version "1.0.2" + resolved "https://registry.yarnpkg.com/path-dirname/-/path-dirname-1.0.2.tgz#cc33d24d525e099a5388c0336c6e32b9160609e0" + integrity sha1-zDPSTVJeCZpTiMAzbG4yuRYGCeA= + path-exists@^2.0.0: version "2.1.0" resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-2.1.0.tgz#0feb6c64f0fc518d9a754dd5efb62c7022761f4b" @@ -8825,7 +9605,7 @@ path-is-inside@^1.0.2: resolved "https://registry.yarnpkg.com/path-is-inside/-/path-is-inside-1.0.2.tgz#365417dede44430d1c11af61027facf074bdfc53" integrity sha1-NlQX3t5EQw0cEa9hAn+s8HS9/FM= -path-key@^2.0.1: +path-key@^2.0.0, path-key@^2.0.1: version "2.0.1" resolved "https://registry.yarnpkg.com/path-key/-/path-key-2.0.1.tgz#411cadb574c5a140d3a4b1910d40d80cc9f40b40" integrity sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A= @@ -8836,16 +9616,9 @@ path-key@^3.0.0, path-key@^3.1.0: integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q== path-parse@^1.0.6: - version "1.0.6" - resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.6.tgz#d62dbb5679405d72c4737ec58600e9ddcf06d24c" - integrity sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw== - -path-starts-with@^1.0.0: - version "1.0.0" - resolved "https://registry.yarnpkg.com/path-starts-with/-/path-starts-with-1.0.0.tgz#b28243015e8b138de572682ac52da42e646ad84e" - integrity sha1-soJDAV6LE43lcmgqxS2kLmRq2E4= - dependencies: - normalize-path "^2.1.1" + version "1.0.7" + resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735" + integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw== path-to-regexp@0.1.7: version "0.1.7" @@ -8861,6 +9634,13 @@ path-type@^1.0.0: pify "^2.0.0" pinkie-promise "^2.0.0" +path-type@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/path-type/-/path-type-2.0.0.tgz#f012ccb8415b7096fc2daa1054c3d72389594c73" + integrity sha1-8BLMuEFbcJb8LaoQVMPXI4lZTHM= + dependencies: + pify "^2.0.0" + path-type@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/path-type/-/path-type-3.0.0.tgz#cef31dc8e0a1a3bb0d105c0cd97cf3bf47f4e36f" @@ -8889,21 +9669,21 @@ pbkdf2@^3.0.17, pbkdf2@^3.0.3, pbkdf2@^3.0.9: safe-buffer "^5.0.1" sha.js "^2.4.8" +pegjs@^0.10.0: + version "0.10.0" + resolved "https://registry.yarnpkg.com/pegjs/-/pegjs-0.10.0.tgz#cf8bafae6eddff4b5a7efb185269eaaf4610ddbd" + integrity sha1-z4uvrm7d/0tafvsYUmnqr0YQ3b0= + performance-now@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/performance-now/-/performance-now-2.1.0.tgz#6309f4e0e5fa913ec1c69307ae364b4b377c9e7b" integrity sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns= -picomatch@^2.0.4, picomatch@^2.2.1: +picomatch@^2.0.4, picomatch@^2.2.1, picomatch@^2.2.3: version "2.3.0" resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.0.tgz#f1f061de8f6a4bf022892e2d128234fb98302972" integrity sha512-lY1Q/PiJGC2zOv/z391WOTD+Z02bCgsFfvxoXXf6h7kv9o+WmsmzYqrAwY63sNgOxE4xEdq0WyUnXfKeBrSvYw== -picomatch@^2.2.3: - version "2.2.3" - resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.2.3.tgz#465547f359ccc206d3c48e46a1bcb89bf7ee619d" - integrity sha512-KpELjfwcCDUb9PeigTs2mBJzXUPzAuP2oPcA989He8Rte0+YUAjw1JVedDhuTKPkHjSYzMN3npC9luThGYEKdg== - pify@^2.0.0, pify@^2.3.0: version "2.3.0" resolved "https://registry.yarnpkg.com/pify/-/pify-2.3.0.tgz#ed141a6ac043a849ea588498e7dca8b15330e90c" @@ -8964,6 +9744,11 @@ postinstall-postinstall@^2.1.0: resolved "https://registry.yarnpkg.com/postinstall-postinstall/-/postinstall-postinstall-2.1.0.tgz#4f7f77441ef539d1512c40bd04c71b06a4704ca3" integrity sha512-7hQX6ZlZXIoRiWNrbMQaLzUUfH+sSx39u8EJ9HYuDc1kLo9IXKWjM5RSquZN1ad5GnH8CGFM78fsAAQi3OKEEQ== +prando@^6.0.1: + version "6.0.1" + resolved "https://registry.yarnpkg.com/prando/-/prando-6.0.1.tgz#ffa8de84c2adc4975dd9df37ae4ada0458face53" + integrity sha512-ghUWxQ1T9IJmPu6eshc3VU0OwveUtXQ33ZLXYUcz1Oc5ppKLDXKp0TBDj6b0epwhEctzcQSNGR2iHyvQSn4W5A== + precond@0.2: version "0.2.3" resolved "https://registry.yarnpkg.com/precond/-/precond-0.2.3.tgz#aa9591bcaa24923f1e0f4849d240f47efc1075ac" @@ -8989,6 +9774,11 @@ prepend-http@^2.0.0: resolved "https://registry.yarnpkg.com/prepend-http/-/prepend-http-2.0.0.tgz#e92434bfa5ea8c19f41cdfd401d741a3c819d897" integrity sha1-6SQ0v6XqjBn0HN/UAddBo8gZ2Jc= +preserve@^0.2.0: + version "0.2.0" + resolved "https://registry.yarnpkg.com/preserve/-/preserve-0.2.0.tgz#815ed1f6ebc65926f865b310c0713bcb3315ce4b" + integrity sha1-gV7R9uvGWSb4ZbMQwHE7yzMVzks= + prettier-linter-helpers@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/prettier-linter-helpers/-/prettier-linter-helpers-1.0.0.tgz#d23d41fe1375646de2d0104d3454a3008802cf7b" @@ -8996,16 +9786,13 @@ prettier-linter-helpers@^1.0.0: dependencies: fast-diff "^1.1.2" -prettier-plugin-solidity@^1.0.0-beta.7: - version "1.0.0-beta.10" - resolved "https://registry.yarnpkg.com/prettier-plugin-solidity/-/prettier-plugin-solidity-1.0.0-beta.10.tgz#f2a249002733826b08d981b599335ddb7e93af8d" - integrity sha512-55UsEbeJfqYKB3RFR7Nvpi+ApEoUfgdKHVg2ZybrbOkRW4RTblyONLL3mEr8Vrxpo7wBbObVLbWodGg4YXIQ7g== +prettier-plugin-solidity@prettier-solidity/prettier-plugin-solidity#aa41b1093421f6ff67a0e6b1442081e05dabe71c: + version "1.0.0-beta.16" + resolved "https://codeload.github.com/prettier-solidity/prettier-plugin-solidity/tar.gz/aa41b1093421f6ff67a0e6b1442081e05dabe71c" dependencies: - "@solidity-parser/parser" "^0.12.1" - dir-to-object "^2.0.0" + "@solidity-parser/parser" "^0.13.2" emoji-regex "^9.2.2" escape-string-regexp "^4.0.0" - prettier "^2.2.1" semver "^7.3.5" solidity-comments-extractor "^0.0.7" string-width "^4.2.2" @@ -9015,24 +9802,19 @@ prettier@^1.14.3: resolved "https://registry.yarnpkg.com/prettier/-/prettier-1.19.1.tgz#f7d7f5ff8a9cd872a7be4ca142095956a60797cb" integrity sha512-s7PoyDv/II1ObgQunCbB9PdLmUcBZcnWOcxDh7O0N/UwDEsHyqkW+Qh28jW+mVuCdx7gLB0BotYI1Y6uI9iyew== -prettier@^2.1.2, prettier@^2.2.1: - version "2.3.0" - resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.3.0.tgz#b6a5bf1284026ae640f17f7ff5658a7567fc0d18" - integrity sha512-kXtO4s0Lz/DW/IJ9QdWhAf7/NmPWQXkFr/r/WkR3vyI+0v8amTDxiaQSLzs8NBlytfLWX/7uQUMIW677yLKl4w== - -prettier@^2.3.1: +prettier@^2.1.2, prettier@^2.3.1: version "2.3.1" resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.3.1.tgz#76903c3f8c4449bc9ac597acefa24dc5ad4cbea6" integrity sha512-p+vNbgpLjif/+D+DwAZAbndtRrR0md0MwfmOVN9N+2RgyACMT+7tfaRnT+WDPkqnuVwleyuBIG2XBxKDme3hPA== -pretty-format@^26.6.2: - version "26.6.2" - resolved "https://registry.yarnpkg.com/pretty-format/-/pretty-format-26.6.2.tgz#e35c2705f14cb7fe2fe94fa078345b444120fc93" - integrity sha512-7AeGuCYNGmycyQbCqd/3PWH4eOoX/OiCa0uphp57NVTeAGdJGaAliecxwBDHYQCIvrW7aDBZCYeNTP/WX69mkg== +pretty-format@^27.0.2: + version "27.0.2" + resolved "https://registry.yarnpkg.com/pretty-format/-/pretty-format-27.0.2.tgz#9283ff8c4f581b186b2d4da461617143dca478a4" + integrity sha512-mXKbbBPnYTG7Yra9qFBtqj+IXcsvxsvOBco3QHxtxTl+hHKq6QdzMZ+q0CtL4ORHZgwGImRr2XZUX2EWzORxig== dependencies: - "@jest/types" "^26.6.2" + "@jest/types" "^27.0.2" ansi-regex "^5.0.0" - ansi-styles "^4.0.0" + ansi-styles "^5.0.0" react-is "^17.0.1" printj@~1.1.0: @@ -9076,11 +9858,11 @@ promise@^8.0.0: asap "~2.0.6" proxy-addr@~2.0.5: - version "2.0.6" - resolved "https://registry.yarnpkg.com/proxy-addr/-/proxy-addr-2.0.6.tgz#fdc2336505447d3f2f2c638ed272caf614bbb2bf" - integrity sha512-dh/frvCBVmSsDYzw6n926jv974gddhkFPfiN8hPOi30Wax25QZyZEGveluCgliBnqmuM+UJmBErbAUFIoDbjOw== + version "2.0.7" + resolved "https://registry.yarnpkg.com/proxy-addr/-/proxy-addr-2.0.7.tgz#f19fe69ceab311eeb94b42e70e8c2070f9ba1025" + integrity sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg== dependencies: - forwarded "~0.1.2" + forwarded "0.2.0" ipaddr.js "1.9.1" prr@~1.0.1: @@ -9176,11 +9958,21 @@ punycode@2.1.0: resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.1.0.tgz#5f863edc89b96db09074bad7947bf09056ca4e7d" integrity sha1-X4Y+3Im5bbCQdLrXlHvwkFbKTn0= +punycode@^1.2.4: + version "1.4.1" + resolved "https://registry.yarnpkg.com/punycode/-/punycode-1.4.1.tgz#c0d5a63b2718800ad8e1eb0fa5269c84dd41845e" + integrity sha1-wNWmOycYgArY4esPpSachN1BhF4= + punycode@^2.1.0, punycode@^2.1.1: version "2.1.1" resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.1.1.tgz#b58b010ac40c22c5657616c8d2c2c02c7bf479ec" integrity sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A== +qrcode-terminal@^0.12.0: + version "0.12.0" + resolved "https://registry.yarnpkg.com/qrcode-terminal/-/qrcode-terminal-0.12.0.tgz#bb5b699ef7f9f0505092a3748be4464fe71b5819" + integrity sha512-EXtzRZmC+YGmGlDFbXKxQiMZNwCLEO6BANKXG4iCtSIM0yqc/pappSx3RIKr4r0uh5JsBckOXeKrB3Iz7mdQpQ== + qs@6.7.0: version "6.7.0" resolved "https://registry.yarnpkg.com/qs/-/qs-6.7.0.tgz#41dc1a015e3d581f1621776be31afb2876a9b1bc" @@ -9207,6 +9999,11 @@ query-string@^5.0.1: object-assign "^4.1.0" strict-uri-encode "^1.0.0" +querystring-es3@^0.2.0: + version "0.2.1" + resolved "https://registry.yarnpkg.com/querystring-es3/-/querystring-es3-0.2.1.tgz#9ec61f79049875707d69414596fd907a4d711e73" + integrity sha1-nsYfeQSYdXB9aUFFlv2Qek1xHnM= + querystring@0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/querystring/-/querystring-0.2.0.tgz#b209849203bb25df820da756e747005878521620" @@ -9217,6 +10014,20 @@ queue-microtask@^1.2.2: resolved "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243" integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A== +ramda@^0.27.1: + version "0.27.1" + resolved "https://registry.yarnpkg.com/ramda/-/ramda-0.27.1.tgz#66fc2df3ef873874ffc2da6aa8984658abacf5c9" + integrity sha512-PgIdVpn5y5Yns8vqb8FzBUEYn98V3xcPgawAkkgj0YJ0qDsnHCiNmZYfOGMgOvoB0eWFLpYbhxUR3mxfDIMvpw== + +randomatic@^3.0.0: + version "3.1.1" + resolved "https://registry.yarnpkg.com/randomatic/-/randomatic-3.1.1.tgz#b776efc59375984e36c537b2f51a1f0aff0da1ed" + integrity sha512-TuDE5KxZ0J461RVjrJZCJc+J+zCkTb1MbH9AQUq68sMhOMcy9jLcb3BrZKgp9q9Ncltdg4QVqWrH02W2EFFVYw== + dependencies: + is-number "^4.0.0" + kind-of "^6.0.0" + math-random "^1.0.1" + 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.yarnpkg.com/randombytes/-/randombytes-2.1.0.tgz#df6f84372f0270dc65cdf6291349ab7a473d4f2a" @@ -9270,6 +10081,14 @@ read-pkg-up@^1.0.1: find-up "^1.0.0" read-pkg "^1.0.0" +read-pkg-up@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-2.0.0.tgz#6b72a8048984e0c41e79510fd5e9fa99b3b549be" + integrity sha1-a3KoBImE4MQeeVEP1en6mbO1Sb4= + dependencies: + find-up "^2.0.0" + read-pkg "^2.0.0" + read-pkg-up@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-3.0.0.tgz#3ed496685dba0f8fe118d0691dc51f4a1ff96f07" @@ -9287,6 +10106,15 @@ read-pkg@^1.0.0: normalize-package-data "^2.3.2" path-type "^1.0.0" +read-pkg@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-2.0.0.tgz#8ef1c0623c6a6db0dc6713c4bfac46332b2368f8" + integrity sha1-jvHAYjxqbbDcZxPEv6xGMysjaPg= + dependencies: + load-json-file "^2.0.0" + normalize-package-data "^2.3.2" + path-type "^2.0.0" + read-pkg@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-3.0.0.tgz#9cbc686978fee65d16c00e2b19c237fcf6e38389" @@ -9306,7 +10134,7 @@ readable-stream@^1.0.33: 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: +readable-stream@^2.0.0, readable-stream@^2.0.1, readable-stream@^2.0.2, readable-stream@^2.0.5, readable-stream@^2.2.2, readable-stream@^2.2.8, readable-stream@^2.2.9, readable-stream@^2.3.3, readable-stream@^2.3.6, readable-stream@~2.3.6: version "2.3.7" resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.3.7.tgz#1eca1cf711aef814c04f62252a36a62f6cb23b57" integrity sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw== @@ -9338,6 +10166,15 @@ readable-stream@~1.0.15: isarray "0.0.1" string_decoder "~0.10.x" +readdirp@^2.0.0, readdirp@^2.2.1: + version "2.2.1" + resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-2.2.1.tgz#0e87622a3325aa33e892285caf8b4e846529a525" + integrity sha512-1JU/8q+VgFZyxwrJ+SVIOsh+KywWGpds3NTqikiKpDMZWScmAYyKIgqkO+ARvNWJfXeXR1zxz7aHF4u4CyH6vQ== + dependencies: + graceful-fs "^4.1.11" + micromatch "^3.1.10" + readable-stream "^2.0.2" + readdirp@~3.2.0: version "3.2.0" resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-3.2.0.tgz#c30c33352b12c96dfb4b895421a49fd5a9593839" @@ -9345,10 +10182,10 @@ readdirp@~3.2.0: dependencies: picomatch "^2.0.4" -readdirp@~3.5.0: - version "3.5.0" - resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-3.5.0.tgz#9ba74c019b15d365278d2e91bb8c48d7b4d42c9e" - integrity sha512-cMhu7c/8rdhkHXWsY+osBhfSy0JikwpHK/5+imo+LpeasTF8ouErHrlYkwT0++njiyuDvc7OFY5T3ukvZ8qmFQ== +readdirp@~3.6.0: + version "3.6.0" + resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-3.6.0.tgz#74a370bd857116e245b29cc97340cd431a02a6c7" + integrity sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA== dependencies: picomatch "^2.2.1" @@ -9362,6 +10199,11 @@ regenerator-runtime@^0.11.0: resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz#be05ad7f9bf7d22e056f9726cee5017fbf19e2e9" integrity sha512-MguG95oij0fC3QV3URf4V2SDYGJhJnJGqvIIgdECeODCT98wSWDAJ94SSuVpYQUoTcGUIL6L4yNB7j1DFFHSBg== +regenerator-runtime@^0.13.4: + version "0.13.7" + resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.13.7.tgz#cac2dacc8a1ea675feaabaeb8ae833898ae46f55" + integrity sha512-a54FxoJDIr27pgf7IgeQGxmqUNYrcV338lf/6gH456HZ/PhX+5BcwHXG9ajESmwe6WRO0tAzRUrRmNONWgkrew== + regenerator-transform@^0.10.0: version "0.10.1" resolved "https://registry.yarnpkg.com/regenerator-transform/-/regenerator-transform-0.10.1.tgz#1e4996837231da8b7f3cf4114d71b5691a0680dd" @@ -9371,6 +10213,13 @@ regenerator-transform@^0.10.0: babel-types "^6.19.0" private "^0.1.6" +regex-cache@^0.4.2: + version "0.4.4" + resolved "https://registry.yarnpkg.com/regex-cache/-/regex-cache-0.4.4.tgz#75bdc58a2a1496cec48a12835bc54c8d562336dd" + integrity sha512-nVIZwtCjkC9YgvWkpM55B5rBhBYRZhAaJbgcFYXXsHnbZ9UZI9nnVWYZpBlCqv9ho2eZryPnWrZGsOdPwVWXWQ== + dependencies: + is-equal-shallow "^0.1.3" + regex-not@^1.0.0, regex-not@^1.0.2: version "1.0.2" resolved "https://registry.yarnpkg.com/regex-not/-/regex-not-1.0.2.tgz#1f4ece27e00b0b65e0247a6810e6a85d83a5752c" @@ -9393,9 +10242,9 @@ regexpp@^2.0.1: integrity sha512-lv0M6+TkDVniA3aD1Eg0DVpfU/booSu7Eev3TDO/mZKHBfVjgCGTV4t4buppESEYDtkArYFOxTJWv6S5C+iaNw== regexpp@^3.0.0, regexpp@^3.1.0: - version "3.1.0" - resolved "https://registry.yarnpkg.com/regexpp/-/regexpp-3.1.0.tgz#206d0ad0a5648cffbdb8ae46438f3dc51c9f78e2" - integrity sha512-ZOIzd8yVsQQA7j8GCSlPGXwg5PfmA1mrq0JP4nGhh54LaKN3xdai/vHUDu74pKwV8OxseMS65u2NImosQcSD0Q== + version "3.2.0" + resolved "https://registry.yarnpkg.com/regexpp/-/regexpp-3.2.0.tgz#0425a2768d8f23bad70ca4b90461fa2f1213e1b2" + integrity sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg== regexpu-core@^2.0.0: version "2.0.0" @@ -9428,7 +10277,7 @@ repeat-element@^1.1.2: 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: +repeat-string@^1.5.2, repeat-string@^1.6.1: version "1.6.1" resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637" integrity sha1-jcrkcOHIirwtYA//Sndihtp15jc= @@ -9592,9 +10441,16 @@ reusify@^1.0.4: integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw== rfc4648@^1.3.0: - version "1.4.0" - resolved "https://registry.yarnpkg.com/rfc4648/-/rfc4648-1.4.0.tgz#c75b2856ad2e2d588b6ddb985d556f1f7f2a2abd" - integrity sha512-3qIzGhHlMHA6PoT6+cdPKZ+ZqtxkIvg8DZGKA5z6PQ33/uuhoJ+Ws/D/J9rXW6gXodgH8QYlz2UCl+sdUDmNIg== + version "1.5.0" + resolved "https://registry.yarnpkg.com/rfc4648/-/rfc4648-1.5.0.tgz#1ba940ec1649685ec4d88788dc57fb8e18855055" + integrity sha512-FA6W9lDNeX8WbMY31io1xWg+TpZCbeDKsBo0ocwACZiWnh9TUAyk9CCuBQuOPmYnwwdEQZmraQ2ZK7yJsxErBg== + +right-align@^0.1.1: + version "0.1.3" + resolved "https://registry.yarnpkg.com/right-align/-/right-align-0.1.3.tgz#61339b722fe6a3515689210d24e14c96148613ef" + integrity sha1-YTObci/mo1FWiSENJOFMlhSGE+8= + dependencies: + align-text "^0.1.1" rimraf@2.6.3: version "2.6.3" @@ -9617,7 +10473,12 @@ rimraf@^3.0.2: dependencies: glob "^7.1.3" -ripemd160@^2.0.0, ripemd160@^2.0.1: +ripemd160-min@0.0.6: + version "0.0.6" + resolved "https://registry.yarnpkg.com/ripemd160-min/-/ripemd160-min-0.0.6.tgz#a904b77658114474d02503e819dcc55853b67e62" + integrity sha512-+GcJgQivhs6S9qvLogusiTcS9kQUfgR75whKuy5jIhuiOfQuJ8fjqxV6EGD5duH1Y/FawFUMtMhyeq3Fbnib8A== + +ripemd160@^2.0.0, ripemd160@^2.0.1, ripemd160@^2.0.2: version "2.0.2" resolved "https://registry.yarnpkg.com/ripemd160/-/ripemd160-2.0.2.tgz#a1c1a6f624751577ba5d07914cbc92850585890c" integrity sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA== @@ -9760,7 +10621,7 @@ semver@^6.1.0, semver@^6.3.0: resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.0.tgz#ee0a64c8af5e8ceea67687b133761e1becbd1d3d" integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw== -semver@^7.2.1, semver@^7.3.2, semver@^7.3.4, semver@^7.3.5: +semver@^7.2.1, semver@^7.3.4, semver@^7.3.5: version "7.3.5" resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.5.tgz#0b621c879348d8998e4b0e4be94b3f12e6018ef7" integrity sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ== @@ -9837,7 +10698,7 @@ setimmediate@1.0.4: resolved "https://registry.yarnpkg.com/setimmediate/-/setimmediate-1.0.4.tgz#20e81de622d4a02588ce0c8da8973cbcf1d3138f" integrity sha1-IOgd5iLUoCWIzgyNqJc8vPHTE48= -setimmediate@^1.0.5: +setimmediate@^1.0.4, setimmediate@^1.0.5: version "1.0.5" resolved "https://registry.yarnpkg.com/setimmediate/-/setimmediate-1.0.5.tgz#290cbb232e306942d7d7ea9b83732ab7856f8285" integrity sha1-KQy7Iy4waULX1+qbg3Mqt4VvgoU= @@ -9863,6 +10724,13 @@ sha1@^1.1.1: charenc ">= 0.0.1" crypt ">= 0.0.1" +sha3@^2.1.1: + version "2.1.4" + resolved "https://registry.yarnpkg.com/sha3/-/sha3-2.1.4.tgz#000fac0fe7c2feac1f48a25e7a31b52a6492cc8f" + integrity sha512-S8cNxbyb0UGUM2VhRD4Poe5N58gJnJsLJ5vC7FYWGUmGhcsj4++WaIOBFVDxlG0W3To6xBuiRh+i0Qp2oNCOtg== + dependencies: + buffer "6.0.3" + shebang-command@^1.2.0: version "1.2.0" resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-1.2.0.tgz#44aac65b695b03398968c39f363fee5deafdf1ea" @@ -9896,7 +10764,7 @@ side-channel@^1.0.4: get-intrinsic "^1.0.2" object-inspect "^1.9.0" -signal-exit@^3.0.2: +signal-exit@^3.0.0, signal-exit@^3.0.2: version "3.0.3" resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.3.tgz#a1410c2edd8f077b08b4e253c8eacfcaf057461c" integrity sha512-VUJ49FC8U1OxwZLxIbTTrDvLnf/6TDgxZcK8wxR8zs13xpx7xbG60ndBlhNrFi2EMuFRoeDoJO7wthSLq42EjA== @@ -9987,6 +10855,16 @@ snapdragon@^0.8.1: source-map-resolve "^0.5.0" use "^3.1.0" +sol-digger@0.0.2: + version "0.0.2" + resolved "https://registry.yarnpkg.com/sol-digger/-/sol-digger-0.0.2.tgz#406c4a9d31e269e7f88eb1c2ea101318e5e09025" + integrity sha1-QGxKnTHiaef4jrHC6hATGOXgkCU= + +sol-explore@1.6.1: + version "1.6.1" + resolved "https://registry.yarnpkg.com/sol-explore/-/sol-explore-1.6.1.tgz#b59f073c69fe332560d5a10c32ba8ca7f2986cfb" + integrity sha1-tZ8HPGn+MyVg1aEMMrqMp/KYbPs= + solc@0.7.3: version "0.7.3" resolved "https://registry.yarnpkg.com/solc/-/solc-0.7.3.tgz#04646961bd867a744f63d2b4e3c0701ffdc7d78a" @@ -10035,11 +10913,11 @@ solhint-plugin-prettier@^0.0.5: prettier-linter-helpers "^1.0.0" solhint@^3.3.4: - version "3.3.4" - resolved "https://registry.yarnpkg.com/solhint/-/solhint-3.3.4.tgz#81770c60eeb027e6e447cb91ed599baf5e888e09" - integrity sha512-AEyjshF/PC6kox1c1l79Pji+DK9WVuk5u2WEh6bBKt188gWa63NBOAgYg0fBRr5CTUmsuGc1sGH7dgUVs83mKw== + version "3.3.6" + resolved "https://registry.yarnpkg.com/solhint/-/solhint-3.3.6.tgz#abe9af185a9a7defefba480047b3e42cbe9a1210" + integrity sha512-HWUxTAv2h7hx3s3hAab3ifnlwb02ZWhwFU/wSudUHqteMS3ll9c+m1FlGn9V8ztE2rf3Z82fQZA005Wv7KpcFA== dependencies: - "@solidity-parser/parser" "^0.12.0" + "@solidity-parser/parser" "^0.13.2" ajv "^6.6.1" antlr4 "4.7.1" ast-parents "0.0.1" @@ -10061,6 +10939,44 @@ solidity-comments-extractor@^0.0.7: resolved "https://registry.yarnpkg.com/solidity-comments-extractor/-/solidity-comments-extractor-0.0.7.tgz#99d8f1361438f84019795d928b931f4e5c39ca19" integrity sha512-wciNMLg/Irp8OKGrh3S2tfvZiZ0NEyILfcRCXCD4mp7SgK/i9gzLfhY2hY7VMCQJ3kH9UB9BzNdibIVMchzyYw== +solium-plugin-security@0.1.1: + version "0.1.1" + resolved "https://registry.yarnpkg.com/solium-plugin-security/-/solium-plugin-security-0.1.1.tgz#2a87bcf8f8c3abf7d198e292e4ac080284e3f3f6" + integrity sha512-kpLirBwIq4mhxk0Y/nn5cQ6qdJTI+U1LO3gpoNIcqNaW+sI058moXBe2UiHs+9wvF9IzYD49jcKhFTxcR9u9SQ== + +solium@^1.2.5: + version "1.2.5" + resolved "https://registry.yarnpkg.com/solium/-/solium-1.2.5.tgz#d036c30e2901e22137bbf342f106b17529ff22a8" + integrity sha512-NuNrm7fp8JcDN/P+SAdM5TVa4wYDtwVtLY/rG4eBOZrC5qItsUhmQKR/YhjszaEW4c8tNUYhkhQcwOsS25znpw== + dependencies: + ajv "^5.2.2" + chokidar "^1.6.0" + colors "^1.1.2" + commander "^2.9.0" + diff "^3.5.0" + eol "^0.9.1" + js-string-escape "^1.0.1" + lodash "^4.14.2" + sol-digger "0.0.2" + sol-explore "1.6.1" + solium-plugin-security "0.1.1" + solparse "2.2.8" + text-table "^0.2.0" + +solparse@2.2.8: + version "2.2.8" + resolved "https://registry.yarnpkg.com/solparse/-/solparse-2.2.8.tgz#d13e42dbed95ce32f43894f5ec53f00d14cf9f11" + integrity sha512-Tm6hdfG72DOxD40SD+T5ddbekWglNWjzDRSNq7ZDIOHVsyaJSeeunUuWNj4DE7uDrJK3tGQuX0ZTDZWNYsGPMA== + dependencies: + mocha "^4.0.1" + pegjs "^0.10.0" + yargs "^10.0.3" + +source-list-map@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/source-list-map/-/source-list-map-2.0.1.tgz#3993bd873bfc48479cca9ea3a547835c7c154b34" + integrity sha512-qnQ7gVMxGNxsiL4lEuJwe/To8UnK7fAnmbGEEH8RpLouuKbeEm0lhbQVFIrNSuB+G7tVrAlVsZgETT5nljf+Iw== + source-map-resolve@^0.5.0: version "0.5.3" resolved "https://registry.yarnpkg.com/source-map-resolve/-/source-map-resolve-0.5.3.tgz#190866bece7553e1f8f267a2ee82c606b5509a1a" @@ -10087,7 +11003,7 @@ source-map-support@^0.4.15: dependencies: source-map "^0.5.6" -source-map-support@^0.5.13, source-map-support@^0.5.17: +source-map-support@^0.5.13, source-map-support@^0.5.17, source-map-support@^0.5.19: version "0.5.19" resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.19.tgz#a98b62f86dcaf4f67399648c085291ab9e8fed61" integrity sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw== @@ -10100,12 +11016,12 @@ source-map-url@^0.4.0: 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: +source-map@^0.5.3, source-map@^0.5.6, source-map@^0.5.7, source-map@~0.5.1: version "0.5.7" resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.7.tgz#8a039d2d1021d22d1ea14c80d8ea468ba2ef3fcc" integrity sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w= -source-map@^0.6.0: +source-map@^0.6.0, source-map@~0.6.1: version "0.6.1" resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263" integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g== @@ -10132,9 +11048,9 @@ spdx-expression-parse@^3.0.0: spdx-license-ids "^3.0.0" spdx-license-ids@^3.0.0: - version "3.0.7" - resolved "https://registry.yarnpkg.com/spdx-license-ids/-/spdx-license-ids-3.0.7.tgz#e9c18a410e5ed7e12442a549fbd8afa767038d65" - integrity sha512-U+MTEOO0AiDzxwFvoa4JVnMV6mZlJKk2sBLt90s7G0Gd0Mlknc7kxEn3nuDPNZRta7O2uy8oLcZLVT+4sqNZHQ== + version "3.0.9" + resolved "https://registry.yarnpkg.com/spdx-license-ids/-/spdx-license-ids-3.0.9.tgz#8a595135def9592bda69709474f1cbeea7c2467f" + integrity sha512-Ki212dKK4ogX+xDo4CtOZBVIwhsKBEfsEEcwmJfLQzirgc2jIWdzg40Unxz/HzEUqM1WFzVlQSMF9kZZ2HboLQ== split-string@^3.0.1, split-string@^3.0.2: version "3.1.0" @@ -10163,7 +11079,7 @@ sshpk@^1.7.0: safer-buffer "^2.0.2" tweetnacl "~0.14.0" -stack-utils@^2.0.2: +stack-utils@^2.0.3: version "2.0.3" resolved "https://registry.yarnpkg.com/stack-utils/-/stack-utils-2.0.3.tgz#cd5f030126ff116b78ccb3c027fe302713b61277" integrity sha512-gL//fkxfWUsIlFL2Tl42Cl6+HFALEaB1FU76I/Fy+oZjRreP7OPMXFlGbxM7NQsI0ZpUfw76sHnv0WNYuTb7Iw== @@ -10195,6 +11111,25 @@ stealthy-require@^1.1.1: resolved "https://registry.yarnpkg.com/stealthy-require/-/stealthy-require-1.1.1.tgz#35b09875b4ff49f26a777e509b3090a3226bf24b" integrity sha1-NbCYdbT/SfJqd35QmzCQoyJr8ks= +stream-browserify@^2.0.1: + version "2.0.2" + resolved "https://registry.yarnpkg.com/stream-browserify/-/stream-browserify-2.0.2.tgz#87521d38a44aa7ee91ce1cd2a47df0cb49dd660b" + integrity sha512-nX6hmklHs/gr2FuxYDltq8fJA1GDlxKQCz8O/IM4atRqBH8OORmBNgfvW5gG10GT/qQ9u0CzIvr2X5Pkt6ntqg== + dependencies: + inherits "~2.0.1" + readable-stream "^2.0.2" + +stream-http@^2.7.2: + version "2.8.3" + resolved "https://registry.yarnpkg.com/stream-http/-/stream-http-2.8.3.tgz#b2d242469288a5a27ec4fe8933acf623de6514fc" + integrity sha512-+TSkfINHDo4J+ZobQLWiMouQYB+UVYFttRA94FpEzzJ7ZdqcL4uUUQ7WkdkI4DSozGmgBUE/a47L+38PenXhUw== + dependencies: + builtin-status-codes "^3.0.0" + inherits "^2.0.1" + readable-stream "^2.3.6" + to-arraybuffer "^1.0.0" + xtend "^4.0.0" + stream-to-pull-stream@^1.7.1: version "1.7.3" resolved "https://registry.yarnpkg.com/stream-to-pull-stream/-/stream-to-pull-stream-1.7.3.tgz#4161aa2d2eb9964de60bfa1af7feaf917e874ece" @@ -10222,7 +11157,7 @@ string-width@^1.0.1: 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: +"string-width@^1.0.2 || 2", string-width@^2.0.0, string-width@^2.1.0, string-width@^2.1.1: version "2.1.1" resolved "https://registry.yarnpkg.com/string-width/-/string-width-2.1.1.tgz#ab93f27a8dc13d28cac815c462143a6d9012ae9e" integrity sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw== @@ -10273,7 +11208,7 @@ string.prototype.trimstart@^1.0.4: call-bind "^1.0.2" define-properties "^1.1.3" -string_decoder@^1.1.1: +string_decoder@^1.0.0, string_decoder@^1.1.1: version "1.3.0" resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.3.0.tgz#42f114594a46cf1a8e30b0a84f56c78c3edac21e" integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA== @@ -10341,6 +11276,11 @@ strip-bom@^3.0.0: resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-3.0.0.tgz#2334c18e9c759f7bdd56fdef7e9ae3d588e68ed3" integrity sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM= +strip-eof@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/strip-eof/-/strip-eof-1.0.0.tgz#bb43ff5598a6eb05d89b59fcd129c983313606bf" + integrity sha1-u0P/VZim6wXYm1n80SnJgzE2Br8= + strip-final-newline@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/strip-final-newline/-/strip-final-newline-2.0.0.tgz#89b852fb2fcbe936f6f4b3187afb0a12c1ab58ad" @@ -10373,6 +11313,13 @@ super-split@^1.1.0: resolved "https://registry.yarnpkg.com/super-split/-/super-split-1.1.0.tgz#43b3ba719155f4d43891a32729d59b213d9155fc" integrity sha512-I4bA5mgcb6Fw5UJ+EkpzqXfiuvVGS/7MuND+oBxNFmxu3ugLNrdIatzBLfhFRMVMLxgSsRy+TjIktgkF9RFSNQ== +supports-color@4.4.0: + version "4.4.0" + resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-4.4.0.tgz#883f7ddabc165142b2a61427f3352ded195d1a3e" + integrity sha512-rKC3+DyXWgK0ZLKwmRsrkyHVZAjNkfzeehuFWdGGcqGDTZFH73+RH6S/RDAAxl9GusSjZSUWYLmT9N5pzXFOXQ== + dependencies: + has-flag "^2.0.0" + supports-color@6.0.0: version "6.0.0" resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-6.0.0.tgz#76cfe742cf1f41bb9b1c29ad03068c05b4c0e40a" @@ -10385,6 +11332,13 @@ supports-color@^2.0.0: resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-2.0.0.tgz#535d045ce6b6363fa40117084629995e9df324c7" integrity sha1-U10EXOa2Nj+kARcIRimZXp3zJMc= +supports-color@^4.2.1: + version "4.5.0" + resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-4.5.0.tgz#be7a0de484dec5c5cddf8b3d59125044912f635b" + integrity sha1-vnoN5ITexcXN34s9WRJQRJEvY1s= + dependencies: + has-flag "^2.0.0" + supports-color@^5.3.0: version "5.5.0" resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.5.0.tgz#e2e69a44ac8772f78a1ec0b35b689df6530efc8f" @@ -10442,7 +11396,7 @@ table@^5.2.3: slice-ansi "^2.1.0" string-width "^3.0.0" -table@^6.0.4: +table@^6.0.9: version "6.7.1" resolved "https://registry.yarnpkg.com/table/-/table-6.7.1.tgz#ee05592b7143831a8c94f3cee6aae4c1ccef33e2" integrity sha512-ZGum47Yi6KOOFDE8m223td53ath2enHcYLgOCjGr5ngu8bdIARQk6mN/wRMv4yMRcHnCSnHbCEha4sobQx5yWg== @@ -10454,6 +11408,11 @@ table@^6.0.4: string-width "^4.2.0" strip-ansi "^6.0.0" +tapable@^0.2.7: + version "0.2.9" + resolved "https://registry.yarnpkg.com/tapable/-/tapable-0.2.9.tgz#af2d8bbc9b04f74ee17af2b4d9048f807acd18a8" + integrity sha512-2wsvQ+4GwBvLPLWsNfLCDYGsW6xb7aeC6utq2Qh0PFwgEy7K7dsma9Jsmb2zSQj7GvYAyUGSntLtsv++GmgL1A== + tape@^4.6.3: version "4.13.3" resolved "https://registry.yarnpkg.com/tape/-/tape-4.13.3.tgz#51b3d91c83668c7a45b1a594b607dee0a0b46278" @@ -10541,6 +11500,13 @@ timed-out@^4.0.0, timed-out@^4.0.1: resolved "https://registry.yarnpkg.com/timed-out/-/timed-out-4.0.1.tgz#f32eacac5a175bea25d7fab565ab3ed8741ef56f" integrity sha1-8y6srFoXW+ol1/q1Zas+2HQe9W8= +timers-browserify@^2.0.4: + version "2.0.12" + resolved "https://registry.yarnpkg.com/timers-browserify/-/timers-browserify-2.0.12.tgz#44a45c11fbf407f34f97bccd1577c652361b00ee" + integrity sha512-9phl76Cqm6FhSX9Xe1ZUAMLtm1BLkKj2Qd5ApyWkXzsMRaA7dgr81kf4wJmQf/hAvg8EEyJxDo3du/0KlhPiKQ== + dependencies: + setimmediate "^1.0.4" + tiny-invariant@^1.1.0: version "1.1.0" resolved "https://registry.yarnpkg.com/tiny-invariant/-/tiny-invariant-1.1.0.tgz#634c5f8efdc27714b7f386c35e6760991d230875" @@ -10565,6 +11531,11 @@ tmp@0.1.0: dependencies: rimraf "^2.6.3" +to-arraybuffer@^1.0.0: + version "1.0.1" + resolved "https://registry.yarnpkg.com/to-arraybuffer/-/to-arraybuffer-1.0.1.tgz#7d229b1fcc637e466ca081180836a7aabff83f43" + integrity sha1-fSKbH8xjfkZsoIEYCDanqr/4P0M= + to-fast-properties@^1.0.3: version "1.0.3" resolved "https://registry.yarnpkg.com/to-fast-properties/-/to-fast-properties-1.0.3.tgz#b83571fa4d8c25b82e231b06e3a3055de4ca1a47" @@ -10646,9 +11617,9 @@ ts-essentials@^6.0.3: integrity sha512-2E4HIIj4tQJlIHuATRHayv0EfMGK3ris/GRk1E3CFnsZzeNV+hUmelbaTZHLtXaZppM5oLhHRtO04gINC4Jusw== ts-essentials@^7.0.1: - version "7.0.1" - resolved "https://registry.yarnpkg.com/ts-essentials/-/ts-essentials-7.0.1.tgz#d205508cae0cdadfb73c89503140cf2228389e2d" - integrity sha512-8lwh3QJtIc1UWhkQtr9XuksXu3O0YQdEE5g79guDfhCaU1FWTDIEDZ1ZSx4HTHUmlJZ8L812j3BZQ4a0aOUkSA== + version "7.0.2" + resolved "https://registry.yarnpkg.com/ts-essentials/-/ts-essentials-7.0.2.tgz#e21142df8034dbd444cb9573ed204d0b85fc64fb" + integrity sha512-qWPVC1xZGdefbsgFP7tPo+bsgSA2ZIXL1XeEe5M2WoMZxIOr/HbsHxP/Iv75IFhiMHMDGL7cOOwi5SXcgx9mHw== ts-generator@^0.1.1: version "0.1.1" @@ -10693,22 +11664,27 @@ tslib@^1.8.1, tslib@^1.9.0, tslib@^1.9.3: integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg== tslib@^2.2.0: - version "2.2.0" - resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.2.0.tgz#fb2c475977e35e241311ede2693cee1ec6698f5c" - integrity sha512-gS9GVHRU+RGn5KQM2rllAlR3dU6m7AcpJKdtH8gFvQiC4Otgk98XnmMU+nZenHt/+VhnBPWwgrJsyrdcw6i23w== + version "2.3.0" + resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.3.0.tgz#803b8cdab3e12ba581a4ca41c8839bbb0dacb09e" + integrity sha512-N82ooyxVNm6h1riLCoyS9e3fuJ3AMG2zIZs2Gd1ATcSFjSA23Q0fzjjZeh0jbJvWVDZ0cJT8yaNNaaXHzueNjg== tsort@0.0.1: version "0.0.1" resolved "https://registry.yarnpkg.com/tsort/-/tsort-0.0.1.tgz#e2280f5e817f8bf4275657fd0f9aebd44f5a2786" integrity sha1-4igPXoF/i/QnVlf9D5rr1E9aJ4Y= -tsutils@^3.17.1: +tsutils@^3.21.0: version "3.21.0" resolved "https://registry.yarnpkg.com/tsutils/-/tsutils-3.21.0.tgz#b48717d394cea6c1e096983eed58e9d61715b623" integrity sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA== dependencies: tslib "^1.8.1" +tty-browserify@0.0.0: + version "0.0.0" + resolved "https://registry.yarnpkg.com/tty-browserify/-/tty-browserify-0.0.0.tgz#a157ba402da24e9bf957f9aa69d524eed42901a6" + integrity sha1-oVe6QC2iTpv5V/mqadUk7tQpAaY= + tunnel-agent@^0.6.0: version "0.6.0" resolved "https://registry.yarnpkg.com/tunnel-agent/-/tunnel-agent-0.6.0.tgz#27a5dea06b36b04a0a9966774b290868f0fc40fd" @@ -10765,11 +11741,6 @@ type-fest@^0.7.1: resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.7.1.tgz#8dda65feaf03ed78f0a3f9678f1869147f7c5c48" integrity sha512-Ne2YiiGN8bmrmJJEuTWTLJR32nh/JdL1+PSicowtNb0WFpn59GK8/lfD61bVtzguz7b3PBt74nxpv/Pw5po5Rg== -type-fest@^0.8.1: - version "0.8.1" - resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.8.1.tgz#09e249ebde851d3b1e48d27c105444667f17b83d" - integrity sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA== - type-is@~1.6.17, type-is@~1.6.18: version "1.6.18" resolved "https://registry.yarnpkg.com/type-is/-/type-is-1.6.18.tgz#4e552cd05df09467dcbc4ef739de89f2cf37c131" @@ -10827,9 +11798,14 @@ typedarray@^0.0.6: integrity sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c= typescript@^4.1.3: - version "4.2.4" - resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.2.4.tgz#8610b59747de028fda898a8aef0e103f156d0961" - integrity sha512-V+evlYHZnQkaz8TRBuxTA92yZBPotr5H+WhQ7bD3hZUndx5tGOa1fuCgeSjxAzM1RiN5IzvadIXTVefuuwZCRg== + version "4.3.5" + resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.3.5.tgz#4d1c37cc16e893973c45a06886b7113234f119f4" + integrity sha512-DqQgihaQ9cUrskJo9kIyW/+g0Vxsk8cDtZ52a3NGh0YNTfpUSArXSohyUGnvbPazEPLu398C0UxmKSOrPumUzA== + +typescript@^4.3.4: + version "4.3.4" + resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.3.4.tgz#3f85b986945bcf31071decdd96cf8bfa65f9dcbc" + integrity sha512-uauPG7XZn9F/mo+7MrsRjyvbxFpzemRjKEZXS4AK83oP2KKOJPvb+9cO/gmnv8arWZvhnjVOXz7B49m1l0e9Ew== typewise-core@^1.2, typewise-core@^1.2.0: version "1.2.0" @@ -10853,12 +11829,36 @@ typical@^2.6.0, typical@^2.6.1: resolved "https://registry.yarnpkg.com/typical/-/typical-2.6.1.tgz#5c080e5d661cbbe38259d2e70a3c7253e873881d" integrity sha1-XAgOXWYcu+OCWdLnCjxyU+hziB0= +uglify-js@^2.8.29: + version "2.8.29" + resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-2.8.29.tgz#29c5733148057bb4e1f75df35b7a9cb72e6a59dd" + integrity sha1-KcVzMUgFe7Th913zW3qcty5qWd0= + dependencies: + source-map "~0.5.1" + yargs "~3.10.0" + optionalDependencies: + uglify-to-browserify "~1.0.0" + +uglify-to-browserify@~1.0.0: + version "1.0.2" + resolved "https://registry.yarnpkg.com/uglify-to-browserify/-/uglify-to-browserify-1.0.2.tgz#6e0924d6bda6b5afe349e39a6d632850a0f882b7" + integrity sha1-bgkk1r2mta/jSeOabWMoUKD4grc= + +uglifyjs-webpack-plugin@^0.4.6: + version "0.4.6" + resolved "https://registry.yarnpkg.com/uglifyjs-webpack-plugin/-/uglifyjs-webpack-plugin-0.4.6.tgz#b951f4abb6bd617e66f63eb891498e391763e309" + integrity sha1-uVH0q7a9YX5m9j64kUmOORdj4wk= + dependencies: + source-map "^0.5.6" + uglify-js "^2.8.29" + webpack-sources "^1.0.1" + ultron@~1.1.0: version "1.1.1" resolved "https://registry.yarnpkg.com/ultron/-/ultron-1.1.1.tgz#9fe1536a10a664a65266a1e3ccf85fd36302bc9c" integrity sha512-UIEXBNeYmKptWH6z8ZnqTeS8fV74zG0/eRU9VGkpzz+LIJNs8W/zM/L+7ctCkRrgbNnnR0xxw4bKOr0cW0N0Og== -unbox-primitive@^1.0.0: +unbox-primitive@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/unbox-primitive/-/unbox-primitive-1.0.1.tgz#085e215625ec3162574dc8859abee78a59b14471" integrity sha512-tZU/3NqK3dA5gpE1KtyiJUrEB0lxnGkMFHptJ7q6ewdZ8s12QrODwNbhIJStmJkd1QDXa1NRA8aF2A1zk/Ypyw== @@ -10926,6 +11926,11 @@ untildify@^4.0.0: resolved "https://registry.yarnpkg.com/untildify/-/untildify-4.0.0.tgz#2bc947b953652487e4600949fb091e3ae8cd919b" integrity sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw== +upath@^1.1.1: + version "1.2.0" + resolved "https://registry.yarnpkg.com/upath/-/upath-1.2.0.tgz#8f66dbcd55a883acdae4408af8b035a5044c1894" + integrity sha512-aZwGpamFO61g3OlfT7OQCHqhGnW43ieH9WZeP7QxN/G/jS4jfqUkZxoryvJgVPEcrl5NL/ggHsSmLMHuH64Lhg== + uri-js@^4.2.2: version "4.4.1" resolved "https://registry.yarnpkg.com/uri-js/-/uri-js-4.4.1.tgz#9b1a52595225859e55f669d928f88c6c57f2a77e" @@ -11003,10 +12008,24 @@ util.promisify@^1.0.0, util.promisify@^1.0.1: has-symbols "^1.0.1" object.getownpropertydescriptors "^2.1.1" +util@0.10.3: + version "0.10.3" + resolved "https://registry.yarnpkg.com/util/-/util-0.10.3.tgz#7afb1afe50805246489e3db7fe0ed379336ac0f9" + integrity sha1-evsa/lCAUkZInj23/g7TeTNqwPk= + dependencies: + inherits "2.0.1" + +util@^0.11.0: + version "0.11.1" + resolved "https://registry.yarnpkg.com/util/-/util-0.11.1.tgz#3236733720ec64bb27f6e26f421aaa2e1b588d61" + integrity sha512-HShAsny+zS2TZfaXxD9tYj4HQGlBezXZMZuM/S5PKLLoZkShZiGk9o5CzukI1LVHZvjdvZ2Sj1aW/Ndn2NB/HQ== + dependencies: + inherits "2.0.3" + util@^0.12.0: - version "0.12.3" - resolved "https://registry.yarnpkg.com/util/-/util-0.12.3.tgz#971bb0292d2cc0c892dab7c6a5d37c2bec707888" - integrity sha512-I8XkoQwE+fPQEhy9v012V+TSdH2kp9ts29i20TaaDUXsg7x/onePbhFJUExBfv/2ay1ZOp/Vsm3nDlmnFGSAog== + version "0.12.4" + resolved "https://registry.yarnpkg.com/util/-/util-0.12.4.tgz#66121a31420df8f01ca0c464be15dfa1d1850253" + integrity sha512-bxZ9qtSlGUWSOy9Qa9Xgk11kSslpuZwaxCg4sNIDj6FLucDab2JxnHwyNTCpHMtK1MjoQiWQ6DiUMZYbSrO+Sw== dependencies: inherits "^2.0.3" is-arguments "^1.0.4" @@ -11067,6 +12086,29 @@ verror@1.10.0: core-util-is "1.0.2" extsprintf "^1.2.0" +vm-browserify@^1.0.1: + version "1.1.2" + resolved "https://registry.yarnpkg.com/vm-browserify/-/vm-browserify-1.1.2.tgz#78641c488b8e6ca91a75f511e7a3b32a86e5dda0" + integrity sha512-2ham8XPWTONajOR0ohOKOHXkm3+gaBmGut3SRuu75xLd/RRaY6vqgh8NBYYk7+RW3u5AtzPQZG8F10LHkl0lAQ== + +watchpack-chokidar2@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/watchpack-chokidar2/-/watchpack-chokidar2-2.0.1.tgz#38500072ee6ece66f3769936950ea1771be1c957" + integrity sha512-nCFfBIPKr5Sh61s4LPpy1Wtfi0HE8isJ3d2Yb5/Ppw2P2B/3eVSEBjKfN0fmHJSK14+31KwMKmcrzs2GM4P0Ww== + dependencies: + chokidar "^2.1.8" + +watchpack@^1.4.0: + version "1.7.5" + resolved "https://registry.yarnpkg.com/watchpack/-/watchpack-1.7.5.tgz#1267e6c55e0b9b5be44c2023aed5437a2c26c453" + integrity sha512-9P3MWk6SrKjHsGkLT2KHXdQ/9SNkyoJbabxnKOoJepsvJjJG8uYTR3yTPxPQvNDI3w4Nz1xnE0TLHK4RIVe/MQ== + dependencies: + graceful-fs "^4.1.2" + neo-async "^2.5.0" + optionalDependencies: + chokidar "^3.4.1" + watchpack-chokidar2 "^2.0.1" + web3-bzz@1.2.11: version "1.2.11" resolved "https://registry.yarnpkg.com/web3-bzz/-/web3-bzz-1.2.11.tgz#41bc19a77444bd5365744596d778b811880f707f" @@ -11077,16 +12119,6 @@ web3-bzz@1.2.11: swarm-js "^0.1.40" underscore "1.9.1" -web3-bzz@1.3.5: - version "1.3.5" - resolved "https://registry.yarnpkg.com/web3-bzz/-/web3-bzz-1.3.5.tgz#f181a1319d9f867f4183b147e7aebd21aecff4a0" - integrity sha512-XiEUAbB1uKm/agqfwBsCW8fbw+sma85TfwuDpdcy591vinVk0S9TfWgLxro6v1KJ6nSELySIbKGbAJbh2GSyxw== - dependencies: - "@types/node" "^12.12.6" - got "9.6.0" - swarm-js "^0.1.40" - underscore "1.9.1" - web3-bzz@1.3.6: version "1.3.6" resolved "https://registry.yarnpkg.com/web3-bzz/-/web3-bzz-1.3.6.tgz#95f370aecc3ff6ad07f057e6c0c916ef09b04dde" @@ -11097,6 +12129,16 @@ web3-bzz@1.3.6: swarm-js "^0.1.40" underscore "1.12.1" +web3-bzz@1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/web3-bzz/-/web3-bzz-1.4.0.tgz#78a5db3544624b6709b2554094d931639f6f85b8" + integrity sha512-KhXmz8hcfGsqhplB7NrekAeNkG2edHjXV4bL3vnXde8RGMWpabpSNxuwiGv+dv/3nWlrHatH0vGooONYCkP5TA== + dependencies: + "@types/node" "^12.12.6" + got "9.6.0" + swarm-js "^0.1.40" + underscore "1.12.1" + web3-core-helpers@1.2.11: version "1.2.11" resolved "https://registry.yarnpkg.com/web3-core-helpers/-/web3-core-helpers-1.2.11.tgz#84c681ed0b942c0203f3b324a245a127e8c67a99" @@ -11106,15 +12148,6 @@ web3-core-helpers@1.2.11: web3-eth-iban "1.2.11" web3-utils "1.2.11" -web3-core-helpers@1.3.5: - version "1.3.5" - resolved "https://registry.yarnpkg.com/web3-core-helpers/-/web3-core-helpers-1.3.5.tgz#9f0ff7ed40befb9f691986e66fd94c828c7b1b13" - integrity sha512-HYh3ix5FjysgT0jyzD8s/X5ym0b4BGU7I2QtuBiydMnE0mQEWy7GcT9XKpTySA8FTOHHIAQYvQS07DN/ky3UzA== - dependencies: - underscore "1.9.1" - web3-eth-iban "1.3.5" - web3-utils "1.3.5" - web3-core-helpers@1.3.6: version "1.3.6" resolved "https://registry.yarnpkg.com/web3-core-helpers/-/web3-core-helpers-1.3.6.tgz#c478246a9abe4e5456acf42657dac2f7c330be74" @@ -11124,6 +12157,15 @@ web3-core-helpers@1.3.6: web3-eth-iban "1.3.6" web3-utils "1.3.6" +web3-core-helpers@1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/web3-core-helpers/-/web3-core-helpers-1.4.0.tgz#5cbed46dd325b9498f6fafb15aed4a4295cce514" + integrity sha512-8Ebq0nmRfzw7iPoXbIRHEWOuPh+1cOV3OOEvKm5Od3McZOjja914vdk+DM3MgmbSpDzYJRFM6KoF0+Z/U/1bPw== + dependencies: + underscore "1.12.1" + web3-eth-iban "1.4.0" + web3-utils "1.4.0" + web3-core-method@1.2.11: version "1.2.11" resolved "https://registry.yarnpkg.com/web3-core-method/-/web3-core-method-1.2.11.tgz#f880137d1507a0124912bf052534f168b8d8fbb6" @@ -11136,18 +12178,6 @@ web3-core-method@1.2.11: web3-core-subscriptions "1.2.11" web3-utils "1.2.11" -web3-core-method@1.3.5: - version "1.3.5" - resolved "https://registry.yarnpkg.com/web3-core-method/-/web3-core-method-1.3.5.tgz#995fe12f3b364469e5208a88d72736327b231faa" - integrity sha512-hCbmgQ+At6OTuaNGAdjXMsCr4eUCmp9yGKSuaB5HdkNVDpqFso4HHjVxcjNrTyJp3OZnyjKBzQzK1ZWLpLl84Q== - dependencies: - "@ethersproject/transactions" "^5.0.0-beta.135" - underscore "1.9.1" - web3-core-helpers "1.3.5" - web3-core-promievent "1.3.5" - web3-core-subscriptions "1.3.5" - web3-utils "1.3.5" - web3-core-method@1.3.6: version "1.3.6" resolved "https://registry.yarnpkg.com/web3-core-method/-/web3-core-method-1.3.6.tgz#4b0334edd94b03dfec729d113c69a4eb6ebc68ae" @@ -11160,6 +12190,18 @@ web3-core-method@1.3.6: web3-core-subscriptions "1.3.6" web3-utils "1.3.6" +web3-core-method@1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/web3-core-method/-/web3-core-method-1.4.0.tgz#0e26001e4029d359731b25a82e0bed4d1bef8392" + integrity sha512-KW9922fEkgKu8zDcJR8Iikg/epsuWMArAUVTipKVwzAI5TVdvOMRgSe/b7IIDRUIeoeXMARmJ+PrAlx+IU2acQ== + dependencies: + "@ethersproject/transactions" "^5.0.0-beta.135" + underscore "1.12.1" + web3-core-helpers "1.4.0" + web3-core-promievent "1.4.0" + web3-core-subscriptions "1.4.0" + web3-utils "1.4.0" + web3-core-promievent@1.2.11: version "1.2.11" resolved "https://registry.yarnpkg.com/web3-core-promievent/-/web3-core-promievent-1.2.11.tgz#51fe97ca0ddec2f99bf8c3306a7a8e4b094ea3cf" @@ -11167,13 +12209,6 @@ web3-core-promievent@1.2.11: dependencies: eventemitter3 "4.0.4" -web3-core-promievent@1.3.5: - version "1.3.5" - resolved "https://registry.yarnpkg.com/web3-core-promievent/-/web3-core-promievent-1.3.5.tgz#33c34811cc4e2987c56e5192f9a014368c42ca39" - integrity sha512-K0j8x3ZJr0eAyNvyUCxOUsSTd4hco0/9nxxlyOuijcsa6YV8l9NL6eqhniWbSyxCJT8ka5Mb7yAiUZe69EDLBQ== - dependencies: - eventemitter3 "4.0.4" - web3-core-promievent@1.3.6: version "1.3.6" resolved "https://registry.yarnpkg.com/web3-core-promievent/-/web3-core-promievent-1.3.6.tgz#6c27dc79de8f71b74f5d17acaf9aaf593d3cb0c9" @@ -11181,6 +12216,13 @@ web3-core-promievent@1.3.6: dependencies: eventemitter3 "4.0.4" +web3-core-promievent@1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/web3-core-promievent/-/web3-core-promievent-1.4.0.tgz#531644dab287e83653d983aeb3d9daa0f894f775" + integrity sha512-YEwko22kcry7lHwbe0k80BrjXCZ+73jMdvZtptRH5k2B+XZ1XtmXwYL1PFIlZy9V0zgZijdg+3GabCnAHjVXAw== + dependencies: + eventemitter3 "4.0.4" + web3-core-requestmanager@1.2.11: version "1.2.11" resolved "https://registry.yarnpkg.com/web3-core-requestmanager/-/web3-core-requestmanager-1.2.11.tgz#fe6eb603fbaee18530293a91f8cf26d8ae28c45a" @@ -11192,18 +12234,6 @@ web3-core-requestmanager@1.2.11: web3-providers-ipc "1.2.11" web3-providers-ws "1.2.11" -web3-core-requestmanager@1.3.5: - version "1.3.5" - resolved "https://registry.yarnpkg.com/web3-core-requestmanager/-/web3-core-requestmanager-1.3.5.tgz#c452ea85fcffdf5b82b84c250707b638790d0e75" - integrity sha512-9l294U3Ga8qmvv8E37BqjQREfMs+kFnkU3PY28g9DZGYzKvl3V1dgDYqxyrOBdCFhc7rNSpHdgC4PrVHjouspg== - dependencies: - underscore "1.9.1" - util "^0.12.0" - web3-core-helpers "1.3.5" - web3-providers-http "1.3.5" - web3-providers-ipc "1.3.5" - web3-providers-ws "1.3.5" - web3-core-requestmanager@1.3.6: version "1.3.6" resolved "https://registry.yarnpkg.com/web3-core-requestmanager/-/web3-core-requestmanager-1.3.6.tgz#4fea269fe913fd4fca464b4f7c65cb94857b5b2a" @@ -11216,6 +12246,18 @@ web3-core-requestmanager@1.3.6: web3-providers-ipc "1.3.6" web3-providers-ws "1.3.6" +web3-core-requestmanager@1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/web3-core-requestmanager/-/web3-core-requestmanager-1.4.0.tgz#39043da0e1a1b1474f85af531df786e6036ef4b3" + integrity sha512-qIwKJO5T0KkUAIL7y9JRSUkk3+LaCwghdUHK8FzbMvq6R1W9lgCBnccqFGEI76EJjHvsiw4kEKBEXowdB3xenQ== + dependencies: + underscore "1.12.1" + util "^0.12.0" + web3-core-helpers "1.4.0" + web3-providers-http "1.4.0" + web3-providers-ipc "1.4.0" + web3-providers-ws "1.4.0" + web3-core-subscriptions@1.2.11: version "1.2.11" resolved "https://registry.yarnpkg.com/web3-core-subscriptions/-/web3-core-subscriptions-1.2.11.tgz#beca908fbfcb050c16f45f3f0f4c205e8505accd" @@ -11225,15 +12267,6 @@ web3-core-subscriptions@1.2.11: underscore "1.9.1" web3-core-helpers "1.2.11" -web3-core-subscriptions@1.3.5: - version "1.3.5" - resolved "https://registry.yarnpkg.com/web3-core-subscriptions/-/web3-core-subscriptions-1.3.5.tgz#7c4dc9d559e344d852de2cf01bd0cc13c94023cb" - integrity sha512-6mtXdaEB1V1zKLqYBq7RF2W75AK5ZJNGpW6QYC7Zvbku7zq1ZlgaUkJo88JKMWJ7etfaHaYqQ/7VveHk5sQynA== - dependencies: - eventemitter3 "4.0.4" - underscore "1.9.1" - web3-core-helpers "1.3.5" - web3-core-subscriptions@1.3.6: version "1.3.6" resolved "https://registry.yarnpkg.com/web3-core-subscriptions/-/web3-core-subscriptions-1.3.6.tgz#ee24e7974d1d72ff6c992c599deba4ef9b308415" @@ -11243,6 +12276,15 @@ web3-core-subscriptions@1.3.6: underscore "1.12.1" web3-core-helpers "1.3.6" +web3-core-subscriptions@1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/web3-core-subscriptions/-/web3-core-subscriptions-1.4.0.tgz#ec44e5cfe7bffe0c2a9da330007f88e08e1b5837" + integrity sha512-/UMC9rSLEd0U+h6Qanx6CM29o/cfUyGWgl/HM6O/AIuth9G+34QBuKDa11Gr2Qg6F8Lr9tSFm8QIGVniOx9i5A== + dependencies: + eventemitter3 "4.0.4" + underscore "1.12.1" + web3-core-helpers "1.4.0" + web3-core@1.2.11: version "1.2.11" resolved "https://registry.yarnpkg.com/web3-core/-/web3-core-1.2.11.tgz#1043cacc1becb80638453cc5b2a14be9050288a7" @@ -11256,19 +12298,6 @@ web3-core@1.2.11: web3-core-requestmanager "1.2.11" web3-utils "1.2.11" -web3-core@1.3.5: - version "1.3.5" - resolved "https://registry.yarnpkg.com/web3-core/-/web3-core-1.3.5.tgz#1e9335e6c4549dac09aaa07157242ebd6d097226" - integrity sha512-VQjTvnGTqJwDwjKEHSApea3RmgtFGLDSJ6bqrOyHROYNyTyKYjFQ/drG9zs3rjDkND9mgh8foI1ty37Qua3QCQ== - dependencies: - "@types/bn.js" "^4.11.5" - "@types/node" "^12.12.6" - bignumber.js "^9.0.0" - web3-core-helpers "1.3.5" - web3-core-method "1.3.5" - web3-core-requestmanager "1.3.5" - web3-utils "1.3.5" - web3-core@1.3.6: version "1.3.6" resolved "https://registry.yarnpkg.com/web3-core/-/web3-core-1.3.6.tgz#a6a761d1ff2f3ee462b8dab679229d2f8e267504" @@ -11282,6 +12311,19 @@ web3-core@1.3.6: web3-core-requestmanager "1.3.6" web3-utils "1.3.6" +web3-core@1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/web3-core/-/web3-core-1.4.0.tgz#db830ed9fa9cca37479c501f0e5bc4201493b46b" + integrity sha512-VRNMNqwzvPeKIet2l9BMApPHoUv0UqwaZH0lZJhG2RBko42w9Xls+pQwfVNSV16j04t/ehm1aLRV2Sx6lzVfRg== + dependencies: + "@types/bn.js" "^4.11.5" + "@types/node" "^12.12.6" + bignumber.js "^9.0.0" + web3-core-helpers "1.4.0" + web3-core-method "1.4.0" + web3-core-requestmanager "1.4.0" + web3-utils "1.4.0" + web3-eth-abi@1.2.11: version "1.2.11" resolved "https://registry.yarnpkg.com/web3-eth-abi/-/web3-eth-abi-1.2.11.tgz#a887494e5d447c2926d557a3834edd66e17af9b0" @@ -11291,15 +12333,6 @@ web3-eth-abi@1.2.11: underscore "1.9.1" web3-utils "1.2.11" -web3-eth-abi@1.3.5: - version "1.3.5" - resolved "https://registry.yarnpkg.com/web3-eth-abi/-/web3-eth-abi-1.3.5.tgz#eeffab0a4b318c47b8777de90983ca45614f8173" - integrity sha512-bkbG2v/mOW5DH6rF/SEgqunusjYoEi2IBw+fkmD3rzWDaEY7+/i1xY94AeO257d06QMgld75GtV/N+aEs7A6vQ== - dependencies: - "@ethersproject/abi" "5.0.7" - underscore "1.9.1" - web3-utils "1.3.5" - web3-eth-abi@1.3.6: version "1.3.6" resolved "https://registry.yarnpkg.com/web3-eth-abi/-/web3-eth-abi-1.3.6.tgz#4272ca48d817aa651bbf97b269f5ff10abc2b8a9" @@ -11309,6 +12342,15 @@ web3-eth-abi@1.3.6: underscore "1.12.1" web3-utils "1.3.6" +web3-eth-abi@1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/web3-eth-abi/-/web3-eth-abi-1.4.0.tgz#83f9f0ce48fd6d6b233a30a33bd674b3518e472b" + integrity sha512-FtmWipG/dSSkTGFb72JCwky7Jd0PIvd0kGTInWQwIEZlw5qMOYl61WZ9gwfojFHvHF6q1eKncerQr+MRXHO6zg== + dependencies: + "@ethersproject/abi" "5.0.7" + underscore "1.12.1" + web3-utils "1.4.0" + web3-eth-accounts@1.2.11: version "1.2.11" resolved "https://registry.yarnpkg.com/web3-eth-accounts/-/web3-eth-accounts-1.2.11.tgz#a9e3044da442d31903a7ce035a86d8fa33f90520" @@ -11326,23 +12368,6 @@ web3-eth-accounts@1.2.11: web3-core-method "1.2.11" web3-utils "1.2.11" -web3-eth-accounts@1.3.5: - version "1.3.5" - resolved "https://registry.yarnpkg.com/web3-eth-accounts/-/web3-eth-accounts-1.3.5.tgz#c23ee748759a6a06d6485a9322b106baa944dcdd" - integrity sha512-r3WOR21rgm6Cd6OFnifr3Tizdm5K+g2TsSOPySwX4FrgLrYDL6ck4zr5VXUPz+llpSExb/JztpE8pqEHr3U2NA== - 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.3.5" - web3-core-helpers "1.3.5" - web3-core-method "1.3.5" - web3-utils "1.3.5" - web3-eth-accounts@1.3.6: version "1.3.6" resolved "https://registry.yarnpkg.com/web3-eth-accounts/-/web3-eth-accounts-1.3.6.tgz#f9fcb50b28ee58090ab292a10d996155caa2b474" @@ -11360,6 +12385,24 @@ web3-eth-accounts@1.3.6: web3-core-method "1.3.6" web3-utils "1.3.6" +web3-eth-accounts@1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/web3-eth-accounts/-/web3-eth-accounts-1.4.0.tgz#25fc4b2b582a16b77c1492f27f58c59481156068" + integrity sha512-tETHBvfO3Z7BXZ7HJIwuX7ol6lPefP55X7b4IiX82C1PujHwsxENY7c/3wyxzqKoDyH6zfyEQo17yhxkhsM1oA== + 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" + underscore "1.12.1" + uuid "3.3.2" + web3-core "1.4.0" + web3-core-helpers "1.4.0" + web3-core-method "1.4.0" + web3-utils "1.4.0" + web3-eth-contract@1.2.11: version "1.2.11" resolved "https://registry.yarnpkg.com/web3-eth-contract/-/web3-eth-contract-1.2.11.tgz#917065902bc27ce89da9a1da26e62ef663663b90" @@ -11375,21 +12418,6 @@ web3-eth-contract@1.2.11: web3-eth-abi "1.2.11" web3-utils "1.2.11" -web3-eth-contract@1.3.5: - version "1.3.5" - resolved "https://registry.yarnpkg.com/web3-eth-contract/-/web3-eth-contract-1.3.5.tgz#b41ecf8612b379c4fb1c614e950135717aa8f919" - integrity sha512-WfGVeQquN3D7Qm+KEIN9EI7yrm/fL2V9Y4+YhDWiKA/ns1pX1LYcEWojTOnBXCnPF3tcvoKKL+KBxXg1iKm38A== - dependencies: - "@types/bn.js" "^4.11.5" - underscore "1.9.1" - web3-core "1.3.5" - web3-core-helpers "1.3.5" - web3-core-method "1.3.5" - web3-core-promievent "1.3.5" - web3-core-subscriptions "1.3.5" - web3-eth-abi "1.3.5" - web3-utils "1.3.5" - web3-eth-contract@1.3.6: version "1.3.6" resolved "https://registry.yarnpkg.com/web3-eth-contract/-/web3-eth-contract-1.3.6.tgz#cccf4d32dc56917fb6923e778498a9ba2a5ba866" @@ -11405,6 +12433,21 @@ web3-eth-contract@1.3.6: web3-eth-abi "1.3.6" web3-utils "1.3.6" +web3-eth-contract@1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/web3-eth-contract/-/web3-eth-contract-1.4.0.tgz#604187d1e44365fa0c0592e61ac5a1b5fd7c2eaa" + integrity sha512-GfIhOzfp/ZXKd+1tFEH3ePq0DEsvq9XO5tOsI0REDtEYUj2GNxO5e/x/Fhekk7iLZ7xAqSzDMweFruDQ1fxn0A== + dependencies: + "@types/bn.js" "^4.11.5" + underscore "1.12.1" + web3-core "1.4.0" + web3-core-helpers "1.4.0" + web3-core-method "1.4.0" + web3-core-promievent "1.4.0" + web3-core-subscriptions "1.4.0" + web3-eth-abi "1.4.0" + web3-utils "1.4.0" + web3-eth-ens@1.2.11: version "1.2.11" resolved "https://registry.yarnpkg.com/web3-eth-ens/-/web3-eth-ens-1.2.11.tgz#26d4d7f16d6cbcfff918e39832b939edc3162532" @@ -11420,21 +12463,6 @@ web3-eth-ens@1.2.11: web3-eth-contract "1.2.11" web3-utils "1.2.11" -web3-eth-ens@1.3.5: - version "1.3.5" - resolved "https://registry.yarnpkg.com/web3-eth-ens/-/web3-eth-ens-1.3.5.tgz#5a28d23eb402fb1f6964da60ea60641e4d24d366" - integrity sha512-5bkpFTXV18CvaVP8kCbLZZm2r1TWUv9AsXH+80yz8bTZulUGvXsBMRfK6e5nfEr2Yv59xlIXCFoalmmySI9EJw== - dependencies: - content-hash "^2.5.2" - eth-ens-namehash "2.0.8" - underscore "1.9.1" - web3-core "1.3.5" - web3-core-helpers "1.3.5" - web3-core-promievent "1.3.5" - web3-eth-abi "1.3.5" - web3-eth-contract "1.3.5" - web3-utils "1.3.5" - web3-eth-ens@1.3.6: version "1.3.6" resolved "https://registry.yarnpkg.com/web3-eth-ens/-/web3-eth-ens-1.3.6.tgz#0d28c5d4ea7b4462ef6c077545a77956a6cdf175" @@ -11450,6 +12478,21 @@ web3-eth-ens@1.3.6: web3-eth-contract "1.3.6" web3-utils "1.3.6" +web3-eth-ens@1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/web3-eth-ens/-/web3-eth-ens-1.4.0.tgz#4e66dfc3bdc6439553482972ffb2a181f1c12cbc" + integrity sha512-jR1KorjU1erpYFpFzsMXAWZnHhqUqWPBq/4+BGVj7/pJ43+A3mrE1eB0zl91Dwc1RTNwOhB02iOj1c9OlpGr3g== + dependencies: + content-hash "^2.5.2" + eth-ens-namehash "2.0.8" + underscore "1.12.1" + web3-core "1.4.0" + web3-core-helpers "1.4.0" + web3-core-promievent "1.4.0" + web3-eth-abi "1.4.0" + web3-eth-contract "1.4.0" + web3-utils "1.4.0" + web3-eth-iban@1.2.11: version "1.2.11" resolved "https://registry.yarnpkg.com/web3-eth-iban/-/web3-eth-iban-1.2.11.tgz#f5f73298305bc7392e2f188bf38a7362b42144ef" @@ -11458,14 +12501,6 @@ web3-eth-iban@1.2.11: bn.js "^4.11.9" web3-utils "1.2.11" -web3-eth-iban@1.3.5: - version "1.3.5" - resolved "https://registry.yarnpkg.com/web3-eth-iban/-/web3-eth-iban-1.3.5.tgz#dff1e37864e23a3387016ec4db96cdc290a6fbd6" - integrity sha512-x+BI/d2Vt0J1cKK8eFd4W0f1TDjgEOYCwiViTb28lLE+tqrgyPqWDA+l6UlKYLF/yMFX3Dym4ofcCOtgcn4q4g== - dependencies: - bn.js "^4.11.9" - web3-utils "1.3.5" - web3-eth-iban@1.3.6: version "1.3.6" resolved "https://registry.yarnpkg.com/web3-eth-iban/-/web3-eth-iban-1.3.6.tgz#0d6ba21fe78f190af8919e9cd5453882457209e0" @@ -11474,6 +12509,14 @@ web3-eth-iban@1.3.6: bn.js "^4.11.9" web3-utils "1.3.6" +web3-eth-iban@1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/web3-eth-iban/-/web3-eth-iban-1.4.0.tgz#b54902c019d677b6356d838b3e964f925017c143" + integrity sha512-YNx748VzwiBe0gvtZjvU9BQsooZ9s9sAlmiDWJOMcvMbUTDhC7SvxA7vV/vrnOxL6oGHRh0U/azsYNxxlKiTBw== + dependencies: + bn.js "^4.11.9" + web3-utils "1.4.0" + web3-eth-personal@1.2.11: version "1.2.11" resolved "https://registry.yarnpkg.com/web3-eth-personal/-/web3-eth-personal-1.2.11.tgz#a38b3942a1d87a62070ce0622a941553c3d5aa70" @@ -11486,18 +12529,6 @@ web3-eth-personal@1.2.11: web3-net "1.2.11" web3-utils "1.2.11" -web3-eth-personal@1.3.5: - version "1.3.5" - resolved "https://registry.yarnpkg.com/web3-eth-personal/-/web3-eth-personal-1.3.5.tgz#bc5d5b900bc4824139af2ef01eaf8e9855c644ba" - integrity sha512-xELQHNZ8p3VoO1582ghCaq+Bx7pSkOOalc6/ACOCGtHDMelqgVejrmSIZGScYl+k0HzngmQAzURZWQocaoGM1g== - dependencies: - "@types/node" "^12.12.6" - web3-core "1.3.5" - web3-core-helpers "1.3.5" - web3-core-method "1.3.5" - web3-net "1.3.5" - web3-utils "1.3.5" - web3-eth-personal@1.3.6: version "1.3.6" resolved "https://registry.yarnpkg.com/web3-eth-personal/-/web3-eth-personal-1.3.6.tgz#226137916754c498f0284f22c55924c87a2efcf0" @@ -11510,6 +12541,18 @@ web3-eth-personal@1.3.6: web3-net "1.3.6" web3-utils "1.3.6" +web3-eth-personal@1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/web3-eth-personal/-/web3-eth-personal-1.4.0.tgz#77420d1f49e36f8c461a61aeabac16045d8592c0" + integrity sha512-8Ip6xZ8plmWqAD4ESbKUIPVV9gfTAFFm0ff1FQIw9I9kYvFlBIPzukvm852w2SftGem+/iRH+2+2mK7HvuKXZQ== + dependencies: + "@types/node" "^12.12.6" + web3-core "1.4.0" + web3-core-helpers "1.4.0" + web3-core-method "1.4.0" + web3-net "1.4.0" + web3-utils "1.4.0" + web3-eth@1.2.11: version "1.2.11" resolved "https://registry.yarnpkg.com/web3-eth/-/web3-eth-1.2.11.tgz#4c81fcb6285b8caf544058fba3ae802968fdc793" @@ -11529,25 +12572,6 @@ web3-eth@1.2.11: web3-net "1.2.11" web3-utils "1.2.11" -web3-eth@1.3.5: - version "1.3.5" - resolved "https://registry.yarnpkg.com/web3-eth/-/web3-eth-1.3.5.tgz#2a3d0db870ef7921942a5d798ba0569175cc4de1" - integrity sha512-5qqDPMMD+D0xRqOV2ePU2G7/uQmhn0FgCEhFzKDMHrssDQJyQLW/VgfA0NLn64lWnuUrGnQStGvNxrWf7MgsfA== - dependencies: - underscore "1.9.1" - web3-core "1.3.5" - web3-core-helpers "1.3.5" - web3-core-method "1.3.5" - web3-core-subscriptions "1.3.5" - web3-eth-abi "1.3.5" - web3-eth-accounts "1.3.5" - web3-eth-contract "1.3.5" - web3-eth-ens "1.3.5" - web3-eth-iban "1.3.5" - web3-eth-personal "1.3.5" - web3-net "1.3.5" - web3-utils "1.3.5" - web3-eth@1.3.6: version "1.3.6" resolved "https://registry.yarnpkg.com/web3-eth/-/web3-eth-1.3.6.tgz#2c650893d540a7a0eb1365dd5b2dca24ac919b7c" @@ -11567,6 +12591,25 @@ web3-eth@1.3.6: web3-net "1.3.6" web3-utils "1.3.6" +web3-eth@1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/web3-eth/-/web3-eth-1.4.0.tgz#6ca2dcbd72d128a225ada1fec0d1e751f8df5200" + integrity sha512-L990eMJeWh4h/Z3M8MJb9HrKq8tqvzdGZ7igdzd6Ba3B/VKgGFAJ/4XIqtLwAJ1Wg5Cj8my60tYY+34c2cLefw== + dependencies: + underscore "1.12.1" + web3-core "1.4.0" + web3-core-helpers "1.4.0" + web3-core-method "1.4.0" + web3-core-subscriptions "1.4.0" + web3-eth-abi "1.4.0" + web3-eth-accounts "1.4.0" + web3-eth-contract "1.4.0" + web3-eth-ens "1.4.0" + web3-eth-iban "1.4.0" + web3-eth-personal "1.4.0" + web3-net "1.4.0" + web3-utils "1.4.0" + web3-net@1.2.11: version "1.2.11" resolved "https://registry.yarnpkg.com/web3-net/-/web3-net-1.2.11.tgz#eda68ef25e5cdb64c96c39085cdb74669aabbe1b" @@ -11576,15 +12619,6 @@ web3-net@1.2.11: web3-core-method "1.2.11" web3-utils "1.2.11" -web3-net@1.3.5: - version "1.3.5" - resolved "https://registry.yarnpkg.com/web3-net/-/web3-net-1.3.5.tgz#06e3465a9fbbeec1240160e2fd66ddb07b6af944" - integrity sha512-usbFbuUpKK8s7jPLGoUzi/WpNnefGFPTj948aJv8BZ04UQA4L/XS5NNkkhk358zNMmhGfEFW8wrWy+0Oy0njtA== - dependencies: - web3-core "1.3.5" - web3-core-method "1.3.5" - web3-utils "1.3.5" - web3-net@1.3.6: version "1.3.6" resolved "https://registry.yarnpkg.com/web3-net/-/web3-net-1.3.6.tgz#a56492e2227475e38db29394f8bac305a2446e41" @@ -11594,6 +12628,15 @@ web3-net@1.3.6: web3-core-method "1.3.6" web3-utils "1.3.6" +web3-net@1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/web3-net/-/web3-net-1.4.0.tgz#eaea1562dc96ddde6f14e823d2b94886091d2049" + integrity sha512-41WkKobL+KnKC0CY0RZ1KhMMyR/hMFGlbHZQac4KtB7ro1UdXeK+RiYX+GzSr1h7j9Dj+dQZqyBs70cxmL9cPQ== + dependencies: + web3-core "1.4.0" + web3-core-method "1.4.0" + web3-utils "1.4.0" + web3-provider-engine@14.2.1: version "14.2.1" resolved "https://registry.yarnpkg.com/web3-provider-engine/-/web3-provider-engine-14.2.1.tgz#ef351578797bf170e08d529cb5b02f8751329b95" @@ -11628,14 +12671,6 @@ web3-providers-http@1.2.11: web3-core-helpers "1.2.11" xhr2-cookies "1.1.0" -web3-providers-http@1.3.5: - version "1.3.5" - resolved "https://registry.yarnpkg.com/web3-providers-http/-/web3-providers-http-1.3.5.tgz#cdada6fb342e08fd75aea249fceb6eee467beffc" - integrity sha512-ZQOmceFjcajEZdiuqciXjijwIYWNmEJ1oxMtbrwB2eGxHRCMXEH2xGRUZuhOFNF88yQC/VXVi14yvYg5ZlFJlA== - dependencies: - web3-core-helpers "1.3.5" - xhr2-cookies "1.1.0" - web3-providers-http@1.3.6: version "1.3.6" resolved "https://registry.yarnpkg.com/web3-providers-http/-/web3-providers-http-1.3.6.tgz#36e8724a7424d52827819d53fd75dbf31f5422c2" @@ -11644,6 +12679,14 @@ web3-providers-http@1.3.6: web3-core-helpers "1.3.6" xhr2-cookies "1.1.0" +web3-providers-http@1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/web3-providers-http/-/web3-providers-http-1.4.0.tgz#2d67f85fda00765c1402aede3d7e6cbacaa3091b" + integrity sha512-A9nLF4XGZfDb1KYYuKRwHY1H90Ee/0I0CqQQEELI0yuY9eca50qdCHEg3sJhvqBIG44JCm83amOGxR8wi+76tQ== + dependencies: + web3-core-helpers "1.4.0" + xhr2-cookies "1.1.0" + web3-providers-ipc@1.2.11: version "1.2.11" resolved "https://registry.yarnpkg.com/web3-providers-ipc/-/web3-providers-ipc-1.2.11.tgz#d16d6c9be1be6e0b4f4536c4acc16b0f4f27ef21" @@ -11653,15 +12696,6 @@ web3-providers-ipc@1.2.11: underscore "1.9.1" web3-core-helpers "1.2.11" -web3-providers-ipc@1.3.5: - version "1.3.5" - resolved "https://registry.yarnpkg.com/web3-providers-ipc/-/web3-providers-ipc-1.3.5.tgz#2f5536abfe03f3824e00dedc614d8f46db72b57f" - integrity sha512-cbZOeb/sALiHjzMolJjIyHla/J5wdL2JKUtRO66Nh/uLALBCpU8JUgzNvpAdJ1ae3+A33+EdFStdzuDYHKtQew== - dependencies: - oboe "2.1.5" - underscore "1.9.1" - web3-core-helpers "1.3.5" - web3-providers-ipc@1.3.6: version "1.3.6" resolved "https://registry.yarnpkg.com/web3-providers-ipc/-/web3-providers-ipc-1.3.6.tgz#cef8d12c1ebb47adce5ebf597f553c623362cb4a" @@ -11671,6 +12705,15 @@ web3-providers-ipc@1.3.6: underscore "1.12.1" web3-core-helpers "1.3.6" +web3-providers-ipc@1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/web3-providers-ipc/-/web3-providers-ipc-1.4.0.tgz#cd14e93e2d22689a26587dd2d2101e575d1e2924" + integrity sha512-ul/tSNUI5anhdBGBV+FWFH9EJgO73/G21haFDEXvTnSJQa9/byj401H/E2Xd8BXGk+2XB+CCGLZBiuAjhhhtTA== + dependencies: + oboe "2.1.5" + underscore "1.12.1" + web3-core-helpers "1.4.0" + web3-providers-ws@1.2.11: version "1.2.11" resolved "https://registry.yarnpkg.com/web3-providers-ws/-/web3-providers-ws-1.2.11.tgz#a1dfd6d9778d840561d9ec13dd453046451a96bb" @@ -11681,16 +12724,6 @@ web3-providers-ws@1.2.11: web3-core-helpers "1.2.11" websocket "^1.0.31" -web3-providers-ws@1.3.5: - version "1.3.5" - resolved "https://registry.yarnpkg.com/web3-providers-ws/-/web3-providers-ws-1.3.5.tgz#7f841ec79358d90c4a803d1291157b5ffb15aeb7" - integrity sha512-zeZ4LMvKhYaJBDCqA//Bzgp4r/T0tNq5U/xvN0axA4YflzF7yqlsbzGwCkcZYDbrUaK3Ltl2uOmvwjbWALOZ1A== - dependencies: - eventemitter3 "4.0.4" - underscore "1.9.1" - web3-core-helpers "1.3.5" - websocket "^1.0.32" - web3-providers-ws@1.3.6: version "1.3.6" resolved "https://registry.yarnpkg.com/web3-providers-ws/-/web3-providers-ws-1.3.6.tgz#e1df617bc89d66165abdf2191da0014c505bfaac" @@ -11701,6 +12734,16 @@ web3-providers-ws@1.3.6: web3-core-helpers "1.3.6" websocket "^1.0.32" +web3-providers-ws@1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/web3-providers-ws/-/web3-providers-ws-1.4.0.tgz#a4db03fc865a73db62bc15c5da37f930517cfe08" + integrity sha512-E5XfF58RLXuCtGiMSXxXEtjceCfPli+I4MDYCKx/J/bDJ6qvLUM2OnnGEmE7pq1Z03h0xh1ZezaB/qoweK3ZIQ== + dependencies: + eventemitter3 "4.0.4" + underscore "1.12.1" + web3-core-helpers "1.4.0" + websocket "^1.0.32" + web3-shh@1.2.11: version "1.2.11" resolved "https://registry.yarnpkg.com/web3-shh/-/web3-shh-1.2.11.tgz#f5d086f9621c9a47e98d438010385b5f059fd88f" @@ -11711,16 +12754,6 @@ web3-shh@1.2.11: web3-core-subscriptions "1.2.11" web3-net "1.2.11" -web3-shh@1.3.5: - version "1.3.5" - resolved "https://registry.yarnpkg.com/web3-shh/-/web3-shh-1.3.5.tgz#af0b8ebca90a3652dbbb90d351395f36ca91f40b" - integrity sha512-aRwzCduXvuGVslLL/Y15VcOHa70Qr2kxZI7UwOzQVhaaOdxuRRvo3AK/cmyln1Tsd54/n93Yk8I3qg5I2+6alw== - dependencies: - web3-core "1.3.5" - web3-core-method "1.3.5" - web3-core-subscriptions "1.3.5" - web3-net "1.3.5" - web3-shh@1.3.6: version "1.3.6" resolved "https://registry.yarnpkg.com/web3-shh/-/web3-shh-1.3.6.tgz#4e3486c7eca5cbdb87f88910948223a5b7ea6c20" @@ -11731,6 +12764,16 @@ web3-shh@1.3.6: web3-core-subscriptions "1.3.6" web3-net "1.3.6" +web3-shh@1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/web3-shh/-/web3-shh-1.4.0.tgz#d22ff8dce16987bef73172191d9e95c3ccf0aa80" + integrity sha512-OZMkMgo+VZnu1ErhIFXW+5ExnPKQg9v8/2DHGVtNEwuC5OHYuAEF5U7MQgbxYJYwbRmxQCt/hA3VwKjnkbmSAA== + dependencies: + web3-core "1.4.0" + web3-core-method "1.4.0" + web3-core-subscriptions "1.4.0" + web3-net "1.4.0" + web3-utils@1.2.11: version "1.2.11" resolved "https://registry.yarnpkg.com/web3-utils/-/web3-utils-1.2.11.tgz#af1942aead3fb166ae851a985bed8ef2c2d95a82" @@ -11745,13 +12788,13 @@ web3-utils@1.2.11: underscore "1.9.1" utf8 "3.0.0" -web3-utils@1.3.5: - version "1.3.5" - resolved "https://registry.yarnpkg.com/web3-utils/-/web3-utils-1.3.5.tgz#14ee2ff1a7a226867698d6eaffd21aa97aed422e" - integrity sha512-5apMRm8ElYjI/92GHqijmaLC+s+d5lgjpjHft+rJSs/dsnX8I8tQreqev0dmU+wzU+2EEe4Sx9a/OwGWHhQv3A== +web3-utils@1.2.9: + version "1.2.9" + resolved "https://registry.yarnpkg.com/web3-utils/-/web3-utils-1.2.9.tgz#abe11735221627da943971ef1a630868fb9c61f3" + integrity sha512-9hcpuis3n/LxFzEVjwnVgvJzTirS2S9/MiNAa7l4WOEoywY+BSNwnRX4MuHnjkh9NY25B6QOjuNG6FNnSjTw1w== dependencies: - bn.js "^4.11.9" - eth-lib "0.2.8" + bn.js "4.11.8" + eth-lib "0.2.7" ethereum-bloom-filters "^1.0.6" ethjs-unit "0.1.6" number-to-bn "1.7.0" @@ -11773,6 +12816,20 @@ web3-utils@1.3.6, web3-utils@^1.0.0-beta.31: underscore "1.12.1" utf8 "3.0.0" +web3-utils@1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/web3-utils/-/web3-utils-1.4.0.tgz#e8cb381c81b242dc1d4ecb397200356d404410e6" + integrity sha512-b8mEhwh/J928Xk+SQFjtqrR2EGPhpknWLcIt9aCpVPVRXiqjUGo/kpOHKz0azu9c6/onEJ9tWXZt0cVjmH0N5Q== + 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.12.1" + utf8 "3.0.0" + web3@1.2.11: version "1.2.11" resolved "https://registry.yarnpkg.com/web3/-/web3-1.2.11.tgz#50f458b2e8b11aa37302071c170ed61cff332975" @@ -11786,20 +12843,7 @@ web3@1.2.11: web3-shh "1.2.11" web3-utils "1.2.11" -web3@1.3.5: - version "1.3.5" - resolved "https://registry.yarnpkg.com/web3/-/web3-1.3.5.tgz#ef4c3a2241fdd74f2f7794e839f30bc6f9814e46" - integrity sha512-UyQW/MT5EIGBrXPCh/FDIaD7RtJTn5/rJUNw2FOglp0qoXnCQHNKvntiR1ylztk05fYxIF6UgsC76IrazlKJjw== - dependencies: - web3-bzz "1.3.5" - web3-core "1.3.5" - web3-eth "1.3.5" - web3-eth-personal "1.3.5" - web3-net "1.3.5" - web3-shh "1.3.5" - web3-utils "1.3.5" - -web3@^1.0.0-beta.34: +web3@1.3.6: version "1.3.6" resolved "https://registry.yarnpkg.com/web3/-/web3-1.3.6.tgz#599425461c3f9a8cbbefa70616438995f4a064cc" integrity sha512-jEpPhnL6GDteifdVh7ulzlPrtVQeA30V9vnki9liYlUvLV82ZM7BNOQJiuzlDePuE+jZETZSP/0G/JlUVt6pOA== @@ -11812,6 +12856,55 @@ web3@^1.0.0-beta.34: web3-shh "1.3.6" web3-utils "1.3.6" +web3@^1.0.0-beta.34: + version "1.4.0" + resolved "https://registry.yarnpkg.com/web3/-/web3-1.4.0.tgz#717c01723226daebab9274be5cb56644de860688" + integrity sha512-faT3pIX+1tuo+wqmUFQPe10MUGaB1UvRYxw9dmVJFLxaRAIfXErSilOf3jFhSwKbbPNkwG0bTiudCLN9JgeS7A== + dependencies: + web3-bzz "1.4.0" + web3-core "1.4.0" + web3-eth "1.4.0" + web3-eth-personal "1.4.0" + web3-net "1.4.0" + web3-shh "1.4.0" + web3-utils "1.4.0" + +webpack-sources@^1.0.1: + version "1.4.3" + resolved "https://registry.yarnpkg.com/webpack-sources/-/webpack-sources-1.4.3.tgz#eedd8ec0b928fbf1cbfe994e22d2d890f330a933" + integrity sha512-lgTS3Xhv1lCOKo7SA5TjKXMjpSM4sBjNV5+q2bqesbSPs5FjGmU6jjtBSkX9b4qW87vDIsCIlUPOEhbZrMdjeQ== + dependencies: + source-list-map "^2.0.0" + source-map "~0.6.1" + +webpack@^3.0.0: + version "3.12.0" + resolved "https://registry.yarnpkg.com/webpack/-/webpack-3.12.0.tgz#3f9e34360370602fcf639e97939db486f4ec0d74" + integrity sha512-Sw7MdIIOv/nkzPzee4o0EdvCuPmxT98+vVpIvwtcwcF1Q4SDSNp92vwcKc4REe7NItH9f1S4ra9FuQ7yuYZ8bQ== + dependencies: + acorn "^5.0.0" + acorn-dynamic-import "^2.0.0" + ajv "^6.1.0" + ajv-keywords "^3.1.0" + async "^2.1.2" + enhanced-resolve "^3.4.0" + escope "^3.6.0" + interpret "^1.0.0" + json-loader "^0.5.4" + json5 "^0.5.1" + loader-runner "^2.3.0" + loader-utils "^1.1.0" + memory-fs "~0.4.1" + mkdirp "~0.5.0" + node-libs-browser "^2.0.0" + source-map "^0.5.3" + supports-color "^4.2.1" + tapable "^0.2.7" + uglifyjs-webpack-plugin "^0.4.6" + watchpack "^1.4.0" + webpack-sources "^1.0.1" + yargs "^8.0.2" + websocket@1.0.32: version "1.0.32" resolved "https://registry.yarnpkg.com/websocket/-/websocket-1.0.32.tgz#1f16ddab3a21a2d929dec1687ab21cfdc6d3dbb1" @@ -11901,6 +12994,11 @@ wide-align@1.1.3: dependencies: string-width "^1.0.2 || 2" +window-size@0.1.0: + version "0.1.0" + resolved "https://registry.yarnpkg.com/window-size/-/window-size-0.1.0.tgz#5438cd2ea93b202efa3a19fe8887aee7c94f9c9d" + integrity sha1-VDjNLqk7IC76Ohn+iIeu58lPnJ0= + window-size@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/window-size/-/window-size-0.2.0.tgz#b4315bb4214a3d7058ebeee892e13fa24d98b075" @@ -11911,6 +13009,11 @@ word-wrap@^1.2.3, word-wrap@~1.2.3: resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.3.tgz#610636f6b1f703891bd34771ccb17fb93b47079c" integrity sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ== +wordwrap@0.0.2: + version "0.0.2" + resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-0.0.2.tgz#b79669bb42ecb409f83d583cad52ca17eaa1643f" + integrity sha1-t5Zpu0LstAn4PVg8rVLKF+qhZD8= + wrap-ansi@^2.0.0: version "2.1.0" resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-2.1.0.tgz#d8fc3d284dd05794fe84973caecdd1cf824fdd85" @@ -11958,11 +13061,6 @@ write@1.0.3: dependencies: mkdirp "^0.5.1" -ws@7.2.3: - version "7.2.3" - resolved "https://registry.yarnpkg.com/ws/-/ws-7.2.3.tgz#a5411e1fb04d5ed0efee76d26d5c46d830c39b46" - integrity sha512-HTDl9G9hbkNDk98naoR/cHDws7+EyYMOdL1BmjsZXRUjf7d+MficC4B7HLUPlSiho0vg+CWKrGIt/VJBd1xunQ== - ws@7.4.6: version "7.4.6" resolved "https://registry.yarnpkg.com/ws/-/ws-7.4.6.tgz#5654ca8ecdeee47c33a9a4bf6d28e2be2980377c" @@ -11978,16 +13076,16 @@ ws@^3.0.0: ultron "~1.1.0" ws@^5.1.1: - version "5.2.2" - resolved "https://registry.yarnpkg.com/ws/-/ws-5.2.2.tgz#dffef14866b8e8dc9133582514d1befaf96e980f" - integrity sha512-jaHFD6PFv6UgoIVda6qZllptQsMlDEJkTQcybzzXDYM1XO9Y8em691FGMPmM46WGyLU4z9KMgQN+qrux/nhlHA== + 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.2.1: - version "7.4.5" - resolved "https://registry.yarnpkg.com/ws/-/ws-7.4.5.tgz#a484dd851e9beb6fdb420027e3885e8ce48986c1" - integrity sha512-xzyu3hFvomRfXKH8vOFMU3OguG6oOvhXMo3xsGy3xWExqaM2dxBbVxuD99O7m3ZUFMvvscsZDqxfgMaRr/Nr1g== +ws@^7.4.6: + version "7.5.0" + resolved "https://registry.yarnpkg.com/ws/-/ws-7.5.0.tgz#0033bafea031fb9df041b2026fc72a571ca44691" + integrity sha512-6ezXvzOZupqKj4jUqbQ9tXuJNo+BR2gU8fFRk3XCP3e0G6WT414u5ELe6Y0vtp7kmSJ3F7YWObSNr1ESsgi4vw== xhr-request-promise@^0.1.2: version "0.1.3" @@ -12078,7 +13176,7 @@ yaml@^1.10.0: resolved "https://registry.yarnpkg.com/yaml/-/yaml-1.10.2.tgz#2301c5ffbf12b467de8da2333a459e29e7920e4b" integrity sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg== -yargs-parser@13.1.2, yargs-parser@^13.1.2: +yargs-parser@13.1.2, yargs-parser@^13.1.0, yargs-parser@^13.1.2: version "13.1.2" resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-13.1.2.tgz#130f09702ebaeef2650d54ce6e3e5706f7a4fb38" integrity sha512-3lbsNRf/j+A4QuSZfDRA7HRSfWrzO0YjqTJd5kjAq37Zep1CEgaYmrH9Q3GwPiB9cHyd1Y1UwggGhJGoxipbzg== @@ -12094,6 +13192,20 @@ yargs-parser@^2.4.1: camelcase "^3.0.0" lodash.assign "^4.0.6" +yargs-parser@^7.0.0: + version "7.0.0" + resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-7.0.0.tgz#8d0ac42f16ea55debd332caf4c4038b3e3f5dfd9" + integrity sha1-jQrELxbqVd69MyyvTEA4s+P139k= + dependencies: + camelcase "^4.1.0" + +yargs-parser@^8.1.0: + version "8.1.0" + resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-8.1.0.tgz#f1376a33b6629a5d063782944da732631e966950" + integrity sha512-yP+6QqN8BmrgW2ggLtTbdrOyBNSI7zBa4IykmiV5R1wl1JWNxQvWhMfMdmzIYtKU7oP3OOInY/tl2ov3BDjnJQ== + dependencies: + camelcase "^4.1.0" + yargs-unparser@1.6.0: version "1.6.0" resolved "https://registry.yarnpkg.com/yargs-unparser/-/yargs-unparser-1.6.0.tgz#ef25c2c769ff6bd09e4b0f9d7c605fb27846ea9f" @@ -12103,6 +13215,23 @@ yargs-unparser@1.6.0: lodash "^4.17.15" yargs "^13.3.0" +yargs@13.2.4: + version "13.2.4" + resolved "https://registry.yarnpkg.com/yargs/-/yargs-13.2.4.tgz#0b562b794016eb9651b98bd37acf364aa5d6dc83" + integrity sha512-HG/DWAJa1PAnHT9JAhNa8AbAv3FPaiLzioSjCcmuXXhP8MlpHO5vwls4g4j6n30Z74GVQj8Xa62dWVx1QCGklg== + dependencies: + cliui "^5.0.0" + find-up "^3.0.0" + get-caller-file "^2.0.1" + os-locale "^3.1.0" + 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.0" + yargs@13.3.2, yargs@^13.3.0: version "13.3.2" resolved "https://registry.yarnpkg.com/yargs/-/yargs-13.3.2.tgz#ad7ffefec1aa59565ac915f82dccb38a9c31a2dd" @@ -12119,6 +13248,24 @@ yargs@13.3.2, yargs@^13.3.0: y18n "^4.0.0" yargs-parser "^13.1.2" +yargs@^10.0.3: + version "10.1.2" + resolved "https://registry.yarnpkg.com/yargs/-/yargs-10.1.2.tgz#454d074c2b16a51a43e2fb7807e4f9de69ccb5c5" + integrity sha512-ivSoxqBGYOqQVruxD35+EyCFDYNEFL/Uo6FcOnz+9xZdZzK0Zzw4r4KhbrME1Oo2gOggwJod2MnsdamSG7H9ig== + dependencies: + cliui "^4.0.0" + decamelize "^1.1.1" + find-up "^2.1.0" + get-caller-file "^1.0.1" + os-locale "^2.0.0" + require-directory "^2.1.1" + require-main-filename "^1.0.1" + set-blocking "^2.0.0" + string-width "^2.0.0" + which-module "^2.0.0" + y18n "^3.2.1" + yargs-parser "^8.1.0" + yargs@^4.7.1: version "4.8.1" resolved "https://registry.yarnpkg.com/yargs/-/yargs-4.8.1.tgz#c0c42924ca4aaa6b0e6da1739dfb216439f9ddc0" @@ -12139,6 +13286,35 @@ yargs@^4.7.1: y18n "^3.2.1" yargs-parser "^2.4.1" +yargs@^8.0.2: + version "8.0.2" + resolved "https://registry.yarnpkg.com/yargs/-/yargs-8.0.2.tgz#6299a9055b1cefc969ff7e79c1d918dceb22c360" + integrity sha1-YpmpBVsc78lp/355wdkY3Osiw2A= + dependencies: + camelcase "^4.1.0" + cliui "^3.2.0" + decamelize "^1.1.1" + get-caller-file "^1.0.1" + os-locale "^2.0.0" + read-pkg-up "^2.0.0" + require-directory "^2.1.1" + require-main-filename "^1.0.1" + set-blocking "^2.0.0" + string-width "^2.0.0" + which-module "^2.0.0" + y18n "^3.2.1" + yargs-parser "^7.0.0" + +yargs@~3.10.0: + version "3.10.0" + resolved "https://registry.yarnpkg.com/yargs/-/yargs-3.10.0.tgz#f7ee7bd857dd7c1d2d38c0e74efbd681d1431fd1" + integrity sha1-9+572FfdfB0tOMDnTvvWgdFDH9E= + dependencies: + camelcase "^1.0.2" + cliui "^2.1.0" + decamelize "^1.0.0" + window-size "0.1.0" + yn@3.1.1: version "3.1.1" resolved "https://registry.yarnpkg.com/yn/-/yn-3.1.1.tgz#1e87401a09d767c1d5eab26a6e4c185182d2eb50"